@postman/sdk-config 0.6.0 → 0.8.0

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

@@ -38,140 +38,152 @@ var hashAlgorithmSchema = zod.z.enum(["sha1", "sha256", "sha384", "sha512"]);
 var encodingSchema = zod.z.enum(["base64", "hex"]);
 var payloadComponentSchema = zod.z.enum(["body", "timestamp", "notification-url", "message-id"]);
 var payloadFormatSchema = zod.z.strictObject({
-  components: zod.z.array(payloadComponentSchema).min(1),
-  delimiter: zod.z.string().optional(),
+  components: zod.z.array(payloadComponentSchema).min(1).describe("Payload components concatenated in declaration order before signing."),
+  delimiter: zod.z.string().optional().describe("The delimiter inserted between payload components."),
   /**
    * Set when the body is a form-encoded parameter map that must be canonicalized before signing:
    * keys sorted, each key's values deduped and sorted, concatenated as key-value pairs.
    */
-  bodySort: zod.z.literal("alphabetical").optional()
+  bodySort: zod.z.literal("alphabetical").optional().describe("Canonicalizes form body keys and values alphabetically before signing.")
 });
 var timestampSchema = zod.z.strictObject({
-  header: nonEmptyStringSchema,
-  format: zod.z.enum(["unix-seconds", "unix-millis", "iso8601"]).optional(),
+  header: nonEmptyStringSchema.describe("The request header containing the signing timestamp."),
+  format: zod.z.enum(["unix-seconds", "unix-millis", "iso8601"]).optional().describe("The timestamp format used in the signature payload."),
   /** Replay window in seconds. */
-  tolerance: zod.z.number().positive().optional()
+  tolerance: zod.z.number().positive().optional().describe("The maximum accepted timestamp age, in seconds.")
 });
 var bodyHashLocationSchema = zod.z.discriminatedUnion("type", [
   zod.z.strictObject({
-    type: zod.z.literal("query-parameter"),
-    name: nonEmptyStringSchema
+    type: zod.z.literal("query-parameter").describe("Reads the body hash from a query parameter."),
+    name: nonEmptyStringSchema.describe("The query parameter containing the body hash.")
   })
 ]);
 var bodyHashBindingSchema = zod.z.strictObject({
-  algorithm: hashAlgorithmSchema,
-  encoding: encodingSchema.optional(),
-  location: bodyHashLocationSchema
+  algorithm: hashAlgorithmSchema.describe("The hash algorithm applied to the raw request body."),
+  encoding: encodingSchema.optional().describe("The encoding used for the body hash."),
+  location: bodyHashLocationSchema.describe("Where the expected body hash is read from.")
 });
 var urlNormalizationSchema = zod.z.strictObject({
   /** Try the URL with and without an explicit default port. */
-  portVariants: zod.z.boolean().optional(),
+  portVariants: zod.z.boolean().optional().describe("Whether verification tries URLs with and without an explicit default port."),
   /** Try the URL with the pre-RFC3986 query encoding (`+` for space, unescaped `*`). */
-  legacyQueryEncoding: zod.z.boolean().optional()
+  legacyQueryEncoding: zod.z.boolean().optional().describe("Whether verification also tries legacy form-style query encoding.")
 }).refine(
   ({ portVariants, legacyQueryEncoding }) => portVariants === true || legacyQueryEncoding === true,
   { message: "url normalization must enable at least one variant" }
 );
 var webhookSignatureSchema = zod.z.discriminatedUnion("type", [
   zod.z.strictObject({
-    type: zod.z.literal("hmac"),
+    type: zod.z.literal("hmac").describe("Identifies HMAC webhook signature verification."),
     /** Request header carrying the signature. */
-    header: nonEmptyStringSchema,
-    algorithm: hashAlgorithmSchema.optional(),
-    encoding: encodingSchema.optional(),
+    header: nonEmptyStringSchema.describe("The request header containing the signature."),
+    algorithm: hashAlgorithmSchema.optional().describe("The HMAC hash algorithm."),
+    encoding: encodingSchema.optional().describe("The encoding used for the HMAC signature."),
     /** Stripped from the header value before comparison, e.g. `sha256=`. */
-    signaturePrefix: zod.z.string().optional(),
-    payloadFormat: payloadFormatSchema.optional(),
-    timestamp: timestampSchema.optional(),
-    bodyHashBinding: bodyHashBindingSchema.optional(),
-    urlNormalization: urlNormalizationSchema.optional()
+    signaturePrefix: zod.z.string().optional().describe("A prefix removed from the signature header before comparison."),
+    payloadFormat: payloadFormatSchema.optional().describe("How the payload signed by the provider is assembled."),
+    timestamp: timestampSchema.optional().describe("Timestamp validation included in signature verification."),
+    bodyHashBinding: bodyHashBindingSchema.optional().describe("A separately transmitted hash that binds the raw body to the signed payload."),
+    urlNormalization: urlNormalizationSchema.optional().describe("Alternate notification URL forms accepted during verification.")
   })
 ]);
 
 // src/sdk-config-domain/v1/api.ts
 var authVariableSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema.optional(),
-  environmentVariable: nonEmptyStringSchema.optional(),
-  description: zod.z.string().optional(),
-  omit: zod.z.boolean().optional()
+  name: nonEmptyStringSchema.optional().describe("The parameter name exposed by the SDK."),
+  environmentVariable: nonEmptyStringSchema.optional().describe("The environment variable used to populate the parameter."),
+  description: zod.z.string().optional().describe(
+    "A description of the authentication parameter included in generated SDK documentation."
+  ),
+  omit: zod.z.boolean().optional().describe("Whether the parameter is omitted from the SDK surface.")
 });
 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()
+  id: nonEmptyStringSchema.describe("A unique identifier for this authentication scheme."),
+  type: zod.z.literal("api-key").describe("Identifies an API key authentication scheme."),
+  location: zod.z.enum(["header", "query", "cookie"]).describe("Where the API key is sent on requests."),
+  name: nonEmptyStringSchema.describe("The header, query parameter, or cookie name."),
+  prefix: nonEmptyStringSchema.optional().describe("A prefix added before the API key value."),
+  environmentVariable: nonEmptyStringSchema.optional().describe("The default environment variable for the API key."),
+  description: zod.z.string().optional().describe(
+    "A description of the authentication scheme included in generated SDK documentation."
+  )
 });
 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()
+  id: nonEmptyStringSchema.describe("A unique identifier for this authentication scheme."),
+  type: zod.z.literal("bearer").describe("Identifies a bearer token authentication scheme."),
+  header: nonEmptyStringSchema.optional().describe("The request header that carries the bearer token."),
+  prefix: nonEmptyStringSchema.optional().describe('The token prefix, such as "Bearer".'),
+  environmentVariable: nonEmptyStringSchema.optional().describe("The default environment variable for the bearer token."),
+  description: zod.z.string().optional().describe(
+    "A description of the authentication scheme included in generated SDK documentation."
+  )
 });
 var basicAuthSchema = zod.z.strictObject({
-  id: nonEmptyStringSchema,
-  type: zod.z.literal("basic"),
-  username: authVariableSchema.optional(),
-  password: authVariableSchema.optional(),
-  description: zod.z.string().optional()
+  id: nonEmptyStringSchema.describe("A unique identifier for this authentication scheme."),
+  type: zod.z.literal("basic").describe("Identifies an HTTP Basic authentication scheme."),
+  username: authVariableSchema.optional().describe("The username parameter exposed by the SDK."),
+  password: authVariableSchema.optional().describe("The password parameter exposed by the SDK."),
+  description: zod.z.string().optional().describe(
+    "A description of the authentication scheme included in generated SDK documentation."
+  )
 });
 var oauthScopeSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  description: zod.z.string().optional()
+  name: nonEmptyStringSchema.describe("The OAuth scope value requested from the provider."),
+  description: zod.z.string().optional().describe("A description of the OAuth scope included in generated SDK documentation.")
 });
 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()
+    type: zod.z.literal("authorization-code").describe("Uses the OAuth authorization code flow."),
+    authorizationUrl: nonEmptyStringSchema.describe("The URL used to authorize the client."),
+    tokenUrl: nonEmptyStringSchema.describe("The URL used to exchange a code for tokens."),
+    refreshUrl: nonEmptyStringSchema.optional().describe("The URL used to refresh access tokens."),
+    scopes: zod.z.array(oauthScopeSchema).optional().describe("The scopes supported by this flow.")
   }),
   zod.z.strictObject({
-    type: zod.z.literal("client-credentials"),
-    tokenUrl: nonEmptyStringSchema,
-    refreshUrl: nonEmptyStringSchema.optional(),
-    scopes: zod.z.array(oauthScopeSchema).optional()
+    type: zod.z.literal("client-credentials").describe("Uses the OAuth client credentials flow."),
+    tokenUrl: nonEmptyStringSchema.describe("The URL used to obtain access tokens."),
+    refreshUrl: nonEmptyStringSchema.optional().describe("The URL used to refresh access tokens."),
+    scopes: zod.z.array(oauthScopeSchema).optional().describe("The scopes supported by this flow.")
   }),
   zod.z.strictObject({
-    type: zod.z.literal("implicit"),
-    authorizationUrl: nonEmptyStringSchema,
-    refreshUrl: nonEmptyStringSchema.optional(),
-    scopes: zod.z.array(oauthScopeSchema).optional()
+    type: zod.z.literal("implicit").describe("Uses the OAuth implicit flow."),
+    authorizationUrl: nonEmptyStringSchema.describe("The URL used to authorize the client."),
+    refreshUrl: nonEmptyStringSchema.optional().describe("The URL used to refresh access tokens."),
+    scopes: zod.z.array(oauthScopeSchema).optional().describe("The scopes supported by this flow.")
   }),
   zod.z.strictObject({
-    type: zod.z.literal("password"),
-    tokenUrl: nonEmptyStringSchema,
-    refreshUrl: nonEmptyStringSchema.optional(),
-    scopes: zod.z.array(oauthScopeSchema).optional()
+    type: zod.z.literal("password").describe("Uses the OAuth resource owner password flow."),
+    tokenUrl: nonEmptyStringSchema.describe("The URL used to obtain access tokens."),
+    refreshUrl: nonEmptyStringSchema.optional().describe("The URL used to refresh access tokens."),
+    scopes: zod.z.array(oauthScopeSchema).optional().describe("The scopes supported by this flow.")
   })
 ]);
 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()
+  id: nonEmptyStringSchema.describe("A unique identifier for this authentication scheme."),
+  type: zod.z.literal("oauth2").describe("Identifies an OAuth 2.0 authentication scheme."),
+  flows: zod.z.array(oauthFlowSchema).min(1).describe("The OAuth flows supported by the API."),
+  clientId: authVariableSchema.optional().describe("The OAuth client ID parameter exposed by the SDK."),
+  clientSecret: authVariableSchema.optional().describe("The OAuth client secret parameter exposed by the SDK."),
+  tokenHeader: nonEmptyStringSchema.optional().describe("The request header that carries the OAuth access token."),
+  tokenPrefix: nonEmptyStringSchema.optional().describe("The prefix added before the OAuth access token."),
+  refreshBufferSeconds: zod.z.number().nonnegative().optional().describe("How early, in seconds, the client refreshes a token before it expires."),
+  description: zod.z.string().optional().describe(
+    "A description of the authentication scheme included in generated SDK documentation."
+  )
 });
 var customAuthParameterSchema = zod.z.strictObject({
-  location: zod.z.enum(["header", "query", "cookie"]),
-  name: nonEmptyStringSchema,
-  prefix: nonEmptyStringSchema.optional(),
-  environmentVariable: nonEmptyStringSchema.optional()
+  location: zod.z.enum(["header", "query", "cookie"]).describe("Where the custom authentication value is sent."),
+  name: nonEmptyStringSchema.describe("The header, query parameter, or cookie name."),
+  prefix: nonEmptyStringSchema.optional().describe("A prefix added before the parameter value."),
+  environmentVariable: nonEmptyStringSchema.optional().describe("The default environment variable for the parameter.")
 });
 var customAuthSchema = zod.z.strictObject({
-  id: nonEmptyStringSchema,
-  type: zod.z.literal("custom"),
-  parameters: zod.z.array(customAuthParameterSchema).min(1),
-  description: zod.z.string().optional()
+  id: nonEmptyStringSchema.describe("A unique identifier for this authentication scheme."),
+  type: zod.z.literal("custom").describe("Identifies a custom authentication scheme."),
+  parameters: zod.z.array(customAuthParameterSchema).min(1).describe("The request parameters that implement the custom scheme."),
+  description: zod.z.string().optional().describe(
+    "A description of the authentication scheme included in generated SDK documentation."
+  )
 });
 var authSchemeSchema = zod.z.discriminatedUnion("type", [
   apiKeyAuthSchema,
@@ -181,12 +193,12 @@ var authSchemeSchema = zod.z.discriminatedUnion("type", [
   customAuthSchema
 ]);
 var authRequirementSchema = zod.z.strictObject({
-  schemes: zod.z.array(nonEmptyStringSchema).min(1)
+  schemes: zod.z.array(nonEmptyStringSchema).min(1).describe("Scheme identifiers that must be satisfied together.")
 });
 var authConfigSchema = zod.z.strictObject({
-  schemes: zod.z.array(authSchemeSchema).min(1),
-  requirements: zod.z.array(authRequirementSchema).optional(),
-  endpointSecurity: zod.z.boolean().optional()
+  schemes: zod.z.array(authSchemeSchema).min(1).describe("Authentication schemes offered by the API."),
+  requirements: zod.z.array(authRequirementSchema).optional().describe("Valid combinations of authentication schemes."),
+  endpointSecurity: zod.z.boolean().optional().describe("Whether generated endpoints expose their individual security requirements.")
 }).superRefine(({ requirements, schemes }, context) => {
   const schemeIds = /* @__PURE__ */ new Set();
   schemes.forEach(({ id }, index) => {
@@ -212,57 +224,57 @@ var authConfigSchema = zod.z.strictObject({
   });
 });
 var environmentUrlSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  url: nonEmptyStringSchema,
-  serverName: nonEmptyStringSchema.optional()
+  name: nonEmptyStringSchema.describe("The display name for this environment URL."),
+  url: nonEmptyStringSchema.describe("The base URL used for this environment entry."),
+  serverName: nonEmptyStringSchema.optional().describe("The source server represented by this URL.")
 });
 var environmentSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  urls: zod.z.array(environmentUrlSchema).min(1),
-  description: zod.z.string().optional()
+  name: nonEmptyStringSchema.describe("The environment name exposed by the SDK."),
+  urls: zod.z.array(environmentUrlSchema).min(1).describe("The base URLs available in this environment."),
+  description: zod.z.string().optional().describe("A description of the environment included in generated SDK documentation.")
 });
 var headerSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  value: zod.z.string().optional(),
-  description: zod.z.string().optional(),
-  environmentVariable: nonEmptyStringSchema.optional()
+  name: nonEmptyStringSchema.describe("The HTTP header name."),
+  value: zod.z.string().optional().describe("A fixed value for the generated header."),
+  description: zod.z.string().optional().describe("A description of the header included in generated SDK documentation."),
+  environmentVariable: nonEmptyStringSchema.optional().describe("The environment variable used to populate the header.")
 });
 var environmentVariableSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  description: zod.z.string().optional(),
-  defaultValue: zod.z.string().optional()
+  name: nonEmptyStringSchema.describe("The environment variable name exposed by the SDK."),
+  description: zod.z.string().optional().describe("A description of the environment variable included in generated SDK documentation."),
+  defaultValue: zod.z.string().optional().describe("The default value used when the variable is unset.")
 });
 var apiConfigSchema = zod.z.strictObject({
-  baseUrl: zod.z.string().default(""),
-  environments: zod.z.array(environmentSchema).default([]),
-  environmentVariables: zod.z.array(environmentVariableSchema).default([]),
-  defaultEnvironment: nonEmptyStringSchema.optional(),
-  auth: authConfigSchema.optional(),
-  headers: zod.z.array(headerSchema).optional(),
+  baseUrl: zod.z.string().default("").describe("The default base URL used by the generated client."),
+  environments: zod.z.array(environmentSchema).default([]).describe("Named API environments and their base URLs."),
+  environmentVariables: zod.z.array(environmentVariableSchema).default([]).describe("Environment variables exposed through generated client configuration."),
+  defaultEnvironment: nonEmptyStringSchema.optional().describe("The environment selected when a caller does not choose one."),
+  auth: authConfigSchema.optional().describe("Authentication supported by the API."),
+  headers: zod.z.array(headerSchema).optional().describe("Headers added to generated API requests."),
   /**
    * Selects the named `x-fern-audiences`.
    *
    * Absent means all audiences. A present empty array selects no tagged audience: untagged nodes
    * remain included, while every audience-tagged node is excluded.
    */
-  audiences: zod.z.array(nonEmptyStringSchema).optional(),
+  audiences: zod.z.array(nonEmptyStringSchema).optional().describe("Named API audiences included in the generated SDK."),
   /**
    * How the API signs the webhooks it sends, enabling a generated verification helper. API-wide, and
    * independent of whether any webhook is modeled — see {@link webhookSignatureSchema}.
    */
-  webhookSignature: webhookSignatureSchema.optional()
+  webhookSignature: webhookSignatureSchema.optional().describe("How generated helpers verify webhook signatures from the API.")
 });
 var retryOverrideShape = {
-  enabled: zod.z.boolean().optional(),
-  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(),
-  maxRetryAfterDelayMs: zod.z.number().nonnegative().optional()
+  enabled: zod.z.boolean().optional().describe("Whether the generated client retries failed requests."),
+  maxAttempts: zod.z.number().int().min(1).optional().describe("The maximum total request attempts, including the initial attempt."),
+  retryDelayMs: zod.z.number().nonnegative().optional().describe("The initial delay between retry attempts, in milliseconds."),
+  maxDelayMs: zod.z.number().nonnegative().optional().describe("The maximum backoff delay between attempts, in milliseconds."),
+  jitterMs: zod.z.number().nonnegative().optional().describe("The maximum random jitter added to retry delays, in milliseconds."),
+  backoffFactor: zod.z.number().positive().optional().describe("The multiplier applied to the delay after each failed attempt."),
+  statusCodes: zod.z.array(zod.z.number().int().min(100).max(599)).optional().describe("HTTP status codes that are eligible for retries."),
+  methods: zod.z.array(nonEmptyStringSchema).optional().describe("HTTP methods that are eligible for retries."),
+  statusCodeProfile: zod.z.enum(["legacy", "recommended"]).optional().describe("The built-in retryable status-code policy."),
+  maxRetryAfterDelayMs: zod.z.number().nonnegative().optional().describe("The longest Retry-After delay the client will honor, in milliseconds.")
 };
 function validateRetryDelays({
   maxDelayMs,
@@ -279,27 +291,29 @@ function validateRetryDelays({
 var clientRetryOverrideSchema = zod.z.strictObject(retryOverrideShape).superRefine(validateRetryDelays);
 var retryConfigSchema = zod.z.strictObject({
   ...retryOverrideShape,
-  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),
-  methods: zod.z.array(nonEmptyStringSchema).default(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]),
-  maxRetryAfterDelayMs: zod.z.number().nonnegative().default(6e4)
+  enabled: zod.z.boolean().default(true).describe("Whether the generated client retries failed requests."),
+  maxAttempts: zod.z.number().int().min(1).default(3).describe("The maximum total request attempts, including the initial attempt."),
+  retryDelayMs: zod.z.number().nonnegative().default(150).describe("The initial delay between retry attempts, in milliseconds."),
+  maxDelayMs: zod.z.number().nonnegative().default(5e3).describe("The maximum backoff delay between attempts, in milliseconds."),
+  jitterMs: zod.z.number().nonnegative().default(50).describe("The maximum random jitter added to retry delays, in milliseconds."),
+  backoffFactor: zod.z.number().positive().default(2).describe("The multiplier applied to the delay after each failed attempt."),
+  methods: zod.z.array(nonEmptyStringSchema).default(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).describe("HTTP methods that are eligible for retries."),
+  maxRetryAfterDelayMs: zod.z.number().nonnegative().default(6e4).describe("The longest Retry-After delay the client will honor, in milliseconds.")
 }).superRefine(validateRetryDelays);
 var constructorParameterSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  example: zod.z.string().optional(),
-  description: zod.z.string().optional(),
-  required: zod.z.boolean().optional()
+  name: nonEmptyStringSchema.describe("The parameter name in the generated client constructor."),
+  example: zod.z.string().optional().describe("An example value shown in generated documentation."),
+  description: zod.z.string().optional().describe(
+    "A description of the constructor parameter included in generated SDK documentation."
+  ),
+  required: zod.z.boolean().optional().describe("Whether callers must provide the parameter.")
 });
 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()
+  enabled: zod.z.boolean().describe("Whether the client can exchange refresh tokens."),
+  endpoint: nonEmptyStringSchema.optional().describe("The API endpoint used to refresh tokens."),
+  accessTokenField: nonEmptyStringSchema.optional().describe("The response field containing the refreshed access token."),
+  refreshTokenField: nonEmptyStringSchema.optional().describe("The response field containing the refreshed refresh token.")
 }).superRefine(({ enabled, endpoint }, context) => {
   if (enabled && endpoint === void 0) {
     context.addIssue({
@@ -310,53 +324,57 @@ var tokenRefreshConfigSchema = zod.z.strictObject({
   }
 });
 var clientOverrideShape = {
-  retry: clientRetryOverrideSchema.optional(),
-  responseHeaders: zod.z.boolean().optional(),
-  responseValidation: zod.z.boolean().optional(),
-  multiTenant: zod.z.boolean().optional(),
-  additionalConstructorParameters: zod.z.array(constructorParameterSchema).optional(),
-  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(),
-  respectOptionalRequestBody: zod.z.boolean().optional(),
-  tokenRefresh: tokenRefreshConfigSchema.optional()
+  retry: clientRetryOverrideSchema.optional().describe("Retry behavior for generated API requests."),
+  responseHeaders: zod.z.boolean().optional().describe("Whether generated operations expose HTTP response headers."),
+  responseValidation: zod.z.boolean().optional().describe("Whether the client validates API responses against the schema."),
+  multiTenant: zod.z.boolean().optional().describe("Whether the client exposes configuration for tenant-specific API access."),
+  additionalConstructorParameters: zod.z.array(constructorParameterSchema).optional().describe("Additional parameters added to the generated client constructor."),
+  timeoutMs: zod.z.union([zod.z.number().nonnegative(), zod.z.literal("infinity")]).optional().describe('The default request timeout in milliseconds, or "infinity" for no timeout.'),
+  requestParameterStyle: parameterStyleSchema.optional().describe("Whether generated operation parameters are wrapped or passed inline."),
+  pathParameterStyle: parameterStyleSchema.optional().describe("Whether generated path parameters are wrapped or passed inline."),
+  filePropertyStyle: parameterStyleSchema.optional().describe("Whether generated file properties are wrapped or passed inline."),
+  useDefaultRequestParameterValues: zod.z.boolean().optional().describe("Whether schema defaults are applied to omitted request parameters."),
+  respectOptionalRequestBody: zod.z.boolean().optional().describe("Whether an optional request body remains optional in generated methods."),
+  tokenRefresh: tokenRefreshConfigSchema.optional().describe("Refresh-token behavior for the generated client.")
 };
 var clientConfigOverrideSchema = zod.z.strictObject(clientOverrideShape);
 var clientConfigSchema = zod.z.strictObject({
   ...clientOverrideShape,
-  retry: retryConfigSchema.prefault({}),
-  responseHeaders: zod.z.boolean().default(false),
-  multiTenant: zod.z.boolean().default(false),
-  additionalConstructorParameters: zod.z.array(constructorParameterSchema).default([])
+  retry: retryConfigSchema.prefault({}).describe("Retry behavior for generated API requests."),
+  responseHeaders: zod.z.boolean().default(false).describe("Whether generated operations expose HTTP response headers."),
+  multiTenant: zod.z.boolean().default(false).describe("Whether the client exposes configuration for tenant-specific API access."),
+  additionalConstructorParameters: zod.z.array(constructorParameterSchema).default([]).describe("Additional parameters added to the generated client constructor.")
 });
 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
+  source: zod.z.enum(["fern", "postman", "sdk-config-ir"]).describe("The configuration surface containing the unsupported field."),
+  path: zod.z.array(zod.z.union([nonEmptyStringSchema, zod.z.number().int().nonnegative()])).min(1).describe("The property path to the unsupported field in its source configuration."),
+  code: nonEmptyStringSchema.optional().describe("A stable diagnostic code for the unsupported field."),
+  reason: nonEmptyStringSchema.describe(
+    "Why the field could not be represented in normalized configuration."
+  ),
+  severity: zod.z.enum(["error", "warning", "info"]).describe("The diagnostic severity."),
+  risk: zod.z.enum(["high", "medium", "low"]).describe("The migration risk of omitting this field."),
+  owner: nonEmptyStringSchema.describe("The component or team responsible for resolving the gap."),
+  suggestedAction: nonEmptyStringSchema.describe(
+    "Recommended action for preserving the intended behavior."
+  )
 });
 var postmanLegacyInputSchema = zod.z.strictObject({
-  kind: zod.z.literal("postman-build-parameters"),
-  value: jsonObjectSchema
+  kind: zod.z.literal("postman-build-parameters").describe("Identifies legacy Postman build parameters."),
+  value: jsonObjectSchema.describe("A debugging copy of the original Postman build parameters.")
 });
 var fernLegacyInputSchema = zod.z.strictObject({
-  kind: zod.z.literal("fern-generator-invocation"),
-  value: jsonObjectSchema
+  kind: zod.z.literal("fern-generator-invocation").describe("Identifies a legacy Fern generator invocation."),
+  value: jsonObjectSchema.describe("A debugging copy of the original Fern generator invocation.")
 });
 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()
+  outputProfile: zod.z.enum(["converged", "postman-legacy", "fern-legacy"]).describe("The output-default profile retained while legacy producers converge."),
+  legacyInput: legacyInputSchema.optional().describe("Original producer input retained only for migration debugging."),
+  unsupportedFields: zod.z.array(unsupportedFieldSchema).optional().describe("Legacy fields that could not be represented in normalized configuration.")
 });
 var httpMethodSchema = zod.z.enum([
   "GET",
@@ -370,116 +388,122 @@ var httpMethodSchema = zod.z.enum([
   "CONNECT"
 ]);
 var readmeEndpointSchema = zod.z.strictObject({
-  method: httpMethodSchema,
-  path: nonEmptyStringSchema,
-  stream: zod.z.boolean().optional()
+  method: httpMethodSchema.describe("The HTTP method of the documented endpoint."),
+  path: nonEmptyStringSchema.describe("The endpoint path used in generated examples."),
+  stream: zod.z.boolean().optional().describe("Whether the example uses the streaming response API.")
 });
 var readmeCustomSectionSchema = zod.z.strictObject({
-  title: nonEmptyStringSchema,
-  content: zod.z.string()
+  title: nonEmptyStringSchema.describe("The heading displayed for this README section."),
+  content: zod.z.string().describe("The Markdown content of this README section.")
 });
 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(),
-  customSections: zod.z.array(readmeCustomSectionSchema).optional(),
-  defaultEndpoint: readmeEndpointSchema.optional(),
-  features: zod.z.record(zod.z.string(), zod.z.array(readmeEndpointSchema)).optional()
+  apiName: nonEmptyStringSchema.optional().describe("The API name displayed in the README."),
+  introduction: zod.z.string().optional().describe("Custom introductory Markdown for the README."),
+  apiReferenceLink: nonEmptyStringSchema.optional().describe("The URL linked as the API reference."),
+  bannerLink: nonEmptyStringSchema.optional().describe("The destination URL for the README banner."),
+  disabledSections: zod.z.array(nonEmptyStringSchema).optional().describe("Generated README sections to omit."),
+  customSections: zod.z.array(readmeCustomSectionSchema).optional().describe("Additional sections inserted into the README."),
+  defaultEndpoint: readmeEndpointSchema.optional().describe("The endpoint used for the primary README example."),
+  features: zod.z.record(zod.z.string(), zod.z.array(readmeEndpointSchema)).optional().describe("Named feature groups and the endpoints demonstrated by each group.")
 });
 var snippetsConfigSchema = zod.z.strictObject({
-  enabled: zod.z.boolean(),
-  format: zod.z.enum(["md", "json"]).optional(),
-  outputPath: nonEmptyStringSchema.optional()
+  enabled: zod.z.boolean().describe("Whether standalone usage snippets are generated."),
+  format: zod.z.enum(["md", "json"]).optional().describe("The output format for generated snippets."),
+  outputPath: nonEmptyStringSchema.optional().describe("The output path for generated snippet files.")
 });
 var docsConfigSchema = zod.z.strictObject({
-  readme: readmeConfigSchema.optional(),
-  snippets: snippetsConfigSchema.optional(),
-  referenceBaseUrl: nonEmptyStringSchema.optional(),
-  includeApiReference: zod.z.boolean().optional()
+  readme: readmeConfigSchema.optional().describe("README content and example configuration."),
+  snippets: snippetsConfigSchema.optional().describe("Standalone usage snippet generation."),
+  referenceBaseUrl: nonEmptyStringSchema.optional().describe("The base URL used for links to generated API reference files."),
+  includeApiReference: zod.z.boolean().optional().describe("Whether API reference documentation is included in the SDK output.")
 });
 var namingConfigSchema = zod.z.strictObject({
-  clientName: nonEmptyStringSchema.optional(),
-  exportedClientName: nonEmptyStringSchema.optional(),
-  environmentTypeName: nonEmptyStringSchema.optional(),
-  apiErrorName: nonEmptyStringSchema.optional(),
-  baseErrorName: nonEmptyStringSchema.optional(),
-  pagerName: nonEmptyStringSchema.optional(),
+  clientName: nonEmptyStringSchema.optional().describe("The generated client class name."),
+  exportedClientName: nonEmptyStringSchema.optional().describe("The client name exported from the generated package."),
+  environmentTypeName: nonEmptyStringSchema.optional().describe("The generated type name for API environments."),
+  apiErrorName: nonEmptyStringSchema.optional().describe("The generated API error class name."),
+  baseErrorName: nonEmptyStringSchema.optional().describe("The generated base error class name."),
+  pagerName: nonEmptyStringSchema.optional().describe("The generated pagination helper name."),
   /** Apply Fern's initialism-aware casing rules when deriving generated identifiers. */
-  smartCasing: zod.z.boolean().optional(),
+  smartCasing: zod.z.boolean().optional().describe("Whether generated identifiers use initialism-aware casing."),
   /** Preserve a word boundary after digits when Fern smart casing is enabled. */
-  smartCasingDigitWordBoundary: zod.z.boolean().optional()
+  smartCasingDigitWordBoundary: zod.z.boolean().optional().describe("Whether smart casing preserves a word boundary after digits.")
 });
 var cliGenerationConfigSchema = zod.z.strictObject({
-  paginationParameters: zod.z.array(nonEmptyStringSchema).optional(),
-  skills: zod.z.boolean().optional()
+  paginationParameters: zod.z.array(nonEmptyStringSchema).optional().describe("Request parameter names treated as pagination controls by the CLI."),
+  skills: zod.z.boolean().optional().describe("Whether the generated CLI includes skills that teach AI agents to invoke commands.")
 });
 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(),
-  experimentalExplicitNullableOptional: zod.z.boolean().optional()
+  useOptionalWrapper: zod.z.boolean().optional().describe("Whether optional values use an explicit Optional wrapper."),
+  simplifyObjectDictionaries: zod.z.boolean().optional().describe("Whether object schemas with arbitrary values use simplified dictionary types."),
+  explicitNamespaces: zod.z.boolean().optional().describe("Whether generated resource groups use explicit nested namespaces."),
+  rootNamespaceForCoreClasses: zod.z.boolean().optional().describe("Whether shared client classes are emitted in the root namespace."),
+  includeExceptionHandler: zod.z.boolean().optional().describe("Whether generated client operations use a configurable exception handler."),
+  experimentalExplicitNullableOptional: zod.z.boolean().optional().describe(
+    "Whether optional nullable properties distinguish omitted values from explicit nulls."
+  )
 });
 var goGenerationConfigSchema = zod.z.strictObject({
-  legacyComplexModels: zod.z.boolean().optional(),
+  legacyComplexModels: zod.z.boolean().optional().describe("Whether complex models use the legacy Go representation."),
   /** Uppercase common initialisms in generated names (`UserID` rather than `UserId`). */
-  smartCasing: zod.z.boolean().optional(),
+  smartCasing: zod.z.boolean().optional().describe("Whether generated Go names capitalize common initialisms."),
   /** Overrides the fern root-client constructor independently from the client type name. */
-  clientConstructorName: nonEmptyStringSchema.optional(),
-  unionVersion: zod.z.enum(["v0", "v1"]).optional(),
-  includeLegacyClientOptions: zod.z.boolean().optional()
+  clientConstructorName: nonEmptyStringSchema.optional().describe("The generated root-client constructor name."),
+  unionVersion: zod.z.enum(["v0", "v1"]).optional().describe("The representation used for generated Go unions."),
+  includeLegacyClientOptions: zod.z.boolean().optional().describe("Whether the client retains legacy constructor option helpers.")
 });
 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(),
+  packageLayout: zod.z.enum(["flat", "nested"]).optional().describe("Whether generated JVM packages use a flat or nested resource layout."),
+  useLocalDateForDates: zod.z.boolean().optional().describe("Whether date-only values use LocalDate instead of OffsetDateTime."),
+  collapseOptionalNullable: zod.z.boolean().optional().describe("Whether optional nullable values collapse into a single nullable representation."),
+  gradleDistributionUrl: zod.z.string().min(1).optional().describe("The Gradle distribution URL written to the generated wrapper."),
+  gradlePluginManagement: zod.z.string().optional().describe("Plugin management configuration added to the generated Gradle settings."),
+  gradleCentralDependencyManagement: zod.z.boolean().optional().describe("Whether dependency versions are managed centrally in the Gradle project."),
   /** Selects co-located async methods or a separate async client surface. */
-  asyncStyle: zod.z.enum(["dedicated-client", "twin-methods"]).optional()
+  asyncStyle: zod.z.enum(["dedicated-client", "twin-methods"]).optional().describe("Whether asynchronous operations use a separate client or co-located methods.")
 });
 
 // src/sdk-config-domain/v1/language/java.ts
 var javaGenerationConfigSchema = jvmGenerationConfigSchema.extend({
-  includeKotlinSnippets: zod.z.boolean().optional()
+  includeKotlinSnippets: zod.z.boolean().optional().describe("Whether Java SDK documentation includes Kotlin usage snippets.")
 });
 
 // src/sdk-config-domain/v1/language/kotlin.ts
 var kotlinGenerationConfigSchema = jvmGenerationConfigSchema;
 var compilerOptionsSchema = zod.z.strictObject({
-  target: nonEmptyStringSchema.optional(),
-  module: nonEmptyStringSchema.optional(),
-  lib: zod.z.array(nonEmptyStringSchema).optional()
+  target: nonEmptyStringSchema.optional().describe("The JavaScript language target passed to TypeScript."),
+  module: nonEmptyStringSchema.optional().describe("The module format passed to TypeScript."),
+  lib: zod.z.array(nonEmptyStringSchema).optional().describe("The runtime library definitions passed to TypeScript.")
 });
 var packageScriptSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  command: nonEmptyStringSchema
+  name: nonEmptyStringSchema.describe("The package script name."),
+  command: nonEmptyStringSchema.describe("The command executed by the package script.")
 });
 var httpClientSchema = zod.z.strictObject({
-  name: zod.z.enum(["axios", "fetch"])
+  name: zod.z.enum(["axios", "fetch"]).describe("The HTTP client used by generated TypeScript code.")
 });
 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(),
+  typescriptVersion: nonEmptyStringSchema.optional().describe("The TypeScript version used by the generated project."),
+  zodVersion: nonEmptyStringSchema.optional().describe("The Zod version used by generated runtime schemas."),
+  compilerOptions: compilerOptionsSchema.optional().describe("TypeScript compiler options for the generated project."),
+  httpClient: httpClientSchema.optional().describe("The HTTP client used by generated TypeScript code."),
+  packageManager: zod.z.enum(["pnpm", "yarn"]).optional().describe("The package manager used by the generated project."),
+  packageManagerVersion: nonEmptyStringSchema.optional().describe("The package manager version used by the generated project."),
+  testFramework: zod.z.enum(["jest", "vitest"]).optional().describe("The test framework used by generated tests."),
+  namingStrategy: zod.z.enum(["base", "originalPropertyNames"]).optional().describe("How schema property names are converted into TypeScript identifiers."),
+  bundle: zod.z.boolean().optional().describe("Whether the generated package includes bundled output."),
+  exportClassDefault: zod.z.boolean().optional().describe("Whether the client class is also exported as the default export."),
   /** Name of the top-level namespace export emitted by Fern-compatible TypeScript SDKs. */
-  namespaceExportName: nonEmptyStringSchema.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()
+  namespaceExportName: nonEmptyStringSchema.optional().describe("The top-level namespace export name."),
+  consolidateTypeFiles: zod.z.boolean().optional().describe("Whether generated types are consolidated into fewer source files."),
+  allowCustomFetcher: zod.z.boolean().optional().describe("Whether callers can supply a custom fetch implementation."),
+  useBrandedStringAliases: zod.z.boolean().optional().describe("Whether string aliases are emitted as distinct branded types."),
+  useLegacyExports: zod.z.boolean().optional().describe("Whether the package emits the legacy export layout."),
+  useBigInt: zod.z.boolean().optional().describe("Whether 64-bit integer values are represented with bigint."),
+  serdeLayer: zod.z.boolean().optional().describe("Whether generated models use Fern serialization and deserialization helpers."),
+  /** Ship only the ESM build (drops CJS) to avoid the Node dual-package hazard. */
+  esmOnly: zod.z.boolean().optional().describe("Whether the package emits only ECMAScript modules."),
+  scripts: zod.z.array(packageScriptSchema).optional().describe("Additional scripts added to the generated package manifest.")
 });
 
 // src/sdk-config-domain/v1/language/mcp.ts
@@ -494,75 +518,75 @@ var mcpAvailabilityStatuses = [
   "LEGACY"
 ];
 var mcpToolFilterSchema = zod.z.strictObject({
-  include: zod.z.array(nonEmptyStringSchema).optional(),
-  exclude: zod.z.array(nonEmptyStringSchema).optional()
+  include: zod.z.array(nonEmptyStringSchema).optional().describe("Operations explicitly included as MCP tools."),
+  exclude: zod.z.array(nonEmptyStringSchema).optional().describe("Operations explicitly excluded from MCP tools.")
 });
 var mcpToolsetNameSchema = nonEmptyStringSchema.refine(
   (name) => name !== "default" && /^[a-z0-9-]+$/.test(name),
   'toolset names must match [a-z0-9-]+ and cannot be "default"'
 );
 var mcpGenerationConfigSchema = typescriptGenerationConfigSchema.extend({
-  serverName: nonEmptyStringSchema.optional(),
-  serverDescription: nonEmptyStringSchema.optional(),
-  excludeAvailability: zod.z.array(zod.z.enum(mcpAvailabilityStatuses)).optional(),
-  tools: mcpToolFilterSchema.optional(),
-  toolsets: zod.z.record(mcpToolsetNameSchema, mcpToolFilterSchema).optional()
+  serverName: nonEmptyStringSchema.optional().describe("The name advertised by the generated MCP server."),
+  serverDescription: nonEmptyStringSchema.optional().describe("The description advertised by the generated MCP server."),
+  excludeAvailability: zod.z.array(zod.z.enum(mcpAvailabilityStatuses)).optional().describe("Operation availability statuses excluded from MCP tool generation."),
+  tools: mcpToolFilterSchema.optional().describe("Global operation filters for generated MCP tools."),
+  toolsets: zod.z.record(mcpToolsetNameSchema, mcpToolFilterSchema).optional().describe("Named MCP toolsets and the operation filters for each toolset.")
 });
 var phpGenerationConfigSchema = zod.z.strictObject({
-  propertyAccess: zod.z.enum(["public", "private"]).optional(),
-  generateClientInterfaces: zod.z.boolean().optional()
+  propertyAccess: zod.z.enum(["public", "private"]).optional().describe("The visibility of generated PHP model properties."),
+  generateClientInterfaces: zod.z.boolean().optional().describe("Whether interfaces are generated for PHP client classes.")
 });
 var pythonClientSchema = zod.z.strictObject({
-  fileName: nonEmptyStringSchema.optional(),
-  exportedFileName: nonEmptyStringSchema.optional()
+  fileName: nonEmptyStringSchema.optional().describe("The source file name for the Python client."),
+  exportedFileName: nonEmptyStringSchema.optional().describe("The file name used when exporting the Python client.")
 });
 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()
+  versionCompatibility: zod.z.enum(["v1", "v2", "both", "v1-on-v2"]).optional().describe("The Pydantic major versions supported by generated models."),
+  frozen: zod.z.boolean().optional().describe("Whether generated Pydantic models are immutable."),
+  requireOptionalFields: zod.z.boolean().optional().describe("Whether Optional fields remain required unless they declare a default."),
+  unionNaming: zod.z.enum(["v0", "v1"]).optional().describe("The naming strategy for generated union types."),
+  useFieldAliases: zod.z.boolean().optional().describe("Whether Pydantic field aliases preserve wire names.")
 });
 var additionalInitExportSchema = zod.z.strictObject({
-  from: nonEmptyStringSchema,
-  imports: zod.z.array(nonEmptyStringSchema).min(1)
+  from: nonEmptyStringSchema.describe("The module from which names are re-exported."),
+  imports: zod.z.array(nonEmptyStringSchema).min(1).describe("Names re-exported from the module.")
 });
 var pythonGenerationConfigSchema = zod.z.strictObject({
-  pythonVersion: nonEmptyStringSchema.optional(),
-  pydanticVersion: nonEmptyStringSchema.optional(),
-  pydantic: pydanticConfigSchema.optional(),
-  client: pythonClientSchema.optional(),
+  pythonVersion: nonEmptyStringSchema.optional().describe("The Python version targeted by the generated project."),
+  pydanticVersion: nonEmptyStringSchema.optional().describe("The Pydantic dependency version requirement."),
+  pydantic: pydanticConfigSchema.optional().describe("Pydantic model-generation behavior."),
+  client: pythonClientSchema.optional().describe("Python client file naming."),
   /** Default followed by generated sync and async HTTP clients when the caller does not override it. */
-  followRedirectsByDefault: zod.z.boolean().optional(),
+  followRedirectsByDefault: zod.z.boolean().optional().describe("Whether generated HTTP clients follow redirects by default."),
   /** Chunk size passed to Python byte-stream iterators. */
-  defaultBytesStreamChunkSize: zod.z.number().int().positive().optional(),
+  defaultBytesStreamChunkSize: zod.z.number().int().positive().optional().describe("The default byte-stream iterator chunk size."),
   /** Python interpreter recursion limit installed by the generated package at import time. */
-  recursionLimit: zod.z.number().int().gt(1e3).optional(),
+  recursionLimit: zod.z.number().int().gt(1e3).optional().describe("The Python recursion limit installed when the generated package is imported."),
   /** Published Python extras, keyed by extra name with package dependency names as values. */
-  extras: zod.z.record(nonEmptyStringSchema, zod.z.array(nonEmptyStringSchema)).optional(),
-  alwaysInitializeOptionals: zod.z.boolean().optional(),
-  useTypedDictRequests: zod.z.boolean().optional(),
-  additionalInitExports: zod.z.array(additionalInitExportSchema).optional()
+  extras: zod.z.record(nonEmptyStringSchema, zod.z.array(nonEmptyStringSchema)).optional().describe("Published Python extras and their dependency names."),
+  alwaysInitializeOptionals: zod.z.boolean().optional().describe("Whether optional model fields are initialized even when omitted."),
+  useTypedDictRequests: zod.z.boolean().optional().describe("Whether request bodies are generated as TypedDict types."),
+  additionalInitExports: zod.z.array(additionalInitExportSchema).optional().describe("Additional names re-exported from the package initializer.")
 });
 var rubyGenerationConfigSchema = zod.z.strictObject({
-  requirePaths: zod.z.array(nonEmptyStringSchema).optional()
+  requirePaths: zod.z.array(nonEmptyStringSchema).optional().describe("Ruby load paths included in the generated gem specification.")
 });
 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(),
+  dateTimeType: zod.z.enum(["offset", "utc"]).optional().describe("Whether datetime values preserve their offset or normalize to UTC."),
   /** Uppercase common initialisms in generated names (`UserID` rather than `UserId`). */
-  capitalizeInitialisms: zod.z.boolean().optional(),
+  capitalizeInitialisms: zod.z.boolean().optional().describe("Whether generated Rust names capitalize common initialisms."),
   /** 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(),
+  features: zod.z.record(zod.z.string(), zod.z.array(nonEmptyStringSchema)).optional().describe("Cargo features and the dependencies or features each enables."),
   /** Overrides which features make up Cargo's `default` feature set. */
-  defaultFeatures: zod.z.array(nonEmptyStringSchema).optional()
+  defaultFeatures: zod.z.array(nonEmptyStringSchema).optional().describe("Cargo features included in the crate default feature set.")
 });
 var swiftGenerationConfigSchema = zod.z.strictObject({
-  moduleName: nonEmptyStringSchema.optional(),
-  nullableAsOptional: zod.z.boolean().optional()
+  moduleName: nonEmptyStringSchema.optional().describe("The Swift module name for the generated package."),
+  nullableAsOptional: zod.z.boolean().optional().describe("Whether nullable values are represented as Swift optionals.")
 });
 var goModulePathSchema = relativePathSchema.regex(
   /^(?!.*(?:^|\/)\.{1,2}(?:\/|$))[A-Za-z0-9._~-]+(?:\/[A-Za-z0-9._~-]+)*$/,
@@ -573,140 +597,166 @@ var composerPackageNameSchema = nonEmptyStringSchema.regex(
   'Composer package name must be a lowercase "vendor/package" name'
 );
 var authorSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  email: zod.z.email().optional(),
-  url: nonEmptyStringSchema.optional()
+  name: nonEmptyStringSchema.describe("The package author name."),
+  email: zod.z.email().optional().describe("The package author email address."),
+  url: nonEmptyStringSchema.optional().describe("The package author website.")
 });
 var developerSchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  email: zod.z.email().optional(),
-  organization: nonEmptyStringSchema.optional(),
-  organizationUrl: nonEmptyStringSchema.optional()
+  name: nonEmptyStringSchema.describe("The package developer name."),
+  email: zod.z.email().optional().describe("The package developer email address."),
+  organization: nonEmptyStringSchema.optional().describe("The developer organization name."),
+  organizationUrl: nonEmptyStringSchema.optional().describe("The developer organization website.")
 });
 var licenseSchema = zod.z.strictObject({
-  type: nonEmptyStringSchema,
-  name: nonEmptyStringSchema.optional(),
-  url: nonEmptyStringSchema.optional(),
-  path: nonEmptyStringSchema.optional()
+  type: nonEmptyStringSchema.describe("The license identifier or license type."),
+  name: nonEmptyStringSchema.optional().describe("The human-readable license name."),
+  url: nonEmptyStringSchema.optional().describe("The URL containing the license text."),
+  path: nonEmptyStringSchema.optional().describe("The path to a custom license file.")
 });
 var dependencySourceSchema = zod.z.discriminatedUnion("type", [
   zod.z.strictObject({
-    type: zod.z.literal("registry"),
-    registry: nonEmptyStringSchema.optional()
+    type: zod.z.literal("registry").describe("Resolves the dependency from a package registry."),
+    registry: nonEmptyStringSchema.optional().describe("The registry used to resolve the dependency.")
   }),
   zod.z.strictObject({
-    type: zod.z.literal("git"),
-    url: nonEmptyStringSchema,
-    ref: nonEmptyStringSchema.optional(),
-    subdirectory: nonEmptyStringSchema.optional()
+    type: zod.z.literal("git").describe("Resolves the dependency from a Git repository."),
+    url: nonEmptyStringSchema.describe("The Git repository URL."),
+    ref: nonEmptyStringSchema.optional().describe("The Git branch, tag, or commit to use."),
+    subdirectory: nonEmptyStringSchema.optional().describe("The package subdirectory within the Git repository.")
   }),
   zod.z.strictObject({
-    type: zod.z.literal("path"),
-    path: nonEmptyStringSchema
+    type: zod.z.literal("path").describe("Resolves the dependency from a local path."),
+    path: nonEmptyStringSchema.describe("The local path containing the dependency.")
   })
 ]);
 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()
+  name: nonEmptyStringSchema.describe("The dependency name used by the package manager."),
+  version: nonEmptyStringSchema.optional().describe("The dependency version requirement."),
+  source: dependencySourceSchema.optional().describe("A non-default source for the dependency."),
+  packageName: nonEmptyStringSchema.optional().describe("The source package name when it differs from the dependency alias."),
+  features: zod.z.array(nonEmptyStringSchema).optional().describe("Cargo features enabled for this dependency."),
+  extras: zod.z.array(nonEmptyStringSchema).optional().describe("Python extras enabled for this dependency."),
+  optional: zod.z.boolean().optional().describe("Whether the dependency is optional."),
+  defaultFeatures: zod.z.boolean().optional().describe("Whether the dependency enables its default Cargo features."),
+  environmentMarker: nonEmptyStringSchema.optional().describe("A Python environment marker that conditions this dependency.")
 }).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
+  label: nonEmptyStringSchema.describe("The label displayed for the project link."),
+  url: nonEmptyStringSchema.describe("The project link URL.")
 });
 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()
+  packageName: nonEmptyStringSchema.optional().describe("The package name used by the target language registry."),
+  moduleName: nonEmptyStringSchema.optional().describe("The generated module or import name when it differs from the package name."),
+  modulePath: goModulePathSchema.optional().describe("The Go module path used for imports and publishing."),
+  namespace: nonEmptyStringSchema.optional().describe("The namespace or package prefix for generated code."),
+  groupId: nonEmptyStringSchema.optional().describe("The Maven group identifier."),
+  artifactId: nonEmptyStringSchema.optional().describe("The Maven artifact identifier."),
+  description: zod.z.string().optional().describe("The package description used in generated metadata."),
+  repository: nonEmptyStringSchema.optional().describe("The source repository for the generated SDK."),
+  homepage: nonEmptyStringSchema.optional().describe("The package homepage URL."),
+  documentationUrl: nonEmptyStringSchema.optional().describe("The package documentation URL."),
+  authors: zod.z.array(authorSchema).optional().describe("Authors credited in package metadata."),
+  developers: zod.z.array(developerSchema).optional().describe("Developers credited in package metadata."),
+  license: licenseSchema.optional().describe("License metadata for the generated package."),
+  keywords: zod.z.array(nonEmptyStringSchema).optional().describe("Search keywords for package metadata."),
+  classifiers: zod.z.array(nonEmptyStringSchema).optional().describe("Package classifiers used by registries such as PyPI."),
+  projectUrls: zod.z.array(projectUrlSchema).optional().describe("Labeled project links for package metadata."),
+  extraDependencies: zod.z.array(dependencySchema).optional().describe("Additional runtime dependencies added to the generated package."),
+  extraDevDependencies: zod.z.array(dependencySchema).optional().describe("Additional development dependencies added to the generated package."),
+  extraPeerDependencies: zod.z.array(dependencySchema).optional().describe("Additional peer dependencies added to the generated package.")
 });
 
 // src/sdk-config-domain/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) })
+  zod.z.strictObject({
+    enabled: zod.z.literal(true).describe("Enables custom Terraform plan modifiers."),
+    sourceDir: nonEmptyStringSchema.describe(
+      "The directory containing custom plan modifier source files."
+    )
+  }),
+  zod.z.strictObject({
+    enabled: zod.z.literal(false).describe("Disables custom Terraform plan modifiers.")
+  })
 ]);
 var planModifiersSchema = zod.z.strictObject({
-  resources: planModifierSourceSchema,
-  attributes: planModifierSourceSchema
+  resources: planModifierSourceSchema.describe("Custom plan modifiers for generated resources."),
+  attributes: planModifierSourceSchema.describe("Custom plan modifiers for generated attributes.")
 });
 var providerSchemaSchema = zod.z.strictObject({
-  addressKey: nonEmptyStringSchema,
-  authTokenKey: nonEmptyStringSchema
+  addressKey: nonEmptyStringSchema.describe(
+    "The provider attribute used to configure the API address."
+  ),
+  authTokenKey: nonEmptyStringSchema.describe(
+    "The provider attribute used to configure the authentication token."
+  )
 });
 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()
+  providerName: nonEmptyStringSchema.optional().describe("The Terraform provider name."),
+  providerVersion: nonEmptyStringSchema.optional().describe("The generated Terraform provider version."),
+  providerModulePath: goModulePathSchema.optional().describe("The Go module path for the generated provider."),
+  mockAcceptance: zod.z.boolean().optional().describe("Whether acceptance tests use a mock API server."),
+  hideComputedDiff: zod.z.boolean().optional().describe("Whether computed-only changes are hidden from Terraform plans."),
+  providerSchema: providerSchemaSchema.optional().describe("Names of provider-level configuration attributes."),
+  planModifiers: planModifiersSchema.optional().describe("Custom plan modifier source configuration.")
 });
 
 // src/sdk-config-ir/v1/generation.ts
 var generationAssetSchema = zod.z.discriminatedUnion("type", [
-  zod.z.strictObject({ type: zod.z.literal("path"), location: relativePathSchema }),
-  zod.z.strictObject({ type: zod.z.literal("url"), location: nonEmptyStringSchema }),
-  zod.z.strictObject({ type: zod.z.literal("artifact"), location: nonEmptyStringSchema })
+  zod.z.strictObject({
+    type: zod.z.literal("path").describe("Loads the generation asset from a relative path."),
+    location: relativePathSchema.describe("The relative path to the generation asset.")
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("url").describe("Loads the generation asset from a URL."),
+    location: nonEmptyStringSchema.describe("The URL of the generation asset.")
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("artifact").describe("Loads the generation asset from stored build output."),
+    location: nonEmptyStringSchema.describe("The artifact identifier or location.")
+  })
 ]);
 var hookDependencySchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  version: nonEmptyStringSchema,
-  groupId: nonEmptyStringSchema.optional()
+  name: nonEmptyStringSchema.describe("The hook dependency name."),
+  version: nonEmptyStringSchema.describe("The hook dependency version requirement."),
+  groupId: nonEmptyStringSchema.optional().describe("The Maven group identifier for the dependency.")
 });
 var hooksConfigSchema = zod.z.strictObject({
-  enabled: zod.z.boolean(),
-  source: generationAssetSchema.optional(),
-  dependencies: zod.z.array(hookDependencySchema).optional()
+  enabled: zod.z.boolean().describe("Whether custom request and response hooks are generated."),
+  source: generationAssetSchema.optional().describe("The source containing custom hook implementations."),
+  dependencies: zod.z.array(hookDependencySchema).optional().describe("Dependencies required by custom hooks.")
 });
 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()
+  enabled: zod.z.boolean().describe("Whether customer-authored code is merged into generated output."),
+  source: generationAssetSchema.optional().describe("The source containing customer-authored code."),
+  conflictStrategy: zod.z.enum(["mark", "ours", "theirs"]).optional().describe("How merge conflicts between generated and custom code are handled."),
+  trackChanges: zod.z.boolean().optional().describe("Whether custom-code changes are tracked between builds."),
+  previousBuildId: zod.z.number().int().positive().optional().describe("The previous build used as the merge baseline."),
+  protectedFiles: zod.z.array(nonEmptyStringSchema).optional().describe("Generated file paths that custom-code merging must not overwrite.")
 });
 var workflowConfigSchema = zod.z.strictObject({
-  path: relativePathSchema,
-  outputName: nonEmptyStringSchema.optional()
+  path: relativePathSchema.describe("The relative path to the workflow definition."),
+  outputName: nonEmptyStringSchema.optional().describe("The file name used for the generated workflow.")
 });
 var analyticsHeaderSchema = zod.z.union([
-  zod.z.strictObject({ name: nonEmptyStringSchema, value: zod.z.string() }),
-  zod.z.strictObject({ name: nonEmptyStringSchema, valueRef: nonEmptyStringSchema })
+  zod.z.strictObject({
+    name: nonEmptyStringSchema.describe("The exported telemetry header name."),
+    value: zod.z.string().describe("The literal telemetry header value.")
+  }),
+  zod.z.strictObject({
+    name: nonEmptyStringSchema.describe("The exported telemetry header name."),
+    valueRef: nonEmptyStringSchema.describe("A reference to the telemetry header value.")
+  })
 ]);
 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()
+  enabled: zod.z.boolean().describe("Whether generated clients export usage telemetry."),
+  endpoint: nonEmptyStringSchema.optional().describe("The telemetry export endpoint."),
+  exporter: zod.z.enum(["otlp-http", "console"]).optional().describe("The telemetry exporter implementation."),
+  headers: zod.z.array(analyticsHeaderSchema).optional().describe("Headers sent by the telemetry exporter."),
+  batchSize: zod.z.number().int().positive().optional().describe("The maximum spans in each export batch."),
+  scheduledDelayMs: zod.z.number().nonnegative().optional().describe("The delay between scheduled exports, in milliseconds."),
+  exportTimeoutMs: zod.z.number().nonnegative().optional().describe("The maximum time allowed for an export, in milliseconds.")
 }).superRefine(({ enabled, endpoint }, context) => {
   if (enabled && endpoint === void 0) {
     context.addIssue({
@@ -717,91 +767,93 @@ var analyticsConfigSchema = zod.z.strictObject({
   }
 });
 var wireTestsSchema = zod.z.strictObject({
-  enabled: zod.z.boolean(),
-  exclusions: zod.z.array(nonEmptyStringSchema).optional(),
-  fallbackToGeneratedErrorExamples: zod.z.boolean().optional(),
-  fixtureSource: zod.z.enum(["synthetic", "recorded", "auto"]).optional()
+  enabled: zod.z.boolean().describe("Whether wire-level request and response tests are generated."),
+  exclusions: zod.z.array(nonEmptyStringSchema).optional().describe("Operations excluded from wire tests."),
+  fallbackToGeneratedErrorExamples: zod.z.boolean().optional().describe("Whether missing error fixtures are synthesized from generated examples."),
+  fixtureSource: zod.z.enum(["synthetic", "recorded", "auto"]).optional().describe("Where wire-test fixtures are obtained.")
 });
 var unitTestsSchema = zod.z.strictObject({
-  enabled: zod.z.boolean(),
-  mode: zod.z.enum(["core-runtime", "schema-driven", "both"]).optional(),
-  exclusions: zod.z.array(nonEmptyStringSchema).optional()
+  enabled: zod.z.boolean().describe("Whether SDK unit tests are generated."),
+  mode: zod.z.enum(["core-runtime", "schema-driven", "both"]).optional().describe("The unit-test generation strategy."),
+  exclusions: zod.z.array(nonEmptyStringSchema).optional().describe("Operations excluded from unit tests.")
 });
 var fernDefinitionMetadataSchema = zod.z.strictObject({
-  definitionS3DownloadUrl: nonEmptyStringSchema,
-  outputPath: nonEmptyStringSchema.optional(),
-  cliVersion: nonEmptyStringSchema.optional()
+  definitionS3DownloadUrl: nonEmptyStringSchema.describe(
+    "The download URL for the materialized Fern definition archive."
+  ),
+  outputPath: nonEmptyStringSchema.optional().describe("The destination path for Fern definition support files."),
+  cliVersion: nonEmptyStringSchema.optional().describe("The Fern CLI version associated with the definition.")
 });
 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()
+  enabled: zod.z.boolean().describe("Whether generated clients expose streaming response APIs."),
+  responseType: zod.z.enum(["wrapper", "native", "web"]).optional().describe("The streaming response abstraction exposed by generated clients."),
+  fileResponseType: zod.z.enum(["stream", "binary-response"]).optional().describe("The response type used for file downloads."),
+  defaultChunkSizeBytes: zod.z.number().int().positive().optional().describe("The default number of bytes yielded by streaming iterators.")
 });
 var layoutConfigSchema = zod.z.strictObject({
-  outputDirectory: zod.z.enum(["project-root", "source-root"]).optional(),
-  packagePath: nonEmptyStringSchema.optional()
+  outputDirectory: zod.z.enum(["project-root", "source-root"]).optional().describe("Whether generated source is rooted at the project or its source directory."),
+  packagePath: nonEmptyStringSchema.optional().describe("The package-relative path for generated source files.")
 });
 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()
+  enumRepresentation: zod.z.enum(["enum", "union", "literal", "forward-compatible-enum", "language-default"]).optional().describe("How schema enums are represented in generated code."),
+  additionalProperties: zod.z.enum(["allow", "forbid", "ignore", "language-default"]).optional().describe("How undeclared object properties are handled."),
+  inlineTypes: zod.z.boolean().optional().describe("Whether inline schemas remain nested under their parent types."),
+  omitUndefined: zod.z.boolean().optional().describe("Whether undefined properties are omitted during serialization.")
 });
 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(),
-  rust: rustGenerationConfigSchema.optional(),
-  cli: cliGenerationConfigSchema.optional(),
-  mcp: mcpGenerationConfigSchema.optional(),
-  swift: swiftGenerationConfigSchema.optional(),
-  terraform: terraformGenerationConfigSchema.optional()
+  typescript: typescriptGenerationConfigSchema.optional().describe("TypeScript-specific generation settings."),
+  python: pythonGenerationConfigSchema.optional().describe("Python-specific generation settings."),
+  java: javaGenerationConfigSchema.optional().describe("Java-specific generation settings."),
+  kotlin: kotlinGenerationConfigSchema.optional().describe("Kotlin-specific generation settings."),
+  go: goGenerationConfigSchema.optional().describe("Go-specific generation settings."),
+  csharp: csharpGenerationConfigSchema.optional().describe("C#-specific generation settings."),
+  php: phpGenerationConfigSchema.optional().describe("PHP-specific generation settings."),
+  ruby: rubyGenerationConfigSchema.optional().describe("Ruby-specific generation settings."),
+  rust: rustGenerationConfigSchema.optional().describe("Rust-specific generation settings."),
+  cli: cliGenerationConfigSchema.optional().describe("CLI-specific generation settings."),
+  mcp: mcpGenerationConfigSchema.optional().describe("MCP-specific generation settings."),
+  swift: swiftGenerationConfigSchema.optional().describe("Swift-specific generation settings."),
+  terraform: terraformGenerationConfigSchema.optional().describe("Terraform-specific generation settings.")
 });
 var generationConfigSchema = zod.z.strictObject({
-  includeWatermark: zod.z.boolean().default(false),
+  includeWatermark: zod.z.boolean().default(false).describe("Whether generated files include a generator watermark."),
   /** 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().default(false),
-  inferServiceNames: zod.z.boolean().default(false),
-  includeDeprecatedOperations: zod.z.boolean().default(true),
-  multipleResponses: zod.z.boolean().default(false),
+  ai: zod.z.boolean().default(false).describe("Whether the SDK includes generated AI service helpers."),
+  includeOptionalSnippetParameters: zod.z.boolean().optional().describe("Whether usage snippets include optional request parameters."),
+  buildAllModels: zod.z.boolean().default(false).describe("Whether models not referenced by operations are also generated."),
+  inferServiceNames: zod.z.boolean().default(false).describe("Whether service names are inferred from API structure."),
+  includeDeprecatedOperations: zod.z.boolean().default(true).describe("Whether deprecated API operations are generated."),
+  multipleResponses: zod.z.boolean().default(false).describe("Whether operations model multiple successful response types."),
   /** Generate the entire SDK project, including package manifests and publishable artifacts. */
-  generateFullProject: zod.z.boolean().default(false),
-  devContainer: zod.z.boolean().default(false),
-  allowMockClient: zod.z.boolean().default(false),
-  ignoreFiles: zod.z.array(nonEmptyStringSchema).optional(),
+  generateFullProject: zod.z.boolean().default(false).describe("Whether generation emits a complete publishable project."),
+  devContainer: zod.z.boolean().default(false).describe("Whether development-container configuration is generated."),
+  allowMockClient: zod.z.boolean().default(false).describe("Whether a mock API client is included in the generated SDK."),
+  ignoreFiles: zod.z.array(nonEmptyStringSchema).optional().describe("Generated paths excluded from the final output."),
   /**
    * Raw .fernignore file contents supplied to external publishers that need Fern ignore semantics.
    * This is separate from generation.ignoreFiles because raw contents preserve comments, ordering,
    * blank lines, and negation rules.
    */
-  fernignoreContents: zod.z.string().optional(),
+  fernignoreContents: zod.z.string().optional().describe("The raw .fernignore contents retained for external publishers."),
   /**
    * Optional Fern definition metadata for publisher paths that need to write definition or
    * mock-server support files. This is not required for core GitHub artifact publishing.
    */
-  fernDefinitionMetadata: fernDefinitionMetadataSchema.optional(),
-  reservedKeywords: zod.z.array(nonEmptyStringSchema).optional(),
-  hooks: hooksConfigSchema.optional(),
-  customCode: customCodeConfigSchema.optional(),
-  workflows: zod.z.array(workflowConfigSchema).optional(),
-  customQueryPaths: zod.z.array(relativePathSchema).optional(),
-  analytics: analyticsConfigSchema.optional(),
-  wireTests: wireTestsSchema.optional(),
-  unitTests: unitTestsSchema.optional(),
-  webSockets: zod.z.boolean().optional(),
-  streams: streamsSchema.optional(),
-  naming: namingConfigSchema.optional(),
-  layout: layoutConfigSchema.optional(),
-  serialization: serializationConfigSchema.optional(),
-  language: languageGenerationConfigSchema.optional()
+  fernDefinitionMetadata: fernDefinitionMetadataSchema.optional().describe("Materialized Fern definition metadata used by external publishers."),
+  reservedKeywords: zod.z.array(nonEmptyStringSchema).optional().describe("Additional identifiers treated as reserved words."),
+  hooks: hooksConfigSchema.optional().describe("Custom SDK request and response hook configuration."),
+  customCode: customCodeConfigSchema.optional().describe("Customer-authored code merge configuration."),
+  workflows: zod.z.array(workflowConfigSchema).optional().describe("Workflow definitions included in generated output."),
+  customQueryPaths: zod.z.array(relativePathSchema).optional().describe("Relative paths to custom query definitions."),
+  analytics: analyticsConfigSchema.optional().describe("Generated client telemetry configuration."),
+  wireTests: wireTestsSchema.optional().describe("Wire-level request and response test generation."),
+  unitTests: unitTestsSchema.optional().describe("SDK unit-test generation."),
+  webSockets: zod.z.boolean().optional().describe("Whether WebSocket clients are generated for supported channels."),
+  streams: streamsSchema.optional().describe("Streaming response generation behavior."),
+  naming: namingConfigSchema.optional().describe("Names and casing used by generated code."),
+  layout: layoutConfigSchema.optional().describe("Generated project and source layout."),
+  serialization: serializationConfigSchema.optional().describe("Generated model serialization behavior."),
+  language: languageGenerationConfigSchema.optional().describe("Settings specific to the selected target language.")
 });
 var publishRegistrySchema = zod.z.enum([
   "npm",
@@ -819,154 +871,160 @@ var credentialResolutionSchema = zod.z.enum([
   "resolved-by-fiddle"
 ]);
 var registryCredentialsSchema = zod.z.strictObject({
-  username: nonEmptyStringSchema.optional(),
-  password: nonEmptyStringSchema.optional(),
-  token: nonEmptyStringSchema.optional(),
-  apiKey: nonEmptyStringSchema.optional()
+  username: nonEmptyStringSchema.optional().describe("The resolved credential username."),
+  password: nonEmptyStringSchema.optional().describe("The resolved credential password."),
+  token: nonEmptyStringSchema.optional().describe("The resolved credential token."),
+  apiKey: nonEmptyStringSchema.optional().describe("The resolved credential API key.")
 });
 var commonPublishShape = {
-  url: nonEmptyStringSchema.optional(),
+  url: nonEmptyStringSchema.optional().describe("A custom package registry URL."),
   /** Reference to registry publishing credentials. */
-  credentialsRef: nonEmptyStringSchema.optional(),
+  credentialsRef: nonEmptyStringSchema.optional().describe("A reference to registry publishing credentials."),
   /** Raw registry credentials. These values can be sensitive and must be handled as secrets. */
-  credentials: registryCredentialsSchema.optional(),
+  credentials: registryCredentialsSchema.optional().describe("Resolved registry publishing credentials."),
   /**
    * Registry-specific package version override. If omitted, the external publisher/orchestrator may
    * fall back to target.sdkVersion.
    */
-  version: nonEmptyStringSchema.optional(),
-  releaseBranch: nonEmptyStringSchema.optional(),
-  tolerateRepublish: zod.z.boolean().optional(),
+  version: nonEmptyStringSchema.optional().describe("A registry-specific package version override."),
+  releaseBranch: nonEmptyStringSchema.optional().describe("The branch used by generated package release workflows."),
+  tolerateRepublish: zod.z.boolean().optional().describe("Whether publishing succeeds when this package version already exists."),
   /** Generate registry publishing workflow files when publishing through GitHub delivery. */
-  shouldGeneratePublishWorkflow: zod.z.boolean().optional()
+  shouldGeneratePublishWorkflow: zod.z.boolean().optional().describe("Whether GitHub delivery includes a registry publishing workflow.")
 };
 var trustedPublishingShape = {
   /** Use registry trusted publishing / OIDC instead of a static token secret. */
-  trustedPublishing: zod.z.boolean().optional()
+  trustedPublishing: zod.z.boolean().optional().describe("Whether registry publication uses trusted publishing or OIDC.")
 };
 var mavenCoordinateSchema = nonEmptyStringSchema.regex(
   /^[A-Za-z0-9_.-]+:[A-Za-z0-9_.-]+$/,
   "Maven coordinate must be in groupId:artifactId form"
 );
 var mavenSignatureEnvironmentSchema = zod.z.strictObject({
-  keyIdEnvironmentVariable: nonEmptyStringSchema.optional(),
-  passwordEnvironmentVariable: nonEmptyStringSchema.optional(),
-  secretKeyEnvironmentVariable: nonEmptyStringSchema.optional()
+  keyIdEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the signing key ID."),
+  passwordEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the signing key password."),
+  secretKeyEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the armored secret key.")
 });
 var mavenSignatureSchema = zod.z.strictObject({
-  keyId: nonEmptyStringSchema,
-  password: nonEmptyStringSchema,
-  secretKey: nonEmptyStringSchema
+  keyId: nonEmptyStringSchema.describe("The resolved signing key identifier."),
+  password: nonEmptyStringSchema.describe("The resolved signing key password."),
+  secretKey: nonEmptyStringSchema.describe("The resolved armored secret key.")
 });
 var publishConfigSchema = zod.z.discriminatedUnion("registry", [
   zod.z.strictObject({
-    registry: zod.z.literal("npm"),
+    registry: zod.z.literal("npm").describe("Publishes the package to an npm-compatible registry."),
     /** Environment variable name containing the npm registry token. */
-    tokenEnvironmentVariable: nonEmptyStringSchema.optional(),
+    tokenEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the npm registry token."),
     /** Write npm package metadata as private when the publisher creates/updates package.json. */
-    isPackagePrivate: zod.z.boolean().optional(),
+    isPackagePrivate: zod.z.boolean().optional().describe("Whether generated npm package metadata marks the package as private."),
     /** Also publish the TypeScript package to JSR from the npm publishing path. */
-    publishToJsr: zod.z.boolean().optional(),
+    publishToJsr: zod.z.boolean().optional().describe("Whether the npm publishing flow also publishes the package to JSR."),
     ...trustedPublishingShape,
     ...commonPublishShape
   }),
   zod.z.strictObject({
-    registry: zod.z.literal("pypi"),
-    usernameEnvironmentVariable: nonEmptyStringSchema.optional(),
-    passwordEnvironmentVariable: nonEmptyStringSchema.optional(),
+    registry: zod.z.literal("pypi").describe("Publishes the package to a PyPI-compatible registry."),
+    usernameEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the PyPI username."),
+    passwordEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the PyPI password or token."),
     ...trustedPublishingShape,
     ...commonPublishShape
   }),
   zod.z.strictObject({
-    registry: zod.z.literal("nuget"),
-    apiKeyEnvironmentVariable: nonEmptyStringSchema.optional(),
+    registry: zod.z.literal("nuget").describe("Publishes the package to a NuGet-compatible registry."),
+    apiKeyEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the NuGet API key."),
     ...trustedPublishingShape,
     ...commonPublishShape
   }),
   zod.z.strictObject({
-    registry: zod.z.literal("rubygems"),
-    apiKeyEnvironmentVariable: nonEmptyStringSchema.optional(),
+    registry: zod.z.literal("rubygems").describe("Publishes the package to a RubyGems-compatible registry."),
+    apiKeyEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the RubyGems API key."),
+    ...commonPublishShape
+  }),
+  zod.z.strictObject({
+    registry: zod.z.literal("crates").describe("Publishes the crate to a Cargo-compatible registry."),
+    tokenEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the Cargo registry token."),
+    ...commonPublishShape
+  }),
+  zod.z.strictObject({
+    registry: zod.z.literal("go").describe("Publishes the SDK as a Go module."),
     ...commonPublishShape
   }),
   zod.z.strictObject({
-    registry: zod.z.literal("crates"),
-    tokenEnvironmentVariable: nonEmptyStringSchema.optional(),
+    registry: zod.z.literal("composer").describe("Publishes the package to a Composer-compatible registry."),
     ...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"),
+    registry: zod.z.literal("maven").describe("Publishes the package to a Maven-compatible repository."),
     /** Maven coordinate in groupId:artifactId form when consumers need the combined value. */
-    coordinate: mavenCoordinateSchema.optional(),
-    usernameEnvironmentVariable: nonEmptyStringSchema.optional(),
-    passwordEnvironmentVariable: nonEmptyStringSchema.optional(),
-    mavenUrlEnvironmentVariable: nonEmptyStringSchema.optional(),
-    signatureEnvironmentVariables: mavenSignatureEnvironmentSchema.optional(),
+    coordinate: mavenCoordinateSchema.optional().describe("The Maven coordinate in groupId:artifactId form."),
+    usernameEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the Maven username."),
+    passwordEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the Maven password."),
+    mavenUrlEnvironmentVariable: nonEmptyStringSchema.optional().describe("The environment variable containing the Maven repository URL."),
+    signatureEnvironmentVariables: mavenSignatureEnvironmentSchema.optional().describe("Environment variables containing Maven signing material."),
     /** Reference to Maven signing credentials. */
-    signingCredentialsRef: nonEmptyStringSchema.optional(),
+    signingCredentialsRef: nonEmptyStringSchema.optional().describe("A reference to Maven signing credentials."),
     /** Raw Maven signing material. These values can be sensitive and must be handled as secrets. */
-    signature: mavenSignatureSchema.optional(),
+    signature: mavenSignatureSchema.optional().describe("Resolved Maven signing material."),
     ...commonPublishShape
   })
 ]);
 var reviewersSchema = zod.z.strictObject({
-  teams: zod.z.array(nonEmptyStringSchema).optional(),
-  users: zod.z.array(nonEmptyStringSchema).optional()
+  teams: zod.z.array(nonEmptyStringSchema).optional().describe("GitHub teams requested as reviewers."),
+  users: zod.z.array(nonEmptyStringSchema).optional().describe("GitHub users requested as reviewers.")
 });
 var replayControlSchema = zod.z.strictObject({
-  enabled: zod.z.boolean()
+  enabled: zod.z.boolean().describe("Whether regeneration reapplies customer-authored repository changes.")
 });
 var githubLicenseSchema = zod.z.strictObject({
   /** SPDX identifier or license key for the repository license (for example, "MIT"). */
-  type: nonEmptyStringSchema.optional(),
+  type: nonEmptyStringSchema.optional().describe("The SPDX identifier or license key for the repository license."),
   /** Path to a custom license file to be committed into the GitHub repository. */
-  customPath: nonEmptyStringSchema.optional()
+  customPath: nonEmptyStringSchema.optional().describe("The path to a custom license file committed to the repository.")
 }).refine((value) => value.type !== void 0 || value.customPath !== void 0, {
   message: "GitHub license must set type or customPath"
 });
 var githubOutputSchema = zod.z.strictObject({
-  repository: nonEmptyStringSchema,
-  host: nonEmptyStringSchema.optional(),
-  branch: nonEmptyStringSchema.optional(),
-  mode: zod.z.enum(["release", "pull-request", "push", "commit", "commit-and-release"]).optional(),
-  reviewers: reviewersSchema.optional(),
+  repository: nonEmptyStringSchema.describe("The GitHub repository that receives generated files."),
+  host: nonEmptyStringSchema.optional().describe("The GitHub host for enterprise installations."),
+  branch: nonEmptyStringSchema.optional().describe("The target branch for generated changes."),
+  mode: zod.z.enum(["release", "pull-request", "push", "commit", "commit-and-release"]).optional().describe("How generated changes are delivered to the repository."),
+  reviewers: reviewersSchema.optional().describe("Reviewers requested for generated pull requests."),
   /** Reference to GitHub credentials. */
-  credentialsRef: nonEmptyStringSchema.optional(),
+  credentialsRef: nonEmptyStringSchema.optional().describe("A reference to GitHub credentials."),
   /** Raw GitHub credentials. These values can be sensitive and must be handled as secrets. */
-  credentials: registryCredentialsSchema.optional(),
-  privateRepository: zod.z.boolean().optional(),
+  credentials: registryCredentialsSchema.optional().describe("Resolved GitHub credentials."),
+  privateRepository: zod.z.boolean().optional().describe("Whether the destination repository is private."),
   /** GitHub license block scoped to repository delivery. */
-  license: githubLicenseSchema.optional(),
+  license: githubLicenseSchema.optional().describe("License configuration for the destination repository."),
   /** GitHub replay control. If omitted, the external publisher applies its default behavior. */
-  replay: replayControlSchema.optional(),
+  replay: replayControlSchema.optional().describe("Replay behavior for the external GitHub publisher."),
   /** Run GitHub publishing verification. Defaults to false to match current Fiddle job behavior. */
-  verify: zod.z.boolean().default(false),
+  verify: zod.z.boolean().default(false).describe("Whether the GitHub publisher verifies the generated result."),
   /** Skip creating/updating a GitHub PR when no files changed. Defaults to false. */
-  skipIfNoDiff: zod.z.boolean().default(false),
+  skipIfNoDiff: zod.z.boolean().default(false).describe("Whether GitHub publication is skipped when no generated files changed."),
   /** Automatically merge the GitHub publishing PR. Defaults to false. */
-  autoMerge: zod.z.boolean().default(false)
+  autoMerge: zod.z.boolean().default(false).describe("Whether the GitHub publisher automatically merges its pull request.")
 });
 var credentialResolutionShape = {
   /** Where output credential references are resolved. */
-  credentialResolution: credentialResolutionSchema.default("refs-only")
+  credentialResolution: credentialResolutionSchema.default("refs-only").describe("Where output credential references are resolved.")
 };
 var filesOutputSchema = zod.z.strictObject({
-  delivery: zod.z.literal("files"),
-  path: nonEmptyStringSchema.optional(),
-  publish: publishConfigSchema.optional(),
+  delivery: zod.z.literal("files").describe("Writes the generated SDK to a directory."),
+  path: nonEmptyStringSchema.optional().describe("The destination directory for generated files."),
+  publish: publishConfigSchema.optional().describe("Optional package registry publication."),
   ...credentialResolutionShape
 });
 var zipOutputSchema = zod.z.strictObject({
-  delivery: zod.z.literal("zip"),
-  fileName: nonEmptyStringSchema.optional(),
-  publish: publishConfigSchema.optional(),
+  delivery: zod.z.literal("zip").describe("Packages the generated SDK as a ZIP archive."),
+  fileName: nonEmptyStringSchema.optional().describe("The generated ZIP archive file name."),
+  publish: publishConfigSchema.optional().describe("Optional package registry publication."),
   ...credentialResolutionShape
 });
 var githubDeliverySchema = zod.z.strictObject({
-  delivery: zod.z.literal("github"),
-  github: githubOutputSchema,
-  publish: publishConfigSchema.optional(),
+  delivery: zod.z.literal("github").describe("Delivers the generated SDK to GitHub."),
+  github: githubOutputSchema.describe("GitHub repository delivery settings."),
+  publish: publishConfigSchema.optional().describe("Optional package registry publication."),
   ...credentialResolutionShape
 });
 var outputConfigSchema = zod.z.discriminatedUnion(
@@ -977,29 +1035,33 @@ var outputConfigSchema = zod.z.discriminatedUnion(
   }
 );
 var replayConfigSchema = zod.z.strictObject({
-  enabled: zod.z.boolean()
+  enabled: zod.z.boolean().describe("Whether regeneration reapplies customer-authored repository changes.")
 });
 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(),
-  ignoreTags: zod.z.boolean().optional(),
-  disambiguateRequestNames: zod.z.boolean().optional(),
-  respectReadonlySchemas: zod.z.boolean().optional(),
-  discriminatedUnionV2: zod.z.boolean().optional(),
-  undiscriminatedUnionsWithLiterals: zod.z.boolean().optional(),
-  inlineAllOfSchemas: zod.z.boolean().optional(),
-  resolveSchemaCollisions: zod.z.boolean().optional(),
-  asyncApiMessageNaming: zod.z.enum(["v1", "v2"]).optional(),
-  defaultIntegerFormat: zod.z.enum(["int32", "int64", "uint32", "uint64"]).optional()
+  respectNullableSchemas: zod.z.boolean().optional().describe("Whether nullable schemas remain nullable in generated types."),
+  titleAsSchemaName: zod.z.boolean().optional().describe("Whether a schema title can determine the generated type name."),
+  coerceEnumsToLiterals: zod.z.boolean().optional().describe("Whether single-value enums are imported as literal values."),
+  idiomaticRequestNames: zod.z.boolean().optional().describe("Whether request types use concise, idiomatic generated names."),
+  wrapReferencesToNullableInOptional: zod.z.boolean().optional().describe("Whether nullable schema references are also treated as optional."),
+  coerceOptionalSchemasToNullable: zod.z.boolean().optional().describe("Whether optional properties are represented as nullable required properties."),
+  pathParameterOrder: zod.z.enum(["url-order", "spec-order"]).optional().describe("Whether path parameters follow their URL order or specification order."),
+  onlyIncludeReferencedSchemas: zod.z.boolean().optional().describe("Whether unreferenced schemas are omitted from the generated SDK."),
+  objectQueryParameters: zod.z.boolean().optional().describe("Whether object-valued query parameters are preserved as objects."),
+  typeDatesAsStrings: zod.z.boolean().optional().describe("Whether date and date-time schemas are generated as strings."),
+  groupMultiApiEnvironments: zod.z.boolean().optional().describe(
+    "Whether environments from multiple API sources are merged into shared named groups."
+  ),
+  ignoreTags: zod.z.boolean().optional().describe("Whether API tags are ignored when organizing generated resources."),
+  disambiguateRequestNames: zod.z.boolean().optional().describe("Whether colliding request type names are automatically disambiguated."),
+  respectReadonlySchemas: zod.z.boolean().optional().describe(
+    "Whether read-only properties are modeled separately for request and response types."
+  ),
+  discriminatedUnionV2: zod.z.boolean().optional().describe("Whether oneOf and anyOf schemas use the newer discriminator inference rules."),
+  undiscriminatedUnionsWithLiterals: zod.z.boolean().optional().describe("Whether literal-bearing unions remain undiscriminated during import."),
+  inlineAllOfSchemas: zod.z.boolean().optional().describe("Whether schemas composed with allOf are inlined when possible."),
+  resolveSchemaCollisions: zod.z.boolean().optional().describe("Whether colliding imported schema names are resolved automatically."),
+  asyncApiMessageNaming: zod.z.enum(["v1", "v2"]).optional().describe("The naming strategy used for messages imported from AsyncAPI."),
+  defaultIntegerFormat: zod.z.enum(["int32", "int64", "uint32", "uint64"]).optional().describe("The integer format used when a schema does not declare one.")
 });
 var sourceSpecTypeSchema = zod.z.enum([
   "openapi",
@@ -1011,18 +1073,20 @@ var sourceSpecTypeSchema = zod.z.enum([
 
 // src/sdk-config-ir/v1/source.ts
 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()
+  id: nonEmptyStringSchema.optional().describe("A unique identifier for this API source."),
+  name: nonEmptyStringSchema.optional().describe("A human-readable name for this API source."),
+  namespace: nonEmptyStringSchema.optional().describe("A namespace used to isolate this source in a multi-source SDK."),
+  specUrl: nonEmptyStringSchema.describe(
+    "The materialized URL from which the generator retrieves the API source."
+  ),
+  specType: sourceSpecTypeSchema.describe("The API description format of this source."),
+  apiImportSettings: apiImportSettingsSchema.optional().describe("Import behavior that overrides the source-level defaults for this spec."),
+  overlays: zod.z.array(nonEmptyStringSchema).optional().describe("Materialized overlays applied to this source in order."),
+  overrides: zod.z.array(nonEmptyStringSchema).optional().describe("Materialized source overrides applied in order.")
 });
 var sourceConfigSchema = zod.z.strictObject({
-  specs: zod.z.array(sourceSpecConfigSchema).min(1, "source.specs must contain at least one source spec"),
-  apiImportSettings: apiImportSettingsSchema.optional()
+  specs: zod.z.array(sourceSpecConfigSchema).min(1, "source.specs must contain at least one source spec").describe("Materialized API sources in authoritative processing order."),
+  apiImportSettings: apiImportSettingsSchema.optional().describe("Default import behavior shared by every source spec.")
 }).superRefine(({ specs }, context) => {
   const seenIds = /* @__PURE__ */ new Set();
   specs.forEach(({ id }, index) => {
@@ -1054,25 +1118,27 @@ var targetLanguageSchema = zod.z.enum([
   "terraform"
 ]);
 var targetConfigSchema = zod.z.strictObject({
-  language: targetLanguageSchema,
-  generatorVersion: exactSemverSchema.optional(),
-  sourceOrigin: zod.z.enum(["postman", "fern"]),
-  sdkName: nonEmptyStringSchema,
+  language: targetLanguageSchema.describe(
+    "The language or platform generated by this single-target request."
+  ),
+  generatorVersion: exactSemverSchema.optional().describe("The exact generator version requested for this target."),
+  sourceOrigin: zod.z.enum(["postman", "fern"]).describe("The configuration system from which this IR was normalized."),
+  sdkName: nonEmptyStringSchema.describe("The name used for the generated SDK."),
   /**
    * Stable Fern/Fiddle API identity for external publishing.
    * Producers must set this explicitly for GitHub or registry publishing; it is not inferred from
    * target.sdkName because SDK display names and Fern API names are not equivalent.
    */
-  apiName: nonEmptyStringSchema.optional(),
-  organization: nonEmptyStringSchema.optional(),
+  apiName: nonEmptyStringSchema.optional().describe("The stable API identity used for external publishing."),
+  organization: nonEmptyStringSchema.optional().describe("Source organization metadata retained for generation."),
   /**
    * Stable Fern/Fiddle organization identity for external publishing.
    * Producers must set this explicitly for GitHub or registry publishing; it is not inferred from
    * target.organization because source organization metadata is optional and may not match Fern.
    */
-  organizationName: nonEmptyStringSchema.optional(),
-  sdkVersion: nonEmptyStringSchema.default("1.0.0"),
-  apiVersion: nonEmptyStringSchema.optional()
+  organizationName: nonEmptyStringSchema.optional().describe("The stable organization identity used for external publishing."),
+  sdkVersion: nonEmptyStringSchema.default("1.0.0").describe("The version of the generated SDK."),
+  apiVersion: nonEmptyStringSchema.optional().describe("The version of the API represented by the SDK.")
 });
 
 // src/sdk-config-ir/v1/sdk-config-ir-v1.ts
@@ -1134,17 +1200,21 @@ function validatePublishingIdentity(packageConfig, registry, context) {
   }
 }
 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,
-  replay: replayConfigSchema.optional(),
-  docs: docsConfigSchema,
-  generation: generationConfigSchema,
-  compatibility: compatibilityConfigSchema.optional()
+  schemaVersion: zod.z.literal(SDK_CONFIG_IR_V1_SCHEMA_VERSION).describe("The version of the normalized SDK Config IR schema."),
+  source: sourceConfigSchema.describe("Materialized API descriptions consumed by generation."),
+  target: targetConfigSchema.describe(
+    "Identity and provenance for this single generation target."
+  ),
+  api: apiConfigSchema.describe("API behavior exposed by the generated SDK."),
+  client: clientConfigSchema.describe("Behavior of the generated API client."),
+  package: packageConfigSchema.describe("Package identity and metadata for the generated SDK."),
+  output: outputConfigSchema.describe("Artifact delivery and optional package publication."),
+  replay: replayConfigSchema.optional().describe("Generation replay behavior."),
+  docs: docsConfigSchema.describe("Generated documentation settings."),
+  generation: generationConfigSchema.describe(
+    "Shared and language-specific generation behavior."
+  ),
+  compatibility: compatibilityConfigSchema.optional().describe("Temporary provenance and diagnostics retained during legacy migration.")
 }).superRefine(({ compatibility, generation, output, package: packageConfig, target }, context) => {
   const configuredLanguages = Object.keys(generation.language ?? {});
   const requiresExternalPublishIdentity = output.delivery === "github" || output.publish !== void 0;