@postman/sdk-config 0.0.1 → 0.0.3

package/README.md

@@ -64,7 +64,76 @@ npm pack --dry-run
 - Breaking wire changes get a new schema directory and discriminator such as `sdk-config-ir/v2`.
 - Keep the previous version exported while consumers migrate.
 
-Release automation is intentionally not included in the initial scaffold. It will be added and
-validated separately once the repository and its `develop` → `main` release process are established.
+### Manual release process
+
+Release automation is intentionally deferred while the tagging and publishing process is reviewed
+with Postman's security team. Until that process is established, use the following manual release
+procedure. The commands use `1.1.0` as an example; replace it consistently with the version being
+released.
+
+#### 1. Prepare a release branch from develop
+
+Normal feature pull requests target `develop`. Start the release from an up-to-date `develop`
+branch, update the version without creating a tag, and run the complete check suite:
+
+```sh
+git switch develop
+git pull --ff-only origin develop
+git switch -c release/v1.1.0
+npm version 1.1.0 --no-git-tag-version
+npm run check
+git add package.json package-lock.json
+git commit -m "release: v1.1.0"
+git push -u origin release/v1.1.0
+```
+
+Open a pull request from `release/v1.1.0` into `main`. Review the version change, wait for required
+checks and approvals, and merge it. The release branch isolates the version bump and preserves the
+exact `develop` snapshot being reviewed, while work can continue independently on `develop`.
+
+#### 2. Merge main back into develop
+
+The publishing workflow requires the tagged commit to be in the history of the repository's default
+branch, `develop`. After the release pull request is merged, create a synchronization branch from
+the latest `develop` and merge the released `main` into it:
+
+```sh
+git fetch origin
+git switch -c chore/merge-main-after-v1.1.0 origin/develop
+git merge --no-ff origin/main -m "Merge main back to develop after v1.1.0"
+git push -u origin chore/merge-main-after-v1.1.0
+```
+
+Open a pull request from `chore/merge-main-after-v1.1.0` into `develop`, wait for its checks, and use
+**Create a merge commit** to merge it. Do not squash or rebase this pull request: the original
+`main` commit must remain in `develop`'s ancestry for the publishing workflow's validation. The
+temporary branch can then be deleted safely.
+
+#### 3. Create the release tag from main
+
+After the synchronization pull request is merged, update your local `main` and verify that
+`package.json` contains the version you are about to tag:
+
+```sh
+git switch main
+git pull --ff-only origin main
+node -p "require('./package.json').version"
+```
+
+Create a signed, annotated tag on the checked-out `main` commit, verify it locally, and push it:
+
+```sh
+git tag -s v1.1.0 -m "Release v1.1.0"
+git tag -v v1.1.0
+git push origin v1.1.0
+```
+
+Pushing a tag matching `v*.*.*` automatically triggers the **Package Release** workflow defined in
+`.github/workflows/npm-publish.yml`. In GitHub, open **Actions** → **Package Release** and confirm
+the tag-triggered run succeeds.
+
+If publishing fails after the tag has been created, do not delete, move, or recreate the tag. After
+the underlying problem is fixed, open **Actions** → **Package Release** → **Run workflow** and enter
+the existing tag, such as `v1.1.0`, to retry it.
 
 See the [SDK Config IR v1 reference](src/sdk-config-ir/v1/README.md) for the complete contract.

package/dist/index.cjs

@@ -176,25 +176,26 @@ var environmentVariableSchema = zod.z.strictObject({
   defaultValue: zod.z.string().optional()
 });
 var apiConfigSchema = zod.z.strictObject({
-  baseUrl: nonEmptyStringSchema.optional(),
+  baseUrl: zod.z.string().default(""),
+  environments: zod.z.array(environmentSchema).default([]),
+  environmentVariables: zod.z.array(environmentVariableSchema).default([]),
   defaultEnvironment: nonEmptyStringSchema.optional(),
-  environments: zod.z.array(environmentSchema).optional(),
   auth: authConfigSchema.optional(),
-  headers: zod.z.array(headerSchema).optional(),
-  environmentVariables: zod.z.array(environmentVariableSchema).optional()
+  headers: zod.z.array(headerSchema).optional()
 });
 var retryConfigSchema = zod.z.strictObject({
-  enabled: zod.z.boolean(),
-  maxAttempts: zod.z.number().int().min(1).optional(),
-  retryDelayMs: zod.z.number().nonnegative().optional(),
-  maxDelayMs: zod.z.number().nonnegative().optional(),
-  jitterMs: zod.z.number().nonnegative().optional(),
-  backoffFactor: zod.z.number().positive().optional(),
+  enabled: zod.z.boolean().default(true),
+  maxAttempts: zod.z.number().int().min(1).default(3),
+  retryDelayMs: zod.z.number().nonnegative().default(150),
+  maxDelayMs: zod.z.number().nonnegative().default(5e3),
+  jitterMs: zod.z.number().nonnegative().default(50),
+  backoffFactor: zod.z.number().positive().default(2),
   statusCodes: zod.z.array(zod.z.number().int().min(100).max(599)).optional(),
-  methods: zod.z.array(nonEmptyStringSchema).optional(),
-  statusCodeProfile: zod.z.enum(["legacy", "recommended"]).optional()
+  methods: zod.z.array(nonEmptyStringSchema).default(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]),
+  statusCodeProfile: zod.z.enum(["legacy", "recommended"]).optional(),
+  maxRetryAfterDelayMs: zod.z.number().nonnegative().default(6e4)
 }).superRefine(({ maxDelayMs, retryDelayMs }, context) => {
-  if (maxDelayMs !== void 0 && retryDelayMs !== void 0 && maxDelayMs < retryDelayMs) {
+  if (maxDelayMs < retryDelayMs) {
     context.addIssue({
       code: "custom",
       message: "maxDelayMs must be greater than or equal to retryDelayMs",
@@ -224,17 +225,17 @@ var tokenRefreshConfigSchema = zod.z.strictObject({
   }
 });
 var clientConfigSchema = zod.z.strictObject({
-  retry: retryConfigSchema.optional(),
-  timeoutMs: zod.z.union([zod.z.number().nonnegative(), zod.z.literal("infinity")]).optional(),
-  responseHeaders: zod.z.boolean().optional(),
+  retry: retryConfigSchema.prefault({}),
+  responseHeaders: zod.z.boolean().default(false),
   responseValidation: zod.z.boolean().optional(),
+  multiTenant: zod.z.boolean().default(false),
+  additionalConstructorParameters: zod.z.array(constructorParameterSchema).default([]),
+  timeoutMs: zod.z.union([zod.z.number().nonnegative(), zod.z.literal("infinity")]).optional(),
   requestParameterStyle: parameterStyleSchema.optional(),
   pathParameterStyle: parameterStyleSchema.optional(),
   filePropertyStyle: parameterStyleSchema.optional(),
   useDefaultRequestParameterValues: zod.z.boolean().optional(),
-  additionalConstructorParameters: zod.z.array(constructorParameterSchema).optional(),
-  tokenRefresh: tokenRefreshConfigSchema.optional(),
-  multiTenant: zod.z.boolean().optional()
+  tokenRefresh: tokenRefreshConfigSchema.optional()
 });
 var unsupportedFieldSchema = zod.z.strictObject({
   source: zod.z.enum(["fern", "postman", "sdk-config-ir"]),
@@ -331,6 +332,38 @@ var javaGenerationConfigSchema = jvmGenerationConfigSchema.extend({
 
 // src/sdk-config-ir/v1/language/kotlin.ts
 var kotlinGenerationConfigSchema = jvmGenerationConfigSchema;
+var compilerOptionsSchema = zod.z.strictObject({
+  target: nonEmptyStringSchema.optional(),
+  module: nonEmptyStringSchema.optional(),
+  lib: zod.z.array(nonEmptyStringSchema).optional()
+});
+var packageScriptSchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  command: nonEmptyStringSchema
+});
+var httpClientSchema = zod.z.strictObject({
+  name: zod.z.enum(["axios", "fetch"])
+});
+var typescriptGenerationConfigSchema = zod.z.strictObject({
+  typescriptVersion: nonEmptyStringSchema.optional(),
+  zodVersion: nonEmptyStringSchema.optional(),
+  compilerOptions: compilerOptionsSchema.optional(),
+  httpClient: httpClientSchema.optional(),
+  packageManager: zod.z.enum(["pnpm", "yarn"]).optional(),
+  testFramework: zod.z.enum(["jest", "vitest"]).optional(),
+  namingStrategy: zod.z.enum(["base", "originalPropertyNames"]).optional(),
+  bundle: zod.z.boolean().optional(),
+  exportClassDefault: zod.z.boolean().optional(),
+  allowCustomFetcher: zod.z.boolean().optional(),
+  useBrandedStringAliases: zod.z.boolean().optional(),
+  useLegacyExports: zod.z.boolean().optional(),
+  useBigInt: zod.z.boolean().optional(),
+  serdeLayer: zod.z.boolean().optional(),
+  scripts: zod.z.array(packageScriptSchema).optional()
+});
+
+// src/sdk-config-ir/v1/language/mcp.ts
+var mcpGenerationConfigSchema = typescriptGenerationConfigSchema;
 var phpGenerationConfigSchema = zod.z.strictObject({
   propertyAccess: zod.z.enum(["public", "private"]).optional(),
   generateClientInterfaces: zod.z.boolean().optional()
@@ -357,34 +390,122 @@ var pythonGenerationConfigSchema = zod.z.strictObject({
 var rubyGenerationConfigSchema = zod.z.strictObject({
   requirePaths: zod.z.array(nonEmptyStringSchema).optional()
 });
-var compilerOptionsSchema = zod.z.strictObject({
-  target: nonEmptyStringSchema.optional(),
-  module: nonEmptyStringSchema.optional(),
-  lib: zod.z.array(nonEmptyStringSchema).optional()
+var rustGenerationConfigSchema = zod.z.strictObject({
+  /**
+   * Rust type for datetime primitives. `offset` maps to `DateTime<FixedOffset>` and preserves the
+   * timezone the payload carried; `utc` maps to `DateTime<Utc>` and normalizes to UTC.
+   */
+  dateTimeType: zod.z.enum(["offset", "utc"]).optional(),
+  /** Uppercase common initialisms in generated names (`UserID` rather than `UserId`). */
+  capitalizeInitialisms: zod.z.boolean().optional(),
+  /** Cargo features, mapping a feature name to the dependencies or features it enables. */
+  features: zod.z.record(zod.z.string(), zod.z.array(nonEmptyStringSchema)).optional(),
+  /** Overrides which features make up Cargo's `default` feature set. */
+  defaultFeatures: zod.z.array(nonEmptyStringSchema).optional()
+});
+var swiftGenerationConfigSchema = zod.z.strictObject({
+  moduleName: nonEmptyStringSchema.optional()
 });
-var packageScriptSchema = zod.z.strictObject({
+var goModulePathSchema = nonEmptyStringSchema.regex(
+  /^(?!.*(?:^|\/)\.{1,2}(?:\/|$))[A-Za-z0-9._~-]+(?:\/[A-Za-z0-9._~-]+)+$/,
+  "Go module path must be a slash-delimited path using letters, numbers, dots, dashes, underscores, or tildes"
+);
+var composerPackageNameSchema = nonEmptyStringSchema.regex(
+  /^[a-z0-9]([_.-]?[a-z0-9]+)*\/[a-z0-9](([_.]?|-{0,2})[a-z0-9]+)*$/,
+  'Composer package name must be a lowercase "vendor/package" name'
+);
+var authorSchema = zod.z.strictObject({
   name: nonEmptyStringSchema,
-  command: nonEmptyStringSchema
+  email: zod.z.email().optional()
 });
-var httpClientSchema = zod.z.strictObject({
-  name: zod.z.enum(["axios", "fetch"])
+var developerSchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  email: zod.z.email().optional(),
+  organization: nonEmptyStringSchema.optional(),
+  organizationUrl: nonEmptyStringSchema.optional()
 });
-var typescriptGenerationConfigSchema = zod.z.strictObject({
-  typescriptVersion: nonEmptyStringSchema.optional(),
-  zodVersion: nonEmptyStringSchema.optional(),
-  compilerOptions: compilerOptionsSchema.optional(),
-  httpClient: httpClientSchema.optional(),
-  packageManager: zod.z.enum(["pnpm", "yarn"]).optional(),
-  testFramework: zod.z.enum(["jest", "vitest"]).optional(),
-  namingStrategy: zod.z.enum(["base", "originalPropertyNames"]).optional(),
-  bundle: zod.z.boolean().optional(),
-  exportClassDefault: zod.z.boolean().optional(),
-  allowCustomFetcher: zod.z.boolean().optional(),
-  useBrandedStringAliases: zod.z.boolean().optional(),
-  useLegacyExports: zod.z.boolean().optional(),
-  useBigInt: zod.z.boolean().optional(),
-  serdeLayer: zod.z.boolean().optional(),
-  scripts: zod.z.array(packageScriptSchema).optional()
+var licenseSchema = zod.z.strictObject({
+  type: nonEmptyStringSchema,
+  name: nonEmptyStringSchema.optional(),
+  url: nonEmptyStringSchema.optional(),
+  path: nonEmptyStringSchema.optional()
+});
+var dependencySourceSchema = zod.z.discriminatedUnion("type", [
+  zod.z.strictObject({
+    type: zod.z.literal("registry"),
+    registry: nonEmptyStringSchema.optional()
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("git"),
+    url: nonEmptyStringSchema,
+    ref: nonEmptyStringSchema.optional(),
+    subdirectory: nonEmptyStringSchema.optional()
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("path"),
+    path: nonEmptyStringSchema
+  })
+]);
+var dependencySchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  version: nonEmptyStringSchema.optional(),
+  source: dependencySourceSchema.optional(),
+  packageName: nonEmptyStringSchema.optional(),
+  features: zod.z.array(nonEmptyStringSchema).optional(),
+  extras: zod.z.array(nonEmptyStringSchema).optional(),
+  optional: zod.z.boolean().optional(),
+  defaultFeatures: zod.z.boolean().optional(),
+  environmentMarker: nonEmptyStringSchema.optional()
+}).refine(({ source, version }) => source !== void 0 || version !== void 0, {
+  message: "dependency must define a version or a source"
+});
+var projectUrlSchema = zod.z.strictObject({
+  label: nonEmptyStringSchema,
+  url: nonEmptyStringSchema
+});
+var packageConfigSchema = zod.z.strictObject({
+  packageName: nonEmptyStringSchema.optional(),
+  moduleName: nonEmptyStringSchema.optional(),
+  modulePath: goModulePathSchema.optional(),
+  namespace: nonEmptyStringSchema.optional(),
+  groupId: nonEmptyStringSchema.optional(),
+  artifactId: nonEmptyStringSchema.optional(),
+  description: zod.z.string().optional(),
+  repository: nonEmptyStringSchema.optional(),
+  homepage: nonEmptyStringSchema.optional(),
+  documentationUrl: nonEmptyStringSchema.optional(),
+  authors: zod.z.array(authorSchema).optional(),
+  developers: zod.z.array(developerSchema).optional(),
+  license: licenseSchema.optional(),
+  keywords: zod.z.array(nonEmptyStringSchema).optional(),
+  classifiers: zod.z.array(nonEmptyStringSchema).optional(),
+  projectUrls: zod.z.array(projectUrlSchema).optional(),
+  extraDependencies: zod.z.array(dependencySchema).optional(),
+  extraDevDependencies: zod.z.array(dependencySchema).optional(),
+  extraPeerDependencies: zod.z.array(dependencySchema).optional()
+});
+
+// src/sdk-config-ir/v1/language/terraform.ts
+var planModifierSourceSchema = zod.z.discriminatedUnion("enabled", [
+  zod.z.strictObject({ enabled: zod.z.literal(true), sourceDir: nonEmptyStringSchema }),
+  zod.z.strictObject({ enabled: zod.z.literal(false) })
+]);
+var planModifiersSchema = zod.z.strictObject({
+  resources: planModifierSourceSchema,
+  attributes: planModifierSourceSchema
+});
+var providerSchemaSchema = zod.z.strictObject({
+  addressKey: nonEmptyStringSchema,
+  authTokenKey: nonEmptyStringSchema
+});
+var terraformGenerationConfigSchema = zod.z.strictObject({
+  providerName: nonEmptyStringSchema.optional(),
+  providerVersion: nonEmptyStringSchema.optional(),
+  providerModulePath: goModulePathSchema.optional(),
+  mockAcceptance: zod.z.boolean().optional(),
+  hideComputedDiff: zod.z.boolean().optional(),
+  providerSchema: providerSchemaSchema.optional(),
+  planModifiers: planModifiersSchema.optional()
 });
 
 // src/sdk-config-ir/v1/generation.ts
@@ -473,17 +594,23 @@ var languageGenerationConfigSchema = zod.z.strictObject({
   csharp: csharpGenerationConfigSchema.optional(),
   php: phpGenerationConfigSchema.optional(),
   ruby: rubyGenerationConfigSchema.optional(),
-  cli: cliGenerationConfigSchema.optional()
+  rust: rustGenerationConfigSchema.optional(),
+  cli: cliGenerationConfigSchema.optional(),
+  mcp: mcpGenerationConfigSchema.optional(),
+  swift: swiftGenerationConfigSchema.optional(),
+  terraform: terraformGenerationConfigSchema.optional()
 });
 var generationConfigSchema = zod.z.strictObject({
-  includeWatermark: zod.z.boolean().optional(),
+  includeWatermark: zod.z.boolean().default(false),
+  /** Emits an AI service into the generated SDK. Python, Java and TypeScript honour it. */
+  ai: zod.z.boolean().default(false),
   includeOptionalSnippetParameters: zod.z.boolean().optional(),
-  buildAllModels: zod.z.boolean().optional(),
-  inferServiceNames: zod.z.boolean().optional(),
-  includeDeprecatedOperations: zod.z.boolean().optional(),
-  multipleResponses: zod.z.boolean().optional(),
-  devContainer: zod.z.boolean().optional(),
-  allowMockClient: zod.z.boolean().optional(),
+  buildAllModels: zod.z.boolean().default(false),
+  inferServiceNames: zod.z.boolean().default(false),
+  includeDeprecatedOperations: zod.z.boolean().default(true),
+  multipleResponses: zod.z.boolean().default(false),
+  devContainer: zod.z.boolean().default(false),
+  allowMockClient: zod.z.boolean().default(false),
   ignoreFiles: zod.z.array(nonEmptyStringSchema).optional(),
   reservedKeywords: zod.z.array(nonEmptyStringSchema).optional(),
   hooks: hooksConfigSchema.optional(),
@@ -564,84 +691,6 @@ var outputConfigSchema = zod.z.discriminatedUnion(
     error: 'output.delivery must be one of "files", "zip", or "github"'
   }
 );
-var goModulePathSchema = nonEmptyStringSchema.regex(
-  /^(?!.*(?:^|\/)\.{1,2}(?:\/|$))[A-Za-z0-9._~-]+(?:\/[A-Za-z0-9._~-]+)+$/,
-  "Go module path must be a slash-delimited path using letters, numbers, dots, dashes, underscores, or tildes"
-);
-var composerPackageNameSchema = nonEmptyStringSchema.regex(
-  /^[a-z0-9]([_.-]?[a-z0-9]+)*\/[a-z0-9](([_.]?|-{0,2})[a-z0-9]+)*$/,
-  'Composer package name must be a lowercase "vendor/package" name'
-);
-var authorSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  email: zod.z.email().optional()
-});
-var developerSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  email: zod.z.email().optional(),
-  organization: nonEmptyStringSchema.optional(),
-  organizationUrl: nonEmptyStringSchema.optional()
-});
-var licenseSchema = zod.z.strictObject({
-  type: nonEmptyStringSchema,
-  name: nonEmptyStringSchema.optional(),
-  url: nonEmptyStringSchema.optional(),
-  path: nonEmptyStringSchema.optional()
-});
-var dependencySourceSchema = zod.z.discriminatedUnion("type", [
-  zod.z.strictObject({
-    type: zod.z.literal("registry"),
-    registry: nonEmptyStringSchema.optional()
-  }),
-  zod.z.strictObject({
-    type: zod.z.literal("git"),
-    url: nonEmptyStringSchema,
-    ref: nonEmptyStringSchema.optional(),
-    subdirectory: nonEmptyStringSchema.optional()
-  }),
-  zod.z.strictObject({
-    type: zod.z.literal("path"),
-    path: nonEmptyStringSchema
-  })
-]);
-var dependencySchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  version: nonEmptyStringSchema.optional(),
-  source: dependencySourceSchema.optional(),
-  packageName: nonEmptyStringSchema.optional(),
-  features: zod.z.array(nonEmptyStringSchema).optional(),
-  extras: zod.z.array(nonEmptyStringSchema).optional(),
-  optional: zod.z.boolean().optional(),
-  defaultFeatures: zod.z.boolean().optional(),
-  environmentMarker: nonEmptyStringSchema.optional()
-}).refine(({ source, version }) => source !== void 0 || version !== void 0, {
-  message: "dependency must define a version or a source"
-});
-var projectUrlSchema = zod.z.strictObject({
-  label: nonEmptyStringSchema,
-  url: nonEmptyStringSchema
-});
-var packageConfigSchema = zod.z.strictObject({
-  packageName: nonEmptyStringSchema.optional(),
-  moduleName: nonEmptyStringSchema.optional(),
-  modulePath: goModulePathSchema.optional(),
-  namespace: nonEmptyStringSchema.optional(),
-  groupId: nonEmptyStringSchema.optional(),
-  artifactId: nonEmptyStringSchema.optional(),
-  description: zod.z.string().optional(),
-  repository: nonEmptyStringSchema.optional(),
-  homepage: nonEmptyStringSchema.optional(),
-  documentationUrl: nonEmptyStringSchema.optional(),
-  authors: zod.z.array(authorSchema).optional(),
-  developers: zod.z.array(developerSchema).optional(),
-  license: licenseSchema.optional(),
-  keywords: zod.z.array(nonEmptyStringSchema).optional(),
-  classifiers: zod.z.array(nonEmptyStringSchema).optional(),
-  projectUrls: zod.z.array(projectUrlSchema).optional(),
-  extraDependencies: zod.z.array(dependencySchema).optional(),
-  extraDevDependencies: zod.z.array(dependencySchema).optional(),
-  extraPeerDependencies: zod.z.array(dependencySchema).optional()
-});
 var apiImportSettingsSchema = zod.z.strictObject({
   respectNullableSchemas: zod.z.boolean().optional(),
   titleAsSchemaName: zod.z.boolean().optional(),
@@ -701,7 +750,9 @@ var targetLanguageSchema = zod.z.enum([
   "ruby",
   "rust",
   "swift",
-  "cli"
+  "cli",
+  "mcp",
+  "terraform"
 ]);
 var targetConfigSchema = zod.z.strictObject({
   language: targetLanguageSchema,
@@ -709,7 +760,7 @@ var targetConfigSchema = zod.z.strictObject({
   sourceOrigin: zod.z.enum(["postman", "fern"]),
   sdkName: nonEmptyStringSchema,
   organization: nonEmptyStringSchema.optional(),
-  sdkVersion: nonEmptyStringSchema.optional(),
+  sdkVersion: nonEmptyStringSchema.default("1.0.0"),
   apiVersion: nonEmptyStringSchema.optional()
 });
 
@@ -842,6 +893,7 @@ exports.jsonValueSchema = jsonValueSchema;
 exports.kotlinGenerationConfigSchema = kotlinGenerationConfigSchema;
 exports.languageGenerationConfigSchema = languageGenerationConfigSchema;
 exports.legacyInputSchema = legacyInputSchema;
+exports.mcpGenerationConfigSchema = mcpGenerationConfigSchema;
 exports.nonEmptyStringSchema = nonEmptyStringSchema;
 exports.outputConfigSchema = outputConfigSchema;
 exports.packageConfigSchema = packageConfigSchema;
@@ -852,12 +904,15 @@ exports.publishRegistrySchema = publishRegistrySchema;
 exports.pythonGenerationConfigSchema = pythonGenerationConfigSchema;
 exports.readmeEndpointSchema = readmeEndpointSchema;
 exports.rubyGenerationConfigSchema = rubyGenerationConfigSchema;
+exports.rustGenerationConfigSchema = rustGenerationConfigSchema;
 exports.sdkConfigIrV1Schema = sdkConfigIrV1Schema;
 exports.sourceConfigSchema = sourceConfigSchema;
 exports.sourceSpecConfigSchema = sourceSpecConfigSchema;
 exports.sourceSpecTypeSchema = sourceSpecTypeSchema;
+exports.swiftGenerationConfigSchema = swiftGenerationConfigSchema;
 exports.targetConfigSchema = targetConfigSchema;
 exports.targetLanguageSchema = targetLanguageSchema;
+exports.terraformGenerationConfigSchema = terraformGenerationConfigSchema;
 exports.typescriptGenerationConfigSchema = typescriptGenerationConfigSchema;
 exports.unsupportedFieldSchema = unsupportedFieldSchema;
 //# sourceMappingURL=index.cjs.map