diff --git a/src/actions/sdk/publish.ts b/src/actions/sdk/publish.ts
index d62c3e68..58732d64 100644
--- a/src/actions/sdk/publish.ts
+++ b/src/actions/sdk/publish.ts
@@ -10,7 +10,6 @@ import { ProfileId } from '../../types/publish/profile-id.js';
 import { SemVersion } from '../../types/publish/version.js';
 import { Language } from '../../types/sdk/generate.js';
 import { PublishingProfile } from '../../types/publish/publishing-profile.js';
-import { PackageSettingsConfiguration } from '../../types/publish/package-settings-configuration.js';
 import { PackageSettingsContext } from '../../types/package-settings-context.js';
 import { TempContext } from '../../types/temp-context.js';
 import { ActionResult } from '../action-result.js';
@@ -38,14 +37,13 @@ export class SdkPublishAction {
     onPublishSdkError: (errorMessage: string) => void
   ): Promise<ActionResult<PublishingInfo>> => {
     return await withDirPath(async (tempDirectory) => {
-      const packageConfiguration = publishingProfile.getPackageConfigurationForLanguage(language);
+      const packageConfigurationData = publishingProfile.getPackageConfigurationDataForLanguage(language);
       let packageSettingsDirectory: DirectoryPath | undefined;
 
-      if (packageConfiguration !== null && packageConfiguration.isEnabled) {
-        const packageSettingsConfiguration = PackageSettingsConfiguration.create(language, packageConfiguration);
+      if (packageConfigurationData) {
         packageSettingsDirectory = tempDirectory.join('package-settings');
         const packageSettingsContext = new PackageSettingsContext(packageSettingsDirectory);
-        await packageSettingsContext.writeConfiguration(packageSettingsConfiguration, language);
+        await packageSettingsContext.writeConfiguration(packageConfigurationData, language);
       }
 
       const sdkGenerateAction = new GenerateAction(this.configDir, this.commandMetadata);
diff --git a/src/types/publish-api/publishing-profile-item.ts b/src/types/publish-api/publishing-profile-item.ts
index 4c271c67..51c273bd 100644
--- a/src/types/publish-api/publishing-profile-item.ts
+++ b/src/types/publish-api/publishing-profile-item.ts
@@ -10,17 +10,16 @@ export interface KeyValueItem {
   value: string;
 }
 
-export interface BaseConfigurationItem {
+export interface GitConfigurationItem {
   isEnabled: boolean;
   credentialsId: string;
-}
-
-export interface GitConfigurationItem extends BaseConfigurationItem {
   repositoryName: string;
   branch: string;
 }
 
-export interface CSharpConfigurationItem extends BaseConfigurationItem {
+export interface CSharpConfigurationItem {
+  isEnabled: boolean;
+  credentialsId: string;
   packageId: string;
   authors: string | null;
   description: string | null;
@@ -34,7 +33,9 @@ export interface CSharpConfigurationItem extends BaseConfigurationItem {
   copyright: string | null;
 }
 
-export interface GoConfigurationItem extends BaseConfigurationItem {
+export interface GoConfigurationItem {
+  isEnabled: boolean;
+  credentialsId: string;
   packageName: string;
 }
 
@@ -61,7 +62,9 @@ export interface JavaScm {
   url: string;
 }
 
-export interface JavaConfigurationItem extends BaseConfigurationItem {
+export interface JavaConfigurationItem {
+  isEnabled: boolean;
+  credentialsId: string;
   groupId: string;
   artifactId: string;
   name: string;
@@ -91,7 +94,9 @@ export interface PhpSupport {
   rss: string | null;
 }
 
-export interface PhpConfigurationItem extends BaseConfigurationItem {
+export interface PhpConfigurationItem {
+  isEnabled: boolean;
+  credentialsId: string;
   gitCredentialsId: string;
   repositoryName: string;
   branchName: string;
@@ -111,7 +116,9 @@ export interface PythonPerson {
   name: string | null;
 }
 
-export interface PythonConfigurationItem extends BaseConfigurationItem {
+export interface PythonConfigurationItem {
+  isEnabled: boolean;
+  credentialsId: string;
   name: string;
   description: string | null;
   authors: PythonPerson[];
@@ -121,7 +128,9 @@ export interface PythonConfigurationItem extends BaseConfigurationItem {
   urls: KeyValueItem[];
 }
 
-export interface RubyConfigurationItem extends BaseConfigurationItem {
+export interface RubyConfigurationItem {
+  isEnabled: boolean;
+  credentialsId: string;
   name: string;
   authors: string[];
   summary: string;
@@ -150,7 +159,9 @@ export interface TsRepository {
   directory: string | null;
 }
 
-export interface TypeScriptConfigurationItem extends BaseConfigurationItem {
+export interface TypeScriptConfigurationItem {
+  isEnabled: boolean;
+  credentialsId: string;
   name: string;
   author: TsPerson;
   description: string | null;
@@ -182,12 +193,6 @@ export interface PublishingProfileItem {
   typeScriptGitConfiguration: GitConfigurationItem | null;
 }
 
-export interface LanguagePublishingConfig {
-  language: Language;
-  packageConfig: BaseConfigurationItem | null;
-  gitConfig: BaseConfigurationItem | null;
-}
-
 export interface PublishingProfileWithLanguages {
   profile: PublishingProfileItem;
   enabledLanguages: Language[];
diff --git a/src/types/publish/package-settings-configuration.ts b/src/types/publish/package-settings-configuration.ts
index c5c2bd32..35550b6b 100644
--- a/src/types/publish/package-settings-configuration.ts
+++ b/src/types/publish/package-settings-configuration.ts
@@ -1,25 +1,23 @@
-import { Language } from '../sdk/generate.js';
 import {
-  BaseConfigurationItem,
-  CSharpConfigurationItem,
-  JavaConfigurationItem,
   JavaDeveloper,
   JavaDistributionManagement,
   JavaScm,
-  KeyValueItem,
   PhpAuthor,
-  PhpConfigurationItem,
   PhpSupport,
-  PythonConfigurationItem,
   PythonPerson,
-  RubyConfigurationItem,
   TsBugs,
   TsPerson,
-  TsRepository,
-  TypeScriptConfigurationItem
+  TsRepository
 } from '../publish-api/publishing-profile-item.js';
 
-interface CSharpPackageConfiguration {
+export interface GitConfiguration {
+  isEnabled: boolean;
+  credentialsId: string;
+  repositoryName: string;
+  branch: string;
+}
+
+export interface CSharpPackageConfiguration {
   packageId: string;
   authors: string | null;
   description: string | null;
@@ -33,7 +31,7 @@ interface CSharpPackageConfiguration {
   copyright: string | null;
 }
 
-interface JavaPackageConfiguration {
+export interface JavaPackageConfiguration {
   groupId: string;
   artifactId: string;
   name: string;
@@ -44,7 +42,7 @@ interface JavaPackageConfiguration {
   scm: JavaScm;
 }
 
-interface PhpPackageConfiguration {
+export interface PhpPackageConfiguration {
   vendorName: string;
   projectName: string;
   description: string;
@@ -55,29 +53,29 @@ interface PhpPackageConfiguration {
   support: PhpSupport;
 }
 
-interface PythonPackageConfiguration {
+export interface PythonPackageConfiguration {
   name: string;
   description: string | null;
   authors: PythonPerson[];
   maintainers: PythonPerson[];
   keywords: string[];
   classifiers: string[];
-  urls: KeyValueItem[];
+  urls: Record<string, string>;
 }
 
-interface RubyPackageConfiguration {
+export interface RubyPackageConfiguration {
   name: string;
   authors: string[];
   summary: string;
   description: string | null;
   email: string[];
   homepage: string | null;
-  metadata: KeyValueItem[];
+  metadata: Record<string, string>;
   postInstallMessage: string | null;
   requirements: string[];
 }
 
-interface TypeScriptPackageConfiguration {
+export interface TypeScriptPackageConfiguration {
   name: string;
   author: TsPerson;
   description: string | null;
@@ -88,72 +86,15 @@ interface TypeScriptPackageConfiguration {
   repository: TsRepository;
 }
 
+export interface GoPackageConfiguration {
+  packageName: string;
+}
+
 export type PackageConfigurationData =
   | CSharpPackageConfiguration
   | JavaPackageConfiguration
   | PhpPackageConfiguration
   | PythonPackageConfiguration
   | RubyPackageConfiguration
-  | TypeScriptPackageConfiguration;
-
-export class PackageSettingsConfiguration {
-  public static create(language: Language, config: BaseConfigurationItem): PackageConfigurationData {
-    switch (language) {
-      case Language.CSHARP: {
-        const {
-          packageId,
-          authors,
-          description,
-          title,
-          packageTags,
-          repositoryUrl,
-          repositoryType,
-          packageProjectUrl,
-          packageIcon,
-          packageReleaseNotes,
-          copyright
-        } = config as CSharpConfigurationItem;
-        return {
-          packageId,
-          authors,
-          description,
-          title,
-          packageTags,
-          repositoryUrl,
-          repositoryType,
-          packageProjectUrl,
-          packageIcon,
-          packageReleaseNotes,
-          copyright
-        };
-      }
-      case Language.JAVA: {
-        const { groupId, artifactId, name, description, url, developers, distributionManagement, scm } =
-          config as JavaConfigurationItem;
-        return { groupId, artifactId, name, description, url, developers, distributionManagement, scm };
-      }
-      case Language.PHP: {
-        const { vendorName, projectName, description, type, keywords, homepage, authors, support } =
-          config as PhpConfigurationItem;
-        return { vendorName, projectName, description, type, keywords, homepage, authors, support };
-      }
-      case Language.PYTHON: {
-        const { name, description, authors, maintainers, keywords, classifiers, urls } =
-          config as PythonConfigurationItem;
-        return { name, description, authors, maintainers, keywords, classifiers, urls };
-      }
-      case Language.RUBY: {
-        const { name, authors, summary, description, email, homepage, metadata, postInstallMessage, requirements } =
-          config as RubyConfigurationItem;
-        return { name, authors, summary, description, email, homepage, metadata, postInstallMessage, requirements };
-      }
-      case Language.TYPESCRIPT: {
-        const { name, author, description, contributors, bugs, keywords, homepage, repository } =
-          config as TypeScriptConfigurationItem;
-        return { name, author, description, contributors, bugs, keywords, homepage, repository };
-      }
-      case Language.GO:
-        return {} as PackageConfigurationData;
-    }
-  }
-}
+  | TypeScriptPackageConfiguration
+  | GoPackageConfiguration;
diff --git a/src/types/publish/publishing-profile.ts b/src/types/publish/publishing-profile.ts
index 88c081cc..7f1398d7 100644
--- a/src/types/publish/publishing-profile.ts
+++ b/src/types/publish/publishing-profile.ts
@@ -1,18 +1,62 @@
 import { Language } from '../sdk/generate.js';
 import {
-  BaseConfigurationItem,
-  LanguagePublishingConfig,
+  CSharpConfigurationItem,
+  GoConfigurationItem,
+  JavaConfigurationItem,
+  PhpConfigurationItem,
   PublishingProfileItem,
   PublishingProfileSummaryGroup,
   PublishingProfileWithLanguagesGroup,
-  PublishType
+  PythonConfigurationItem,
+  RubyConfigurationItem,
+  TypeScriptConfigurationItem,
+  PublishType,
 } from '../publish-api/publishing-profile-item.js';
+import { 
+  CSharpPackageConfiguration,
+  GitConfiguration,
+  GoPackageConfiguration,
+  JavaPackageConfiguration,
+  PackageConfigurationData,
+  PhpPackageConfiguration,
+  PythonPackageConfiguration,
+  RubyPackageConfiguration,
+  TypeScriptPackageConfiguration 
+} from './package-settings-configuration.js';
 
 export class PublishingProfile {
-  private readonly item: PublishingProfileItem;
+  private readonly profile: PublishingProfileItem;
+  private readonly languageConfigs: Partial<Record<Language, PackageConfigurationData>>;
+  private readonly gitConfigs: Partial<Record<Language, GitConfiguration>>;
 
-  private constructor(item: PublishingProfileItem) {
-    this.item = item;
+  private constructor(profile: PublishingProfileItem) {
+    this.profile = profile;
+    this.languageConfigs = Object.fromEntries(
+      (
+        [
+          [Language.CSHARP, profile.cSharpConfiguration?.isEnabled ? PublishingProfile.createCSharpConfiguration(profile.cSharpConfiguration) : undefined],
+          [Language.GO, profile.goConfiguration?.isEnabled ? PublishingProfile.createGoConfiguration(profile.goConfiguration) : undefined],
+          [Language.JAVA, profile.javaConfiguration?.isEnabled ? PublishingProfile.createJavaConfiguration(profile.javaConfiguration) : undefined],
+          [Language.PHP, profile.phpConfiguration?.isEnabled ? PublishingProfile.createPhpConfiguration(profile.phpConfiguration) : undefined],
+          [Language.PYTHON, profile.pythonConfiguration?.isEnabled ? PublishingProfile.createPythonConfiguration(profile.pythonConfiguration) : undefined],
+          [Language.RUBY, profile.rubyConfiguration?.isEnabled ? PublishingProfile.createRubyConfiguration(profile.rubyConfiguration) : undefined],
+          [Language.TYPESCRIPT, profile.typeScriptConfiguration?.isEnabled ? PublishingProfile.createTypeScriptConfiguration(profile.typeScriptConfiguration) : undefined]
+        ] as [Language, PackageConfigurationData | undefined][]
+      ).filter(([, data]) => data !== undefined)
+    );
+    this.gitConfigs = Object.fromEntries(
+      (
+        [
+          [Language.CSHARP, profile.cSharpGitConfiguration?.isEnabled ? profile.cSharpGitConfiguration : undefined],
+          [Language.GO, profile.goGitConfiguration?.isEnabled ? profile.goGitConfiguration : undefined],
+          [Language.JAVA, profile.javaGitConfiguration?.isEnabled ? profile.javaGitConfiguration : undefined],
+          [Language.PHP, profile.phpGitConfiguration?.isEnabled ? profile.phpGitConfiguration : undefined],
+          [Language.PYTHON, profile.pythonGitConfiguration?.isEnabled ? profile.pythonGitConfiguration : undefined],
+          [Language.RUBY, profile.rubyGitConfiguration?.isEnabled ? profile.rubyGitConfiguration : undefined],
+          [Language.TYPESCRIPT, profile.typeScriptGitConfiguration?.isEnabled ? profile.typeScriptGitConfiguration : undefined]
+        ] as [Language, GitConfiguration | undefined][]
+      ).filter(([, config]) => config !== undefined)
+    );
   }
 
   public static create(item: PublishingProfileItem): PublishingProfile {
@@ -20,31 +64,25 @@ export class PublishingProfile {
   }
 
   public toString(): string {
-    return this.item.name;
+    return this.profile.name;
   }
 
   public hasEnabledLanguages(): boolean {
-    const languageConfigs = this.getLanguageConfigs();
-    return languageConfigs.some(({ packageConfig, gitConfig }) => packageConfig?.isEnabled || gitConfig?.isEnabled);
+    return Object.keys(this.languageConfigs).length > 0 || Object.keys(this.gitConfigs).length > 0;
   }
 
   public isLanguageEnabled(language: Language): boolean {
-    const { packageConfig, gitConfig } = this.getLanguageConfig(language);
-    return packageConfig?.isEnabled === true || gitConfig?.isEnabled === true;
+    return language in this.languageConfigs || language in this.gitConfigs;
   }
 
   public getEnabledLanguages(): Language[] {
-    const languageConfigs = this.getLanguageConfigs();
-    return languageConfigs
-      .filter(({ packageConfig, gitConfig }) => packageConfig?.isEnabled || gitConfig?.isEnabled)
-      .map(({ language }) => language);
-  }
+  return [...new Set([...Object.keys(this.languageConfigs), ...Object.keys(this.gitConfigs)])] as Language[];
+}
 
   public getPublishTypesForLanguage(language: Language): PublishType[] {
-    const { packageConfig, gitConfig } = this.getLanguageConfig(language);
     const types: PublishType[] = [];
-    if (gitConfig?.isEnabled === true) types.push(PublishType.SourceCodePublishing);
-    if (packageConfig?.isEnabled === true) types.push(PublishType.PackagePublishing);
+    if (language in this.gitConfigs) types.push(PublishType.SourceCodePublishing);
+    if (language in this.languageConfigs) types.push(PublishType.PackagePublishing);
     return types;
   }
 
@@ -55,70 +93,111 @@ export class PublishingProfile {
 
   public toPublishingProfileSummaryGroup(): PublishingProfileSummaryGroup {
     return {
-      apiGroupName: this.item.apiGroupName,
-      profiles: [{ name: this.item.name, id: this.item.id, enabledLanguages: this.getEnabledLanguages() }]
+      apiGroupName: this.profile.apiGroupName,
+      profiles: [{ name: this.profile.name, id: this.profile.id, enabledLanguages: this.getEnabledLanguages() }]
     };
   }
 
   public toPublishingProfileWithLanguagesGroup(): PublishingProfileWithLanguagesGroup {
     return {
-      apiGroupName: this.item.apiGroupName,
-      profiles: [{ profile: this.item, enabledLanguages: this.getEnabledLanguages() }]
+      apiGroupName: this.profile.apiGroupName,
+      profiles: [
+        {
+          profile: this.profile,
+          enabledLanguages: this.getEnabledLanguages()
+        }
+      ]
     };
   }
 
-  public getPackageConfigurationForLanguage(language: Language): BaseConfigurationItem | null {
-    switch (language) {
-      case Language.CSHARP:
-        return this.item.cSharpConfiguration;
-      case Language.JAVA:
-        return this.item.javaConfiguration;
-      case Language.GO:
-        return this.item.goConfiguration;
-      case Language.RUBY:
-        return this.item.rubyConfiguration;
-      case Language.PHP:
-        return this.item.phpConfiguration;
-      case Language.PYTHON:
-        return this.item.pythonConfiguration;
-      case Language.TYPESCRIPT:
-        return this.item.typeScriptConfiguration;
-    }
-  }
-
-  private getLanguageConfigs(): LanguagePublishingConfig[] {
-    return [
-      {
-        language: Language.CSHARP,
-        packageConfig: this.item.cSharpConfiguration,
-        gitConfig: this.item.cSharpGitConfiguration
-      },
-      {
-        language: Language.JAVA,
-        packageConfig: this.item.javaConfiguration,
-        gitConfig: this.item.javaGitConfiguration
-      },
-      { language: Language.GO, packageConfig: this.item.goConfiguration, gitConfig: this.item.goGitConfiguration },
-      { language: Language.PHP, packageConfig: this.item.phpConfiguration, gitConfig: this.item.phpGitConfiguration },
-      {
-        language: Language.PYTHON,
-        packageConfig: this.item.pythonConfiguration,
-        gitConfig: this.item.pythonGitConfiguration
-      },
-      {
-        language: Language.RUBY,
-        packageConfig: this.item.rubyConfiguration,
-        gitConfig: this.item.rubyGitConfiguration
-      },
-      {
-        language: Language.TYPESCRIPT,
-        packageConfig: this.item.typeScriptConfiguration,
-        gitConfig: this.item.typeScriptGitConfiguration
-      }
-    ];
-  }
-
-  private getLanguageConfig(language: Language): LanguagePublishingConfig {
-    return this.getLanguageConfigs().find((lc) => lc.language === language)!;
+  public getPackageConfigurationDataForLanguage(language: Language): PackageConfigurationData | undefined {
+    return this.languageConfigs[language];
+  }
+
+  private static createCSharpConfiguration(config: CSharpConfigurationItem): CSharpPackageConfiguration {
+    return  {
+          packageId: config.packageId,
+          authors: config.authors,
+          description: config.description,
+          title: config.title,
+          packageTags: config.packageTags,
+          repositoryUrl: config.repositoryUrl,
+          repositoryType: config.repositoryType,
+          packageProjectUrl: config.packageProjectUrl,
+          packageIcon: config.packageIcon,
+          packageReleaseNotes: config.packageReleaseNotes,
+          copyright: config.copyright
+        };
+  }
+
+  private static createJavaConfiguration(config: JavaConfigurationItem): JavaPackageConfiguration {
+    return {
+          groupId: config.groupId,
+          artifactId: config.artifactId,
+          name: config.name,
+          description: config.description,
+          url: config.url,
+          developers: config.developers,
+          distributionManagement: config.distributionManagement,
+          scm: config.scm
+        };
+  }
+
+  private static createPhpConfiguration(config: PhpConfigurationItem): PhpPackageConfiguration {
+    return {
+          vendorName: config.vendorName,
+          projectName: config.projectName,
+          description: config.description,
+          type: config.type,
+          keywords: config.keywords,
+          homepage: config.homepage,
+          authors: config.authors,
+          support: config.support
+        };
+  }
+
+  private static createPythonConfiguration(config: PythonConfigurationItem): PythonPackageConfiguration {
+    return {
+          name: config.name,
+          description: config.description,
+          authors: config.authors,
+          maintainers: config.maintainers,
+          keywords: config.keywords,
+          classifiers: config.classifiers,
+          urls: Object.fromEntries(config.urls.map(({ key, value }) => [key, value]))
+        };
+  }
+
+  private static createRubyConfiguration(config: RubyConfigurationItem) : RubyPackageConfiguration {
+    return  {
+          name: config.name,
+          authors: config.authors,
+          summary: config.summary,
+          description: config.description,
+          email: config.email,
+          homepage: config.homepage,
+          metadata: Object.fromEntries(config.metadata.map(({ key, value }) => [key, value])),
+          postInstallMessage: config.postInstallMessage,
+          requirements: config.requirements
+        };
+  }
+
+  private static createTypeScriptConfiguration(config: TypeScriptConfigurationItem): TypeScriptPackageConfiguration {
+    return  {
+          name: config.name,
+          author: config.author,
+          description: config.description,
+          contributors: config.contributors,
+          bugs: config.bugs,
+          homepage: config.homepage,
+          keywords: config.keywords,
+          repository: config.repository,
+        };
+  }
+
+  private static createGoConfiguration(config: GoConfigurationItem): GoPackageConfiguration {
+    return {
+          packageName: config.packageName
+        };
   }
 }