@postman/sdk-config 0.0.0 → 0.0.1

package/dist/sdk-config-ir/v1/index.cjs

@@ -0,0 +1,864 @@
+'use strict';
+
+var zod = require('zod');
+var semver = require('semver');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var semver__default = /*#__PURE__*/_interopDefault(semver);
+
+// src/sdk-config-ir/v1/api.ts
+var nonEmptyStringSchema = zod.z.string().min(1);
+var exactSemverSchema = zod.z.string().refine(
+  (value) => {
+    if (value.trim() !== value || !/^\d/.test(value)) {
+      return false;
+    }
+    const parsed = semver__default.default.parse(value, { loose: false });
+    return parsed?.raw === value;
+  },
+  { message: "must be an exact semantic version" }
+);
+var jsonValueSchema = zod.z.lazy(
+  () => zod.z.union([
+    zod.z.null(),
+    zod.z.boolean(),
+    zod.z.number(),
+    zod.z.string(),
+    zod.z.array(jsonValueSchema),
+    zod.z.record(zod.z.string(), jsonValueSchema)
+  ])
+);
+var jsonObjectSchema = zod.z.record(zod.z.string(), jsonValueSchema);
+
+// src/sdk-config-ir/v1/api.ts
+var authVariableSchema = zod.z.strictObject({
+  name: nonEmptyStringSchema.optional(),
+  environmentVariable: nonEmptyStringSchema.optional(),
+  description: zod.z.string().optional(),
+  omit: zod.z.boolean().optional()
+});
+var apiKeyAuthSchema = zod.z.strictObject({
+  id: nonEmptyStringSchema,
+  type: zod.z.literal("api-key"),
+  location: zod.z.enum(["header", "query", "cookie"]),
+  name: nonEmptyStringSchema,
+  prefix: nonEmptyStringSchema.optional(),
+  environmentVariable: nonEmptyStringSchema.optional(),
+  description: zod.z.string().optional()
+});
+var bearerAuthSchema = zod.z.strictObject({
+  id: nonEmptyStringSchema,
+  type: zod.z.literal("bearer"),
+  header: nonEmptyStringSchema.optional(),
+  prefix: nonEmptyStringSchema.optional(),
+  environmentVariable: nonEmptyStringSchema.optional(),
+  description: zod.z.string().optional()
+});
+var basicAuthSchema = zod.z.strictObject({
+  id: nonEmptyStringSchema,
+  type: zod.z.literal("basic"),
+  username: authVariableSchema.optional(),
+  password: authVariableSchema.optional(),
+  description: zod.z.string().optional()
+});
+var oauthScopeSchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  description: zod.z.string().optional()
+});
+var oauthFlowSchema = zod.z.discriminatedUnion("type", [
+  zod.z.strictObject({
+    type: zod.z.literal("authorization-code"),
+    authorizationUrl: nonEmptyStringSchema,
+    tokenUrl: nonEmptyStringSchema,
+    refreshUrl: nonEmptyStringSchema.optional(),
+    scopes: zod.z.array(oauthScopeSchema).optional()
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("client-credentials"),
+    tokenUrl: nonEmptyStringSchema,
+    refreshUrl: nonEmptyStringSchema.optional(),
+    scopes: zod.z.array(oauthScopeSchema).optional()
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("implicit"),
+    authorizationUrl: nonEmptyStringSchema,
+    refreshUrl: nonEmptyStringSchema.optional(),
+    scopes: zod.z.array(oauthScopeSchema).optional()
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("password"),
+    tokenUrl: nonEmptyStringSchema,
+    refreshUrl: nonEmptyStringSchema.optional(),
+    scopes: zod.z.array(oauthScopeSchema).optional()
+  })
+]);
+var oauth2AuthSchema = zod.z.strictObject({
+  id: nonEmptyStringSchema,
+  type: zod.z.literal("oauth2"),
+  flows: zod.z.array(oauthFlowSchema).min(1),
+  clientId: authVariableSchema.optional(),
+  clientSecret: authVariableSchema.optional(),
+  tokenHeader: nonEmptyStringSchema.optional(),
+  tokenPrefix: nonEmptyStringSchema.optional(),
+  refreshBufferSeconds: zod.z.number().nonnegative().optional(),
+  description: zod.z.string().optional()
+});
+var customAuthParameterSchema = zod.z.strictObject({
+  location: zod.z.enum(["header", "query", "cookie"]),
+  name: nonEmptyStringSchema,
+  prefix: nonEmptyStringSchema.optional(),
+  environmentVariable: nonEmptyStringSchema.optional()
+});
+var customAuthSchema = zod.z.strictObject({
+  id: nonEmptyStringSchema,
+  type: zod.z.literal("custom"),
+  parameters: zod.z.array(customAuthParameterSchema).min(1),
+  description: zod.z.string().optional()
+});
+var authSchemeSchema = zod.z.discriminatedUnion("type", [
+  apiKeyAuthSchema,
+  bearerAuthSchema,
+  basicAuthSchema,
+  oauth2AuthSchema,
+  customAuthSchema
+]);
+var authRequirementSchema = zod.z.strictObject({
+  schemes: zod.z.array(nonEmptyStringSchema).min(1)
+});
+var authConfigSchema = zod.z.strictObject({
+  schemes: zod.z.array(authSchemeSchema).min(1),
+  requirements: zod.z.array(authRequirementSchema).optional(),
+  endpointSecurity: zod.z.boolean().optional()
+}).superRefine(({ requirements, schemes }, context) => {
+  const schemeIds = /* @__PURE__ */ new Set();
+  schemes.forEach(({ id }, index) => {
+    if (schemeIds.has(id)) {
+      context.addIssue({
+        code: "custom",
+        message: `auth scheme id "${id}" must be unique`,
+        path: ["schemes", index, "id"]
+      });
+    }
+    schemeIds.add(id);
+  });
+  requirements?.forEach((requirement, requirementIndex) => {
+    requirement.schemes.forEach((schemeId, schemeIndex) => {
+      if (!schemeIds.has(schemeId)) {
+        context.addIssue({
+          code: "custom",
+          message: `auth requirement references unknown scheme "${schemeId}"`,
+          path: ["requirements", requirementIndex, "schemes", schemeIndex]
+        });
+      }
+    });
+  });
+});
+var environmentUrlSchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  url: nonEmptyStringSchema,
+  serverName: nonEmptyStringSchema.optional()
+});
+var environmentSchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  urls: zod.z.array(environmentUrlSchema).min(1),
+  description: zod.z.string().optional()
+});
+var headerSchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  value: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  environmentVariable: nonEmptyStringSchema.optional()
+});
+var environmentVariableSchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  description: zod.z.string().optional(),
+  defaultValue: zod.z.string().optional()
+});
+var apiConfigSchema = zod.z.strictObject({
+  baseUrl: nonEmptyStringSchema.optional(),
+  defaultEnvironment: nonEmptyStringSchema.optional(),
+  environments: zod.z.array(environmentSchema).optional(),
+  auth: authConfigSchema.optional(),
+  headers: zod.z.array(headerSchema).optional(),
+  environmentVariables: zod.z.array(environmentVariableSchema).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(),
+  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()
+}).superRefine(({ maxDelayMs, retryDelayMs }, context) => {
+  if (maxDelayMs !== void 0 && retryDelayMs !== void 0 && maxDelayMs < retryDelayMs) {
+    context.addIssue({
+      code: "custom",
+      message: "maxDelayMs must be greater than or equal to retryDelayMs",
+      path: ["maxDelayMs"]
+    });
+  }
+});
+var constructorParameterSchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  example: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  required: zod.z.boolean().optional()
+});
+var parameterStyleSchema = zod.z.enum(["wrapped", "inline", "language-default"]);
+var tokenRefreshConfigSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  endpoint: nonEmptyStringSchema.optional(),
+  accessTokenField: nonEmptyStringSchema.optional(),
+  refreshTokenField: nonEmptyStringSchema.optional()
+}).superRefine(({ enabled, endpoint }, context) => {
+  if (enabled && endpoint === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "endpoint is required when tokenRefresh is enabled",
+      path: ["endpoint"]
+    });
+  }
+});
+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(),
+  responseValidation: zod.z.boolean().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()
+});
+var unsupportedFieldSchema = zod.z.strictObject({
+  source: zod.z.enum(["fern", "postman", "sdk-config-ir"]),
+  path: zod.z.array(zod.z.union([nonEmptyStringSchema, zod.z.number().int().nonnegative()])).min(1),
+  code: nonEmptyStringSchema.optional(),
+  reason: nonEmptyStringSchema,
+  severity: zod.z.enum(["error", "warning", "info"]),
+  risk: zod.z.enum(["high", "medium", "low"]),
+  owner: nonEmptyStringSchema,
+  suggestedAction: nonEmptyStringSchema
+});
+var postmanLegacyInputSchema = zod.z.strictObject({
+  kind: zod.z.literal("postman-build-parameters"),
+  value: jsonObjectSchema
+});
+var fernLegacyInputSchema = zod.z.strictObject({
+  kind: zod.z.literal("fern-generator-invocation"),
+  value: jsonObjectSchema
+});
+var legacyInputSchema = zod.z.discriminatedUnion("kind", [
+  postmanLegacyInputSchema,
+  fernLegacyInputSchema
+]);
+var compatibilityConfigSchema = zod.z.strictObject({
+  outputProfile: zod.z.enum(["converged", "postman-legacy", "fern-legacy"]),
+  legacyInput: legacyInputSchema.optional(),
+  unsupportedFields: zod.z.array(unsupportedFieldSchema).optional()
+});
+var httpMethodSchema = zod.z.enum([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "TRACE",
+  "CONNECT"
+]);
+var readmeEndpointSchema = zod.z.strictObject({
+  method: httpMethodSchema,
+  path: nonEmptyStringSchema,
+  stream: zod.z.boolean().optional()
+});
+var readmeConfigSchema = zod.z.strictObject({
+  apiName: nonEmptyStringSchema.optional(),
+  introduction: zod.z.string().optional(),
+  apiReferenceLink: nonEmptyStringSchema.optional(),
+  bannerLink: nonEmptyStringSchema.optional(),
+  disabledSections: zod.z.array(nonEmptyStringSchema).optional(),
+  defaultEndpoint: readmeEndpointSchema.optional(),
+  features: zod.z.record(zod.z.string(), zod.z.array(readmeEndpointSchema)).optional()
+});
+var snippetsConfigSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  format: zod.z.enum(["md", "json"]).optional(),
+  outputPath: nonEmptyStringSchema.optional()
+});
+var docsConfigSchema = zod.z.strictObject({
+  readme: readmeConfigSchema.optional(),
+  snippets: snippetsConfigSchema.optional(),
+  referenceBaseUrl: nonEmptyStringSchema.optional(),
+  includeApiReference: zod.z.boolean().optional()
+});
+var cliGenerationConfigSchema = zod.z.strictObject({
+  paginationParameters: zod.z.array(nonEmptyStringSchema).optional(),
+  skills: zod.z.boolean().optional()
+});
+var csharpGenerationConfigSchema = zod.z.strictObject({
+  useOptionalWrapper: zod.z.boolean().optional(),
+  simplifyObjectDictionaries: zod.z.boolean().optional(),
+  explicitNamespaces: zod.z.boolean().optional(),
+  rootNamespaceForCoreClasses: zod.z.boolean().optional(),
+  includeExceptionHandler: zod.z.boolean().optional()
+});
+var goGenerationConfigSchema = zod.z.strictObject({
+  legacyComplexModels: zod.z.boolean().optional(),
+  unionVersion: zod.z.enum(["v0", "v1"]).optional(),
+  includeLegacyClientOptions: zod.z.boolean().optional()
+});
+var jvmGenerationConfigSchema = zod.z.strictObject({
+  packageLayout: zod.z.enum(["flat", "nested"]).optional(),
+  useLocalDateForDates: zod.z.boolean().optional(),
+  collapseOptionalNullable: zod.z.boolean().optional(),
+  gradleDistributionUrl: zod.z.string().min(1).optional(),
+  gradlePluginManagement: zod.z.string().optional(),
+  gradleCentralDependencyManagement: zod.z.boolean().optional()
+});
+
+// src/sdk-config-ir/v1/language/java.ts
+var javaGenerationConfigSchema = jvmGenerationConfigSchema.extend({
+  includeKotlinSnippets: zod.z.boolean().optional()
+});
+
+// src/sdk-config-ir/v1/language/kotlin.ts
+var kotlinGenerationConfigSchema = jvmGenerationConfigSchema;
+var phpGenerationConfigSchema = zod.z.strictObject({
+  propertyAccess: zod.z.enum(["public", "private"]).optional(),
+  generateClientInterfaces: zod.z.boolean().optional()
+});
+var pythonClientSchema = zod.z.strictObject({
+  fileName: nonEmptyStringSchema.optional(),
+  exportedFileName: nonEmptyStringSchema.optional()
+});
+var pydanticConfigSchema = zod.z.strictObject({
+  versionCompatibility: zod.z.enum(["v1", "v2", "both", "v1-on-v2"]).optional(),
+  frozen: zod.z.boolean().optional(),
+  requireOptionalFields: zod.z.boolean().optional(),
+  unionNaming: zod.z.enum(["v0", "v1"]).optional(),
+  useFieldAliases: zod.z.boolean().optional()
+});
+var pythonGenerationConfigSchema = zod.z.strictObject({
+  pythonVersion: nonEmptyStringSchema.optional(),
+  pydanticVersion: nonEmptyStringSchema.optional(),
+  pydantic: pydanticConfigSchema.optional(),
+  client: pythonClientSchema.optional(),
+  alwaysInitializeOptionals: zod.z.boolean().optional(),
+  useTypedDictRequests: zod.z.boolean().optional()
+});
+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 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/generation.ts
+var generationAssetSchema = zod.z.strictObject({
+  type: zod.z.enum(["path", "url", "artifact"]),
+  location: nonEmptyStringSchema
+});
+var hookDependencySchema = zod.z.strictObject({
+  name: nonEmptyStringSchema,
+  version: nonEmptyStringSchema,
+  groupId: nonEmptyStringSchema.optional()
+});
+var hooksConfigSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  source: generationAssetSchema.optional(),
+  dependencies: zod.z.array(hookDependencySchema).optional()
+});
+var customCodeConfigSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  source: generationAssetSchema.optional(),
+  conflictStrategy: zod.z.enum(["mark", "ours", "theirs"]).optional(),
+  trackChanges: zod.z.boolean().optional(),
+  previousBuildId: zod.z.number().int().positive().optional(),
+  protectedFiles: zod.z.array(nonEmptyStringSchema).optional()
+});
+var workflowConfigSchema = zod.z.strictObject({
+  path: nonEmptyStringSchema,
+  outputName: nonEmptyStringSchema.optional()
+});
+var analyticsHeaderSchema = zod.z.union([
+  zod.z.strictObject({ name: nonEmptyStringSchema, value: zod.z.string() }),
+  zod.z.strictObject({ name: nonEmptyStringSchema, valueRef: nonEmptyStringSchema })
+]);
+var analyticsConfigSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  endpoint: nonEmptyStringSchema.optional(),
+  exporter: zod.z.enum(["otlp-http", "console"]).optional(),
+  headers: zod.z.array(analyticsHeaderSchema).optional(),
+  batchSize: zod.z.number().int().positive().optional(),
+  scheduledDelayMs: zod.z.number().nonnegative().optional(),
+  exportTimeoutMs: zod.z.number().nonnegative().optional()
+}).superRefine(({ enabled, endpoint }, context) => {
+  if (enabled && endpoint === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "endpoint is required when analytics is enabled",
+      path: ["endpoint"]
+    });
+  }
+});
+var wireTestsSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  exclusions: zod.z.array(nonEmptyStringSchema).optional(),
+  fallbackToGeneratedErrorExamples: zod.z.boolean().optional()
+});
+var streamsSchema = zod.z.strictObject({
+  enabled: zod.z.boolean(),
+  responseType: zod.z.enum(["wrapper", "native", "web"]).optional(),
+  fileResponseType: zod.z.enum(["stream", "binary-response"]).optional(),
+  defaultChunkSizeBytes: zod.z.number().int().positive().optional()
+});
+var namingConfigSchema = zod.z.strictObject({
+  clientName: nonEmptyStringSchema.optional(),
+  exportedClientName: nonEmptyStringSchema.optional(),
+  environmentTypeName: nonEmptyStringSchema.optional(),
+  apiErrorName: nonEmptyStringSchema.optional(),
+  baseErrorName: nonEmptyStringSchema.optional(),
+  pagerName: nonEmptyStringSchema.optional()
+});
+var layoutConfigSchema = zod.z.strictObject({
+  outputDirectory: zod.z.enum(["project-root", "source-root"]).optional(),
+  packagePath: nonEmptyStringSchema.optional()
+});
+var serializationConfigSchema = zod.z.strictObject({
+  enumRepresentation: zod.z.enum(["enum", "union", "literal", "forward-compatible-enum", "language-default"]).optional(),
+  additionalProperties: zod.z.enum(["allow", "forbid", "ignore", "language-default"]).optional(),
+  inlineTypes: zod.z.boolean().optional(),
+  omitUndefined: zod.z.boolean().optional()
+});
+var languageGenerationConfigSchema = zod.z.strictObject({
+  typescript: typescriptGenerationConfigSchema.optional(),
+  python: pythonGenerationConfigSchema.optional(),
+  java: javaGenerationConfigSchema.optional(),
+  kotlin: kotlinGenerationConfigSchema.optional(),
+  go: goGenerationConfigSchema.optional(),
+  csharp: csharpGenerationConfigSchema.optional(),
+  php: phpGenerationConfigSchema.optional(),
+  ruby: rubyGenerationConfigSchema.optional(),
+  cli: cliGenerationConfigSchema.optional()
+});
+var generationConfigSchema = zod.z.strictObject({
+  includeWatermark: zod.z.boolean().optional(),
+  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(),
+  ignoreFiles: zod.z.array(nonEmptyStringSchema).optional(),
+  reservedKeywords: zod.z.array(nonEmptyStringSchema).optional(),
+  hooks: hooksConfigSchema.optional(),
+  customCode: customCodeConfigSchema.optional(),
+  workflows: zod.z.array(workflowConfigSchema).optional(),
+  customQueryPaths: zod.z.array(nonEmptyStringSchema).optional(),
+  analytics: analyticsConfigSchema.optional(),
+  wireTests: wireTestsSchema.optional(),
+  webSockets: zod.z.boolean().optional(),
+  streams: streamsSchema.optional(),
+  naming: namingConfigSchema.optional(),
+  layout: layoutConfigSchema.optional(),
+  serialization: serializationConfigSchema.optional(),
+  language: languageGenerationConfigSchema.optional()
+});
+var publishRegistrySchema = zod.z.enum([
+  "npm",
+  "pypi",
+  "maven",
+  "nuget",
+  "rubygems",
+  "crates",
+  "go",
+  "composer"
+]);
+var commonPublishShape = {
+  url: nonEmptyStringSchema.optional(),
+  credentialsRef: nonEmptyStringSchema.optional(),
+  releaseBranch: nonEmptyStringSchema.optional(),
+  tolerateRepublish: zod.z.boolean().optional()
+};
+var publishConfigSchema = zod.z.discriminatedUnion("registry", [
+  zod.z.strictObject({ registry: zod.z.literal("npm"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("pypi"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("nuget"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("rubygems"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("crates"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("go"), ...commonPublishShape }),
+  zod.z.strictObject({ registry: zod.z.literal("composer"), ...commonPublishShape }),
+  zod.z.strictObject({
+    registry: zod.z.literal("maven"),
+    signingCredentialsRef: nonEmptyStringSchema.optional(),
+    ...commonPublishShape
+  })
+]);
+var reviewersSchema = zod.z.strictObject({
+  teams: zod.z.array(nonEmptyStringSchema).optional(),
+  users: zod.z.array(nonEmptyStringSchema).optional()
+});
+var githubOutputSchema = zod.z.strictObject({
+  repository: nonEmptyStringSchema,
+  host: nonEmptyStringSchema.optional(),
+  branch: nonEmptyStringSchema.optional(),
+  mode: zod.z.enum(["release", "pull-request", "push"]).optional(),
+  reviewers: reviewersSchema.optional(),
+  credentialsRef: nonEmptyStringSchema.optional(),
+  privateRepository: zod.z.boolean().optional()
+});
+var filesOutputSchema = zod.z.strictObject({
+  delivery: zod.z.literal("files"),
+  path: nonEmptyStringSchema.optional(),
+  publish: publishConfigSchema.optional()
+});
+var zipOutputSchema = zod.z.strictObject({
+  delivery: zod.z.literal("zip"),
+  fileName: nonEmptyStringSchema.optional(),
+  publish: publishConfigSchema.optional()
+});
+var githubDeliverySchema = zod.z.strictObject({
+  delivery: zod.z.literal("github"),
+  github: githubOutputSchema,
+  publish: publishConfigSchema.optional()
+});
+var outputConfigSchema = zod.z.discriminatedUnion(
+  "delivery",
+  [filesOutputSchema, zipOutputSchema, githubDeliverySchema],
+  {
+    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(),
+  coerceEnumsToLiterals: zod.z.boolean().optional(),
+  idiomaticRequestNames: zod.z.boolean().optional(),
+  wrapReferencesToNullableInOptional: zod.z.boolean().optional(),
+  coerceOptionalSchemasToNullable: zod.z.boolean().optional(),
+  pathParameterOrder: zod.z.enum(["url-order", "spec-order"]).optional(),
+  onlyIncludeReferencedSchemas: zod.z.boolean().optional(),
+  objectQueryParameters: zod.z.boolean().optional(),
+  typeDatesAsStrings: zod.z.boolean().optional(),
+  groupMultiApiEnvironments: zod.z.boolean().optional()
+});
+var sourceSpecTypeSchema = zod.z.enum([
+  "openapi",
+  "swagger",
+  "postman",
+  "asyncapi",
+  "graphql"
+]);
+var sourceSpecConfigSchema = zod.z.strictObject({
+  id: nonEmptyStringSchema.optional(),
+  name: nonEmptyStringSchema.optional(),
+  namespace: nonEmptyStringSchema.optional(),
+  specUrl: nonEmptyStringSchema,
+  specType: sourceSpecTypeSchema,
+  apiImportSettings: apiImportSettingsSchema.optional(),
+  overlays: zod.z.array(nonEmptyStringSchema).optional(),
+  overrides: zod.z.array(nonEmptyStringSchema).optional()
+});
+var sourceConfigSchema = zod.z.strictObject({
+  specs: zod.z.array(sourceSpecConfigSchema).min(1, "source.specs must contain at least one source spec"),
+  apiImportSettings: apiImportSettingsSchema.optional()
+}).superRefine(({ specs }, context) => {
+  const seenIds = /* @__PURE__ */ new Set();
+  specs.forEach(({ id }, index) => {
+    if (id && seenIds.has(id)) {
+      context.addIssue({
+        code: "custom",
+        message: `source spec id "${id}" must be unique`,
+        path: ["specs", index, "id"]
+      });
+    }
+    if (id) {
+      seenIds.add(id);
+    }
+  });
+});
+var targetLanguageSchema = zod.z.enum([
+  "typescript",
+  "python",
+  "java",
+  "kotlin",
+  "go",
+  "csharp",
+  "php",
+  "ruby",
+  "rust",
+  "swift",
+  "cli"
+]);
+var targetConfigSchema = zod.z.strictObject({
+  language: targetLanguageSchema,
+  generatorVersion: exactSemverSchema.optional(),
+  sourceOrigin: zod.z.enum(["postman", "fern"]),
+  sdkName: nonEmptyStringSchema,
+  organization: nonEmptyStringSchema.optional(),
+  sdkVersion: nonEmptyStringSchema.optional(),
+  apiVersion: nonEmptyStringSchema.optional()
+});
+
+// src/sdk-config-ir/v1/sdk-config-ir-v1.ts
+var SDK_CONFIG_IR_V1_SCHEMA_VERSION = "sdk-config-ir/v1";
+var publishRegistryLanguages = {
+  npm: ["typescript"],
+  pypi: ["python"],
+  maven: ["java", "kotlin"],
+  nuget: ["csharp"],
+  rubygems: ["ruby"],
+  crates: ["rust"],
+  go: ["go"],
+  composer: ["php"]
+};
+var packageNameRegistries = /* @__PURE__ */ new Set([
+  "npm",
+  "pypi",
+  "nuget",
+  "rubygems",
+  "crates",
+  "composer"
+]);
+function validatePublishingIdentity(packageConfig, registry, context) {
+  if (packageNameRegistries.has(registry) && !packageConfig.packageName) {
+    context.addIssue({
+      code: "custom",
+      message: `package.packageName is required when publishing to "${registry}"`,
+      path: ["package", "packageName"]
+    });
+    return;
+  }
+  if (registry === "composer" && packageConfig.packageName) {
+    const result = composerPackageNameSchema.safeParse(packageConfig.packageName);
+    if (!result.success) {
+      context.addIssue({
+        code: "custom",
+        message: result.error.issues[0]?.message ?? "Invalid Composer package name",
+        path: ["package", "packageName"]
+      });
+    }
+  }
+  if (registry === "go" && !packageConfig.modulePath) {
+    context.addIssue({
+      code: "custom",
+      message: "package.modulePath is required when publishing a Go module",
+      path: ["package", "modulePath"]
+    });
+  }
+  if (registry === "maven") {
+    ["groupId", "artifactId"].forEach((field) => {
+      if (!packageConfig[field]) {
+        context.addIssue({
+          code: "custom",
+          message: `package.${field} is required when publishing to Maven`,
+          path: ["package", field]
+        });
+      }
+    });
+  }
+}
+var sdkConfigIrV1Schema = zod.z.strictObject({
+  schemaVersion: zod.z.literal(SDK_CONFIG_IR_V1_SCHEMA_VERSION),
+  source: sourceConfigSchema,
+  target: targetConfigSchema,
+  api: apiConfigSchema,
+  client: clientConfigSchema,
+  package: packageConfigSchema,
+  output: outputConfigSchema,
+  docs: docsConfigSchema,
+  generation: generationConfigSchema,
+  compatibility: compatibilityConfigSchema.optional()
+}).superRefine(({ compatibility, generation, output, package: packageConfig, target }, context) => {
+  const configuredLanguages = Object.keys(generation.language ?? {});
+  configuredLanguages.forEach((language) => {
+    if (language !== target.language) {
+      context.addIssue({
+        code: "custom",
+        message: `generation.language.${language} does not match target language "${target.language}"`,
+        path: ["generation", "language", language]
+      });
+    }
+  });
+  if (output.publish && !publishRegistryLanguages[output.publish.registry].some(
+    (language) => language === target.language
+  )) {
+    context.addIssue({
+      code: "custom",
+      message: `registry "${output.publish.registry}" is not supported for target language "${target.language}"`,
+      path: ["output", "publish", "registry"]
+    });
+  }
+  if (output.publish) {
+    validatePublishingIdentity(packageConfig, output.publish.registry, context);
+  }
+  if (compatibility?.legacyInput) {
+    const expectedKind = target.sourceOrigin === "postman" ? "postman-build-parameters" : "fern-generator-invocation";
+    if (compatibility.legacyInput.kind !== expectedKind) {
+      context.addIssue({
+        code: "custom",
+        message: `compatibility.legacyInput kind "${compatibility.legacyInput.kind}" does not match target.sourceOrigin "${target.sourceOrigin}"`,
+        path: ["compatibility", "legacyInput", "kind"]
+      });
+    }
+  }
+});
+function parseSdkConfigIrV1(value) {
+  return sdkConfigIrV1Schema.parse(value);
+}
+
+exports.SDK_CONFIG_IR_V1_SCHEMA_VERSION = SDK_CONFIG_IR_V1_SCHEMA_VERSION;
+exports.apiConfigSchema = apiConfigSchema;
+exports.apiImportSettingsSchema = apiImportSettingsSchema;
+exports.authConfigSchema = authConfigSchema;
+exports.authSchemeSchema = authSchemeSchema;
+exports.cliGenerationConfigSchema = cliGenerationConfigSchema;
+exports.clientConfigSchema = clientConfigSchema;
+exports.compatibilityConfigSchema = compatibilityConfigSchema;
+exports.composerPackageNameSchema = composerPackageNameSchema;
+exports.csharpGenerationConfigSchema = csharpGenerationConfigSchema;
+exports.dependencySchema = dependencySchema;
+exports.docsConfigSchema = docsConfigSchema;
+exports.exactSemverSchema = exactSemverSchema;
+exports.generationConfigSchema = generationConfigSchema;
+exports.goGenerationConfigSchema = goGenerationConfigSchema;
+exports.goModulePathSchema = goModulePathSchema;
+exports.javaGenerationConfigSchema = javaGenerationConfigSchema;
+exports.jsonObjectSchema = jsonObjectSchema;
+exports.jsonValueSchema = jsonValueSchema;
+exports.kotlinGenerationConfigSchema = kotlinGenerationConfigSchema;
+exports.languageGenerationConfigSchema = languageGenerationConfigSchema;
+exports.legacyInputSchema = legacyInputSchema;
+exports.nonEmptyStringSchema = nonEmptyStringSchema;
+exports.outputConfigSchema = outputConfigSchema;
+exports.packageConfigSchema = packageConfigSchema;
+exports.parseSdkConfigIrV1 = parseSdkConfigIrV1;
+exports.phpGenerationConfigSchema = phpGenerationConfigSchema;
+exports.publishConfigSchema = publishConfigSchema;
+exports.publishRegistrySchema = publishRegistrySchema;
+exports.pythonGenerationConfigSchema = pythonGenerationConfigSchema;
+exports.readmeEndpointSchema = readmeEndpointSchema;
+exports.rubyGenerationConfigSchema = rubyGenerationConfigSchema;
+exports.sdkConfigIrV1Schema = sdkConfigIrV1Schema;
+exports.sourceConfigSchema = sourceConfigSchema;
+exports.sourceSpecConfigSchema = sourceSpecConfigSchema;
+exports.sourceSpecTypeSchema = sourceSpecTypeSchema;
+exports.targetConfigSchema = targetConfigSchema;
+exports.targetLanguageSchema = targetLanguageSchema;
+exports.typescriptGenerationConfigSchema = typescriptGenerationConfigSchema;
+exports.unsupportedFieldSchema = unsupportedFieldSchema;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map