@postman/sdk-config 0.0.0 → 0.0.2

package/dist/sdk-config-ir/index.js

@@ -0,0 +1,833 @@
+import { z } from 'zod';
+import semver from 'semver';
+
+// src/sdk-config-ir/v1/api.ts
+var nonEmptyStringSchema = z.string().min(1);
+var exactSemverSchema = z.string().refine(
+  (value) => {
+    if (value.trim() !== value || !/^\d/.test(value)) {
+      return false;
+    }
+    const parsed = semver.parse(value, { loose: false });
+    return parsed?.raw === value;
+  },
+  { message: "must be an exact semantic version" }
+);
+var jsonValueSchema = z.lazy(
+  () => z.union([
+    z.null(),
+    z.boolean(),
+    z.number(),
+    z.string(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema)
+  ])
+);
+var jsonObjectSchema = z.record(z.string(), jsonValueSchema);
+
+// src/sdk-config-ir/v1/api.ts
+var authVariableSchema = z.strictObject({
+  name: nonEmptyStringSchema.optional(),
+  environmentVariable: nonEmptyStringSchema.optional(),
+  description: z.string().optional(),
+  omit: z.boolean().optional()
+});
+var apiKeyAuthSchema = z.strictObject({
+  id: nonEmptyStringSchema,
+  type: z.literal("api-key"),
+  location: z.enum(["header", "query", "cookie"]),
+  name: nonEmptyStringSchema,
+  prefix: nonEmptyStringSchema.optional(),
+  environmentVariable: nonEmptyStringSchema.optional(),
+  description: z.string().optional()
+});
+var bearerAuthSchema = z.strictObject({
+  id: nonEmptyStringSchema,
+  type: z.literal("bearer"),
+  header: nonEmptyStringSchema.optional(),
+  prefix: nonEmptyStringSchema.optional(),
+  environmentVariable: nonEmptyStringSchema.optional(),
+  description: z.string().optional()
+});
+var basicAuthSchema = z.strictObject({
+  id: nonEmptyStringSchema,
+  type: z.literal("basic"),
+  username: authVariableSchema.optional(),
+  password: authVariableSchema.optional(),
+  description: z.string().optional()
+});
+var oauthScopeSchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  description: z.string().optional()
+});
+var oauthFlowSchema = z.discriminatedUnion("type", [
+  z.strictObject({
+    type: z.literal("authorization-code"),
+    authorizationUrl: nonEmptyStringSchema,
+    tokenUrl: nonEmptyStringSchema,
+    refreshUrl: nonEmptyStringSchema.optional(),
+    scopes: z.array(oauthScopeSchema).optional()
+  }),
+  z.strictObject({
+    type: z.literal("client-credentials"),
+    tokenUrl: nonEmptyStringSchema,
+    refreshUrl: nonEmptyStringSchema.optional(),
+    scopes: z.array(oauthScopeSchema).optional()
+  }),
+  z.strictObject({
+    type: z.literal("implicit"),
+    authorizationUrl: nonEmptyStringSchema,
+    refreshUrl: nonEmptyStringSchema.optional(),
+    scopes: z.array(oauthScopeSchema).optional()
+  }),
+  z.strictObject({
+    type: z.literal("password"),
+    tokenUrl: nonEmptyStringSchema,
+    refreshUrl: nonEmptyStringSchema.optional(),
+    scopes: z.array(oauthScopeSchema).optional()
+  })
+]);
+var oauth2AuthSchema = z.strictObject({
+  id: nonEmptyStringSchema,
+  type: z.literal("oauth2"),
+  flows: z.array(oauthFlowSchema).min(1),
+  clientId: authVariableSchema.optional(),
+  clientSecret: authVariableSchema.optional(),
+  tokenHeader: nonEmptyStringSchema.optional(),
+  tokenPrefix: nonEmptyStringSchema.optional(),
+  refreshBufferSeconds: z.number().nonnegative().optional(),
+  description: z.string().optional()
+});
+var customAuthParameterSchema = z.strictObject({
+  location: z.enum(["header", "query", "cookie"]),
+  name: nonEmptyStringSchema,
+  prefix: nonEmptyStringSchema.optional(),
+  environmentVariable: nonEmptyStringSchema.optional()
+});
+var customAuthSchema = z.strictObject({
+  id: nonEmptyStringSchema,
+  type: z.literal("custom"),
+  parameters: z.array(customAuthParameterSchema).min(1),
+  description: z.string().optional()
+});
+var authSchemeSchema = z.discriminatedUnion("type", [
+  apiKeyAuthSchema,
+  bearerAuthSchema,
+  basicAuthSchema,
+  oauth2AuthSchema,
+  customAuthSchema
+]);
+var authRequirementSchema = z.strictObject({
+  schemes: z.array(nonEmptyStringSchema).min(1)
+});
+var authConfigSchema = z.strictObject({
+  schemes: z.array(authSchemeSchema).min(1),
+  requirements: z.array(authRequirementSchema).optional(),
+  endpointSecurity: 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 = z.strictObject({
+  name: nonEmptyStringSchema,
+  url: nonEmptyStringSchema,
+  serverName: nonEmptyStringSchema.optional()
+});
+var environmentSchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  urls: z.array(environmentUrlSchema).min(1),
+  description: z.string().optional()
+});
+var headerSchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  value: z.string().optional(),
+  description: z.string().optional(),
+  environmentVariable: nonEmptyStringSchema.optional()
+});
+var environmentVariableSchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  description: z.string().optional(),
+  defaultValue: z.string().optional()
+});
+var apiConfigSchema = z.strictObject({
+  baseUrl: nonEmptyStringSchema.optional(),
+  defaultEnvironment: nonEmptyStringSchema.optional(),
+  environments: z.array(environmentSchema).optional(),
+  auth: authConfigSchema.optional(),
+  headers: z.array(headerSchema).optional(),
+  environmentVariables: z.array(environmentVariableSchema).optional()
+});
+var retryConfigSchema = z.strictObject({
+  enabled: z.boolean(),
+  maxAttempts: z.number().int().min(1).optional(),
+  retryDelayMs: z.number().nonnegative().optional(),
+  maxDelayMs: z.number().nonnegative().optional(),
+  jitterMs: z.number().nonnegative().optional(),
+  backoffFactor: z.number().positive().optional(),
+  statusCodes: z.array(z.number().int().min(100).max(599)).optional(),
+  methods: z.array(nonEmptyStringSchema).optional(),
+  statusCodeProfile: 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 = z.strictObject({
+  name: nonEmptyStringSchema,
+  example: z.string().optional(),
+  description: z.string().optional(),
+  required: z.boolean().optional()
+});
+var parameterStyleSchema = z.enum(["wrapped", "inline", "language-default"]);
+var tokenRefreshConfigSchema = z.strictObject({
+  enabled: 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 = z.strictObject({
+  retry: retryConfigSchema.optional(),
+  timeoutMs: z.union([z.number().nonnegative(), z.literal("infinity")]).optional(),
+  responseHeaders: z.boolean().optional(),
+  responseValidation: z.boolean().optional(),
+  requestParameterStyle: parameterStyleSchema.optional(),
+  pathParameterStyle: parameterStyleSchema.optional(),
+  filePropertyStyle: parameterStyleSchema.optional(),
+  useDefaultRequestParameterValues: z.boolean().optional(),
+  additionalConstructorParameters: z.array(constructorParameterSchema).optional(),
+  tokenRefresh: tokenRefreshConfigSchema.optional(),
+  multiTenant: z.boolean().optional()
+});
+var unsupportedFieldSchema = z.strictObject({
+  source: z.enum(["fern", "postman", "sdk-config-ir"]),
+  path: z.array(z.union([nonEmptyStringSchema, z.number().int().nonnegative()])).min(1),
+  code: nonEmptyStringSchema.optional(),
+  reason: nonEmptyStringSchema,
+  severity: z.enum(["error", "warning", "info"]),
+  risk: z.enum(["high", "medium", "low"]),
+  owner: nonEmptyStringSchema,
+  suggestedAction: nonEmptyStringSchema
+});
+var postmanLegacyInputSchema = z.strictObject({
+  kind: z.literal("postman-build-parameters"),
+  value: jsonObjectSchema
+});
+var fernLegacyInputSchema = z.strictObject({
+  kind: z.literal("fern-generator-invocation"),
+  value: jsonObjectSchema
+});
+var legacyInputSchema = z.discriminatedUnion("kind", [
+  postmanLegacyInputSchema,
+  fernLegacyInputSchema
+]);
+var compatibilityConfigSchema = z.strictObject({
+  outputProfile: z.enum(["converged", "postman-legacy", "fern-legacy"]),
+  legacyInput: legacyInputSchema.optional(),
+  unsupportedFields: z.array(unsupportedFieldSchema).optional()
+});
+var httpMethodSchema = z.enum([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "TRACE",
+  "CONNECT"
+]);
+var readmeEndpointSchema = z.strictObject({
+  method: httpMethodSchema,
+  path: nonEmptyStringSchema,
+  stream: z.boolean().optional()
+});
+var readmeConfigSchema = z.strictObject({
+  apiName: nonEmptyStringSchema.optional(),
+  introduction: z.string().optional(),
+  apiReferenceLink: nonEmptyStringSchema.optional(),
+  bannerLink: nonEmptyStringSchema.optional(),
+  disabledSections: z.array(nonEmptyStringSchema).optional(),
+  defaultEndpoint: readmeEndpointSchema.optional(),
+  features: z.record(z.string(), z.array(readmeEndpointSchema)).optional()
+});
+var snippetsConfigSchema = z.strictObject({
+  enabled: z.boolean(),
+  format: z.enum(["md", "json"]).optional(),
+  outputPath: nonEmptyStringSchema.optional()
+});
+var docsConfigSchema = z.strictObject({
+  readme: readmeConfigSchema.optional(),
+  snippets: snippetsConfigSchema.optional(),
+  referenceBaseUrl: nonEmptyStringSchema.optional(),
+  includeApiReference: z.boolean().optional()
+});
+var cliGenerationConfigSchema = z.strictObject({
+  paginationParameters: z.array(nonEmptyStringSchema).optional(),
+  skills: z.boolean().optional()
+});
+var csharpGenerationConfigSchema = z.strictObject({
+  useOptionalWrapper: z.boolean().optional(),
+  simplifyObjectDictionaries: z.boolean().optional(),
+  explicitNamespaces: z.boolean().optional(),
+  rootNamespaceForCoreClasses: z.boolean().optional(),
+  includeExceptionHandler: z.boolean().optional()
+});
+var goGenerationConfigSchema = z.strictObject({
+  legacyComplexModels: z.boolean().optional(),
+  unionVersion: z.enum(["v0", "v1"]).optional(),
+  includeLegacyClientOptions: z.boolean().optional()
+});
+var jvmGenerationConfigSchema = z.strictObject({
+  packageLayout: z.enum(["flat", "nested"]).optional(),
+  useLocalDateForDates: z.boolean().optional(),
+  collapseOptionalNullable: z.boolean().optional(),
+  gradleDistributionUrl: z.string().min(1).optional(),
+  gradlePluginManagement: z.string().optional(),
+  gradleCentralDependencyManagement: z.boolean().optional()
+});
+
+// src/sdk-config-ir/v1/language/java.ts
+var javaGenerationConfigSchema = jvmGenerationConfigSchema.extend({
+  includeKotlinSnippets: z.boolean().optional()
+});
+
+// src/sdk-config-ir/v1/language/kotlin.ts
+var kotlinGenerationConfigSchema = jvmGenerationConfigSchema;
+var phpGenerationConfigSchema = z.strictObject({
+  propertyAccess: z.enum(["public", "private"]).optional(),
+  generateClientInterfaces: z.boolean().optional()
+});
+var pythonClientSchema = z.strictObject({
+  fileName: nonEmptyStringSchema.optional(),
+  exportedFileName: nonEmptyStringSchema.optional()
+});
+var pydanticConfigSchema = z.strictObject({
+  versionCompatibility: z.enum(["v1", "v2", "both", "v1-on-v2"]).optional(),
+  frozen: z.boolean().optional(),
+  requireOptionalFields: z.boolean().optional(),
+  unionNaming: z.enum(["v0", "v1"]).optional(),
+  useFieldAliases: z.boolean().optional()
+});
+var pythonGenerationConfigSchema = z.strictObject({
+  pythonVersion: nonEmptyStringSchema.optional(),
+  pydanticVersion: nonEmptyStringSchema.optional(),
+  pydantic: pydanticConfigSchema.optional(),
+  client: pythonClientSchema.optional(),
+  alwaysInitializeOptionals: z.boolean().optional(),
+  useTypedDictRequests: z.boolean().optional()
+});
+var rubyGenerationConfigSchema = z.strictObject({
+  requirePaths: z.array(nonEmptyStringSchema).optional()
+});
+var rustGenerationConfigSchema = 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: z.enum(["offset", "utc"]).optional(),
+  /** Uppercase common initialisms in generated names (`UserID` rather than `UserId`). */
+  capitalizeInitialisms: z.boolean().optional(),
+  /** Cargo features, mapping a feature name to the dependencies or features it enables. */
+  features: z.record(z.string(), z.array(nonEmptyStringSchema)).optional(),
+  /** Overrides which features make up Cargo's `default` feature set. */
+  defaultFeatures: z.array(nonEmptyStringSchema).optional()
+});
+var compilerOptionsSchema = z.strictObject({
+  target: nonEmptyStringSchema.optional(),
+  module: nonEmptyStringSchema.optional(),
+  lib: z.array(nonEmptyStringSchema).optional()
+});
+var packageScriptSchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  command: nonEmptyStringSchema
+});
+var httpClientSchema = z.strictObject({
+  name: z.enum(["axios", "fetch"])
+});
+var typescriptGenerationConfigSchema = z.strictObject({
+  typescriptVersion: nonEmptyStringSchema.optional(),
+  zodVersion: nonEmptyStringSchema.optional(),
+  compilerOptions: compilerOptionsSchema.optional(),
+  httpClient: httpClientSchema.optional(),
+  packageManager: z.enum(["pnpm", "yarn"]).optional(),
+  testFramework: z.enum(["jest", "vitest"]).optional(),
+  namingStrategy: z.enum(["base", "originalPropertyNames"]).optional(),
+  bundle: z.boolean().optional(),
+  exportClassDefault: z.boolean().optional(),
+  allowCustomFetcher: z.boolean().optional(),
+  useBrandedStringAliases: z.boolean().optional(),
+  useLegacyExports: z.boolean().optional(),
+  useBigInt: z.boolean().optional(),
+  serdeLayer: z.boolean().optional(),
+  scripts: z.array(packageScriptSchema).optional()
+});
+
+// src/sdk-config-ir/v1/generation.ts
+var generationAssetSchema = z.strictObject({
+  type: z.enum(["path", "url", "artifact"]),
+  location: nonEmptyStringSchema
+});
+var hookDependencySchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  version: nonEmptyStringSchema,
+  groupId: nonEmptyStringSchema.optional()
+});
+var hooksConfigSchema = z.strictObject({
+  enabled: z.boolean(),
+  source: generationAssetSchema.optional(),
+  dependencies: z.array(hookDependencySchema).optional()
+});
+var customCodeConfigSchema = z.strictObject({
+  enabled: z.boolean(),
+  source: generationAssetSchema.optional(),
+  conflictStrategy: z.enum(["mark", "ours", "theirs"]).optional(),
+  trackChanges: z.boolean().optional(),
+  previousBuildId: z.number().int().positive().optional(),
+  protectedFiles: z.array(nonEmptyStringSchema).optional()
+});
+var workflowConfigSchema = z.strictObject({
+  path: nonEmptyStringSchema,
+  outputName: nonEmptyStringSchema.optional()
+});
+var analyticsHeaderSchema = z.union([
+  z.strictObject({ name: nonEmptyStringSchema, value: z.string() }),
+  z.strictObject({ name: nonEmptyStringSchema, valueRef: nonEmptyStringSchema })
+]);
+var analyticsConfigSchema = z.strictObject({
+  enabled: z.boolean(),
+  endpoint: nonEmptyStringSchema.optional(),
+  exporter: z.enum(["otlp-http", "console"]).optional(),
+  headers: z.array(analyticsHeaderSchema).optional(),
+  batchSize: z.number().int().positive().optional(),
+  scheduledDelayMs: z.number().nonnegative().optional(),
+  exportTimeoutMs: 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 = z.strictObject({
+  enabled: z.boolean(),
+  exclusions: z.array(nonEmptyStringSchema).optional(),
+  fallbackToGeneratedErrorExamples: z.boolean().optional()
+});
+var streamsSchema = z.strictObject({
+  enabled: z.boolean(),
+  responseType: z.enum(["wrapper", "native", "web"]).optional(),
+  fileResponseType: z.enum(["stream", "binary-response"]).optional(),
+  defaultChunkSizeBytes: z.number().int().positive().optional()
+});
+var namingConfigSchema = z.strictObject({
+  clientName: nonEmptyStringSchema.optional(),
+  exportedClientName: nonEmptyStringSchema.optional(),
+  environmentTypeName: nonEmptyStringSchema.optional(),
+  apiErrorName: nonEmptyStringSchema.optional(),
+  baseErrorName: nonEmptyStringSchema.optional(),
+  pagerName: nonEmptyStringSchema.optional()
+});
+var layoutConfigSchema = z.strictObject({
+  outputDirectory: z.enum(["project-root", "source-root"]).optional(),
+  packagePath: nonEmptyStringSchema.optional()
+});
+var serializationConfigSchema = z.strictObject({
+  enumRepresentation: z.enum(["enum", "union", "literal", "forward-compatible-enum", "language-default"]).optional(),
+  additionalProperties: z.enum(["allow", "forbid", "ignore", "language-default"]).optional(),
+  inlineTypes: z.boolean().optional(),
+  omitUndefined: z.boolean().optional()
+});
+var languageGenerationConfigSchema = 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(),
+  rust: rustGenerationConfigSchema.optional(),
+  cli: cliGenerationConfigSchema.optional()
+});
+var generationConfigSchema = z.strictObject({
+  includeWatermark: z.boolean().optional(),
+  includeOptionalSnippetParameters: z.boolean().optional(),
+  buildAllModels: z.boolean().optional(),
+  inferServiceNames: z.boolean().optional(),
+  includeDeprecatedOperations: z.boolean().optional(),
+  multipleResponses: z.boolean().optional(),
+  devContainer: z.boolean().optional(),
+  allowMockClient: z.boolean().optional(),
+  ignoreFiles: z.array(nonEmptyStringSchema).optional(),
+  reservedKeywords: z.array(nonEmptyStringSchema).optional(),
+  hooks: hooksConfigSchema.optional(),
+  customCode: customCodeConfigSchema.optional(),
+  workflows: z.array(workflowConfigSchema).optional(),
+  customQueryPaths: z.array(nonEmptyStringSchema).optional(),
+  analytics: analyticsConfigSchema.optional(),
+  wireTests: wireTestsSchema.optional(),
+  webSockets: z.boolean().optional(),
+  streams: streamsSchema.optional(),
+  naming: namingConfigSchema.optional(),
+  layout: layoutConfigSchema.optional(),
+  serialization: serializationConfigSchema.optional(),
+  language: languageGenerationConfigSchema.optional()
+});
+var publishRegistrySchema = z.enum([
+  "npm",
+  "pypi",
+  "maven",
+  "nuget",
+  "rubygems",
+  "crates",
+  "go",
+  "composer"
+]);
+var commonPublishShape = {
+  url: nonEmptyStringSchema.optional(),
+  credentialsRef: nonEmptyStringSchema.optional(),
+  releaseBranch: nonEmptyStringSchema.optional(),
+  tolerateRepublish: z.boolean().optional()
+};
+var publishConfigSchema = z.discriminatedUnion("registry", [
+  z.strictObject({ registry: z.literal("npm"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("pypi"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("nuget"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("rubygems"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("crates"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("go"), ...commonPublishShape }),
+  z.strictObject({ registry: z.literal("composer"), ...commonPublishShape }),
+  z.strictObject({
+    registry: z.literal("maven"),
+    signingCredentialsRef: nonEmptyStringSchema.optional(),
+    ...commonPublishShape
+  })
+]);
+var reviewersSchema = z.strictObject({
+  teams: z.array(nonEmptyStringSchema).optional(),
+  users: z.array(nonEmptyStringSchema).optional()
+});
+var githubOutputSchema = z.strictObject({
+  repository: nonEmptyStringSchema,
+  host: nonEmptyStringSchema.optional(),
+  branch: nonEmptyStringSchema.optional(),
+  mode: z.enum(["release", "pull-request", "push"]).optional(),
+  reviewers: reviewersSchema.optional(),
+  credentialsRef: nonEmptyStringSchema.optional(),
+  privateRepository: z.boolean().optional()
+});
+var filesOutputSchema = z.strictObject({
+  delivery: z.literal("files"),
+  path: nonEmptyStringSchema.optional(),
+  publish: publishConfigSchema.optional()
+});
+var zipOutputSchema = z.strictObject({
+  delivery: z.literal("zip"),
+  fileName: nonEmptyStringSchema.optional(),
+  publish: publishConfigSchema.optional()
+});
+var githubDeliverySchema = z.strictObject({
+  delivery: z.literal("github"),
+  github: githubOutputSchema,
+  publish: publishConfigSchema.optional()
+});
+var outputConfigSchema = 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 = z.strictObject({
+  name: nonEmptyStringSchema,
+  email: z.email().optional()
+});
+var developerSchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  email: z.email().optional(),
+  organization: nonEmptyStringSchema.optional(),
+  organizationUrl: nonEmptyStringSchema.optional()
+});
+var licenseSchema = z.strictObject({
+  type: nonEmptyStringSchema,
+  name: nonEmptyStringSchema.optional(),
+  url: nonEmptyStringSchema.optional(),
+  path: nonEmptyStringSchema.optional()
+});
+var dependencySourceSchema = z.discriminatedUnion("type", [
+  z.strictObject({
+    type: z.literal("registry"),
+    registry: nonEmptyStringSchema.optional()
+  }),
+  z.strictObject({
+    type: z.literal("git"),
+    url: nonEmptyStringSchema,
+    ref: nonEmptyStringSchema.optional(),
+    subdirectory: nonEmptyStringSchema.optional()
+  }),
+  z.strictObject({
+    type: z.literal("path"),
+    path: nonEmptyStringSchema
+  })
+]);
+var dependencySchema = z.strictObject({
+  name: nonEmptyStringSchema,
+  version: nonEmptyStringSchema.optional(),
+  source: dependencySourceSchema.optional(),
+  packageName: nonEmptyStringSchema.optional(),
+  features: z.array(nonEmptyStringSchema).optional(),
+  extras: z.array(nonEmptyStringSchema).optional(),
+  optional: z.boolean().optional(),
+  defaultFeatures: 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 = z.strictObject({
+  label: nonEmptyStringSchema,
+  url: nonEmptyStringSchema
+});
+var packageConfigSchema = z.strictObject({
+  packageName: nonEmptyStringSchema.optional(),
+  moduleName: nonEmptyStringSchema.optional(),
+  modulePath: goModulePathSchema.optional(),
+  namespace: nonEmptyStringSchema.optional(),
+  groupId: nonEmptyStringSchema.optional(),
+  artifactId: nonEmptyStringSchema.optional(),
+  description: z.string().optional(),
+  repository: nonEmptyStringSchema.optional(),
+  homepage: nonEmptyStringSchema.optional(),
+  documentationUrl: nonEmptyStringSchema.optional(),
+  authors: z.array(authorSchema).optional(),
+  developers: z.array(developerSchema).optional(),
+  license: licenseSchema.optional(),
+  keywords: z.array(nonEmptyStringSchema).optional(),
+  classifiers: z.array(nonEmptyStringSchema).optional(),
+  projectUrls: z.array(projectUrlSchema).optional(),
+  extraDependencies: z.array(dependencySchema).optional(),
+  extraDevDependencies: z.array(dependencySchema).optional(),
+  extraPeerDependencies: z.array(dependencySchema).optional()
+});
+var apiImportSettingsSchema = z.strictObject({
+  respectNullableSchemas: z.boolean().optional(),
+  titleAsSchemaName: z.boolean().optional(),
+  coerceEnumsToLiterals: z.boolean().optional(),
+  idiomaticRequestNames: z.boolean().optional(),
+  wrapReferencesToNullableInOptional: z.boolean().optional(),
+  coerceOptionalSchemasToNullable: z.boolean().optional(),
+  pathParameterOrder: z.enum(["url-order", "spec-order"]).optional(),
+  onlyIncludeReferencedSchemas: z.boolean().optional(),
+  objectQueryParameters: z.boolean().optional(),
+  typeDatesAsStrings: z.boolean().optional(),
+  groupMultiApiEnvironments: z.boolean().optional()
+});
+var sourceSpecTypeSchema = z.enum([
+  "openapi",
+  "swagger",
+  "postman",
+  "asyncapi",
+  "graphql"
+]);
+var sourceSpecConfigSchema = z.strictObject({
+  id: nonEmptyStringSchema.optional(),
+  name: nonEmptyStringSchema.optional(),
+  namespace: nonEmptyStringSchema.optional(),
+  specUrl: nonEmptyStringSchema,
+  specType: sourceSpecTypeSchema,
+  apiImportSettings: apiImportSettingsSchema.optional(),
+  overlays: z.array(nonEmptyStringSchema).optional(),
+  overrides: z.array(nonEmptyStringSchema).optional()
+});
+var sourceConfigSchema = z.strictObject({
+  specs: 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 = z.enum([
+  "typescript",
+  "python",
+  "java",
+  "kotlin",
+  "go",
+  "csharp",
+  "php",
+  "ruby",
+  "rust",
+  "swift",
+  "cli"
+]);
+var targetConfigSchema = z.strictObject({
+  language: targetLanguageSchema,
+  generatorVersion: exactSemverSchema.optional(),
+  sourceOrigin: 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 = z.strictObject({
+  schemaVersion: 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);
+}
+
+export { SDK_CONFIG_IR_V1_SCHEMA_VERSION, apiConfigSchema, apiImportSettingsSchema, authConfigSchema, authSchemeSchema, cliGenerationConfigSchema, clientConfigSchema, compatibilityConfigSchema, composerPackageNameSchema, csharpGenerationConfigSchema, dependencySchema, docsConfigSchema, exactSemverSchema, generationConfigSchema, goGenerationConfigSchema, goModulePathSchema, javaGenerationConfigSchema, jsonObjectSchema, jsonValueSchema, kotlinGenerationConfigSchema, languageGenerationConfigSchema, legacyInputSchema, nonEmptyStringSchema, outputConfigSchema, packageConfigSchema, parseSdkConfigIrV1, phpGenerationConfigSchema, publishConfigSchema, publishRegistrySchema, pythonGenerationConfigSchema, readmeEndpointSchema, rubyGenerationConfigSchema, rustGenerationConfigSchema, sdkConfigIrV1Schema, sourceConfigSchema, sourceSpecConfigSchema, sourceSpecTypeSchema, targetConfigSchema, targetLanguageSchema, typescriptGenerationConfigSchema, unsupportedFieldSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map