@postman/sdk-config 0.7.0 → 0.8.0

package/dist/sdk-config/v1/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,45 +224,45 @@ 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.")
 });
 
 // src/sdk-config/v1/api.ts
@@ -259,16 +271,16 @@ var sdkConfigV1AuthConfigSchema = authConfigSchema;
 var sdkConfigV1ApiConfigSchema = apiConfigSchema;
 var sdkConfigV1WebhookSignatureSchema = webhookSignatureSchema;
 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,
@@ -285,27 +297,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({
@@ -316,26 +330,26 @@ 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.")
 });
 
 // src/sdk-config/v1/client.ts
@@ -350,75 +364,75 @@ 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.")
 });
 var httpMethodSchema = zod.z.enum([
   "GET",
@@ -432,34 +446,34 @@ 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.")
 });
 
 // src/sdk-config/v1/docs.ts
@@ -1258,16 +1272,10 @@ function finishOutputMapping(mapping, outputMode, sourcePath, state, index) {
   for (const path of collectLeafPaths(outputMode, sourcePath)) {
     if (path[path.length - 1] === "_visit") consume(state, path);
   }
-  const legacyGenerateFullProject = isObject(outputMode) ? outputMode.generateFullProject : void 0;
-  const generationShape = typeof legacyGenerateFullProject === "boolean" ? { generation: { ...mapping.generation, generateFullProject: legacyGenerateFullProject } } : {};
-  if (typeof legacyGenerateFullProject === "boolean") {
-    consume(state, [...sourcePath, "generateFullProject"]);
-  }
   const unsupported = collectUnsupported(outputMode, sourcePath, state);
   const hasCredentials = unsupported.some((diagnostic) => isCredentialPath(diagnostic.path));
   return {
     ...mapping,
-    ...generationShape,
     unsupportedFields: [
       ...state.credentialDiagnostics ?? [],
       ...hasCredentials ? [
@@ -1338,6 +1346,9 @@ function outputDiagnostic(path, index) {
     homepageLink: {
       sdkConfigPath: ["targets", index, "package", "homepage"],
       suggestedAction: "Set target.package.homepage manually to a valid URL."
+    },
+    generateFullProject: {
+      suggestedAction: "Preserve this packaging setting on the generation request; it is not customer-authored SDK configuration."
     }
   };
   const fieldGuidance = field ? guidance[field] : void 0;
@@ -1459,59 +1470,48 @@ function deepEqual(left, right) {
   return false;
 }
 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.")
 });
 
 // src/sdk-config/v1/generation.ts
 var customerGenerationAssetSchema = zod.z.discriminatedUnion("type", [
-  zod.z.strictObject({ type: zod.z.literal("path"), location: relativePathSchema }),
-  zod.z.strictObject({ type: zod.z.literal("url"), location: nonEmptyStringSchema })
-]);
-var hookDependencySchema = zod.z.strictObject({
-  name: nonEmptyStringSchema,
-  version: nonEmptyStringSchema,
-  groupId: nonEmptyStringSchema.optional()
-});
-var hooksConfigSchema = zod.z.strictObject({
-  enabled: zod.z.boolean(),
-  source: customerGenerationAssetSchema.optional(),
-  dependencies: zod.z.array(hookDependencySchema).optional()
-});
-var customCodeConfigSchema = zod.z.strictObject({
-  enabled: zod.z.boolean(),
-  source: customerGenerationAssetSchema.optional(),
-  conflictStrategy: zod.z.enum(["mark", "ours", "theirs"]).optional(),
-  trackChanges: zod.z.boolean().optional(),
-  protectedFiles: zod.z.array(nonEmptyStringSchema).optional()
-});
-var workflowConfigSchema = zod.z.strictObject({
-  path: relativePathSchema,
-  outputName: nonEmptyStringSchema.optional()
-});
-var analyticsHeaderSchema = zod.z.union([
-  zod.z.strictObject({ name: nonEmptyStringSchema, value: zod.z.string() }),
   zod.z.strictObject({
-    name: nonEmptyStringSchema,
-    valueRef: nonEmptyStringSchema
+    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.")
   })
 ]);
+var customCodeConfigSchema = zod.z.strictObject({
+  enabled: zod.z.boolean().describe("Whether customer-authored code is merged into generated output."),
+  source: customerGenerationAssetSchema.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."),
+  protectedFiles: zod.z.array(nonEmptyStringSchema).optional().describe("Generated file paths that custom-code merging must not overwrite.")
+});
+var analyticsHeaderSchema = zod.z.strictObject({
+  name: nonEmptyStringSchema.describe("The exported telemetry header name."),
+  value: zod.z.string().describe("The literal 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({
@@ -1522,73 +1522,63 @@ 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."),
+  exclusions: zod.z.array(nonEmptyStringSchema).optional().describe("Operations excluded from unit tests.")
 });
 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 generationConfigOverrideShape = {
-  includeWatermark: zod.z.boolean().optional(),
-  ai: zod.z.boolean().optional(),
-  includeOptionalSnippetParameters: zod.z.boolean().optional(),
-  buildAllModels: zod.z.boolean().optional(),
-  inferServiceNames: zod.z.boolean().optional(),
-  includeDeprecatedOperations: zod.z.boolean().optional(),
-  multipleResponses: zod.z.boolean().optional(),
-  /** Generate the entire SDK project, including package manifests and publishable artifacts. */
-  generateFullProject: zod.z.boolean().optional(),
-  devContainer: zod.z.boolean().optional(),
-  allowMockClient: zod.z.boolean().optional(),
-  ignoreFiles: zod.z.array(nonEmptyStringSchema).optional(),
-  reservedKeywords: zod.z.array(nonEmptyStringSchema).optional(),
-  hooks: hooksConfigSchema.optional(),
-  customCode: customCodeConfigSchema.optional(),
-  workflows: zod.z.array(workflowConfigSchema).optional(),
-  customQueryPaths: zod.z.array(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()
+  includeOptionalSnippetParameters: zod.z.boolean().optional().describe("Whether usage snippets include optional request parameters."),
+  buildAllModels: zod.z.boolean().optional().describe("Whether models not referenced by operations are also generated."),
+  inferServiceNames: zod.z.boolean().optional().describe("Whether service names are inferred from API structure."),
+  includeDeprecatedOperations: zod.z.boolean().optional().describe("Whether deprecated API operations are generated."),
+  multipleResponses: zod.z.boolean().optional().describe("Whether operations model multiple successful response types."),
+  devContainer: zod.z.boolean().optional().describe("Whether development-container configuration is generated."),
+  allowMockClient: zod.z.boolean().optional().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."),
+  reservedKeywords: zod.z.array(nonEmptyStringSchema).optional().describe("Additional identifiers treated as reserved words."),
+  customCode: customCodeConfigSchema.optional().describe("Customer-authored code merge configuration."),
+  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.")
 };
 var sdkConfigV1GenerationConfigOverrideSchema = zod.z.strictObject(
   generationConfigOverrideShape
 );
 var sdkConfigV1GenerationConfigSchema = zod.z.strictObject({
   ...generationConfigOverrideShape,
-  includeWatermark: zod.z.boolean().default(false),
-  ai: zod.z.boolean().default(false),
-  buildAllModels: zod.z.boolean().default(false),
-  inferServiceNames: zod.z.boolean().default(false),
-  includeDeprecatedOperations: zod.z.boolean().default(true),
-  multipleResponses: zod.z.boolean().default(false),
-  generateFullProject: zod.z.boolean().default(false),
-  devContainer: zod.z.boolean().default(false),
-  allowMockClient: zod.z.boolean().default(false)
+  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."),
+  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.")
 });
 var commonGenerationKeys = new Set(Object.keys(generationConfigOverrideShape));
 function splitSdkConfigV1TargetGeneration(generation) {
@@ -1610,78 +1600,97 @@ var sdkConfigV1PublishRegistrySchema = zod.z.enum([
   "composer"
 ]);
 var mavenSignatureSchema = zod.z.strictObject({
-  keyId: nonEmptyStringSchema,
-  password: nonEmptyStringSchema,
-  secretKey: nonEmptyStringSchema
+  keyId: nonEmptyStringSchema.describe(
+    "The signing key identifier, or an environment expression that resolves to it."
+  ),
+  password: nonEmptyStringSchema.describe(
+    "The signing key password, or an environment expression that resolves to it."
+  ),
+  secretKey: nonEmptyStringSchema.describe(
+    "The armored secret key, or an environment expression that resolves to it."
+  )
 });
 var commonPublishShape = {
-  url: nonEmptyStringSchema.optional(),
-  releaseBranch: nonEmptyStringSchema.optional(),
-  tolerateRepublish: zod.z.boolean().optional()
+  url: nonEmptyStringSchema.optional().describe("A custom package registry URL."),
+  releaseBranch: nonEmptyStringSchema.optional().describe("The branch used by generated package release workflows."),
+  tolerateRepublish: zod.z.boolean().optional().describe("Whether an already-published package version is treated as non-fatal.")
 };
 var sdkConfigV1PublishConfigSchema = zod.z.discriminatedUnion("registry", [
   zod.z.strictObject({
-    registry: zod.z.literal("npm"),
-    token: nonEmptyStringSchema.optional(),
+    registry: zod.z.literal("npm").describe("Publishes the package to an npm-compatible registry."),
+    token: nonEmptyStringSchema.optional().describe("The npm registry token, or an environment expression that resolves to it."),
+    ...commonPublishShape
+  }),
+  zod.z.strictObject({
+    registry: zod.z.literal("pypi").describe("Publishes the package to a PyPI-compatible registry."),
+    username: nonEmptyStringSchema.optional().describe("The PyPI username, or an environment expression that resolves to it."),
+    password: nonEmptyStringSchema.optional().describe("The PyPI password or token, or an environment expression that resolves to it."),
+    ...commonPublishShape
+  }),
+  zod.z.strictObject({
+    registry: zod.z.literal("maven").describe("Publishes the package to a Maven-compatible repository."),
+    username: nonEmptyStringSchema.optional().describe("The Maven username, or an environment expression that resolves to it."),
+    password: nonEmptyStringSchema.optional().describe("The Maven password, or an environment expression that resolves to it."),
+    signature: mavenSignatureSchema.optional().describe("Credentials used to sign Maven artifacts."),
     ...commonPublishShape
   }),
   zod.z.strictObject({
-    registry: zod.z.literal("pypi"),
-    username: nonEmptyStringSchema.optional(),
-    password: nonEmptyStringSchema.optional(),
+    registry: zod.z.literal("nuget").describe("Publishes the package to a NuGet-compatible registry."),
     ...commonPublishShape
   }),
   zod.z.strictObject({
-    registry: zod.z.literal("maven"),
-    username: nonEmptyStringSchema.optional(),
-    password: nonEmptyStringSchema.optional(),
-    signature: mavenSignatureSchema.optional(),
+    registry: zod.z.literal("rubygems").describe("Publishes the package to a RubyGems-compatible registry."),
     ...commonPublishShape
   }),
-  zod.z.strictObject({ registry: zod.z.literal("nuget"), ...commonPublishShape }),
-  zod.z.strictObject({ registry: zod.z.literal("rubygems"), ...commonPublishShape }),
   zod.z.strictObject({
-    registry: zod.z.literal("crates"),
-    token: nonEmptyStringSchema.optional(),
+    registry: zod.z.literal("crates").describe("Publishes the crate to a Cargo-compatible registry."),
+    token: nonEmptyStringSchema.optional().describe("The Cargo registry token, or an environment expression that resolves to it."),
     ...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("go").describe("Publishes the SDK as a Go module."),
+    ...commonPublishShape
+  }),
+  zod.z.strictObject({
+    registry: zod.z.literal("composer").describe("Publishes the package to a Composer-compatible registry."),
+    ...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 githubCredentialsSchema = zod.z.strictObject({
-  username: nonEmptyStringSchema.optional(),
-  password: nonEmptyStringSchema.optional(),
-  token: nonEmptyStringSchema.optional(),
-  apiKey: nonEmptyStringSchema.optional()
+  username: nonEmptyStringSchema.optional().describe("The username used to authenticate with the GitHub host."),
+  password: nonEmptyStringSchema.optional().describe("The password used to authenticate with the GitHub host."),
+  token: nonEmptyStringSchema.optional().describe("A token used to authenticate with the GitHub host."),
+  apiKey: nonEmptyStringSchema.optional().describe("An API key used to authenticate with the GitHub host.")
 });
 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(),
-  /** Raw GitHub credentials. These values can be sensitive and must be handled as secrets. */
-  credentials: githubCredentialsSchema.optional(),
-  privateRepository: zod.z.boolean().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."),
+  credentials: githubCredentialsSchema.optional().describe("Credentials used to authenticate GitHub delivery."),
+  privateRepository: zod.z.boolean().optional().describe("Whether the destination repository is private.")
 });
 var filesOutputSchema = zod.z.strictObject({
-  delivery: zod.z.literal("files"),
-  path: nonEmptyStringSchema.optional(),
-  publish: sdkConfigV1PublishConfigSchema.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: sdkConfigV1PublishConfigSchema.optional().describe("Optional package registry publication.")
 });
 var zipOutputSchema = zod.z.strictObject({
-  delivery: zod.z.literal("zip"),
-  fileName: nonEmptyStringSchema.optional(),
-  publish: sdkConfigV1PublishConfigSchema.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: sdkConfigV1PublishConfigSchema.optional().describe("Optional package registry publication.")
 });
 var githubDeliverySchema = zod.z.strictObject({
-  delivery: zod.z.literal("github"),
-  github: githubOutputSchema,
-  publish: sdkConfigV1PublishConfigSchema.optional()
+  delivery: zod.z.literal("github").describe("Delivers the generated SDK to GitHub."),
+  github: githubOutputSchema.describe("GitHub repository delivery settings."),
+  publish: sdkConfigV1PublishConfigSchema.optional().describe("Optional package registry publication.")
 });
 var sdkConfigV1OutputConfigSchema = zod.z.discriminatedUnion(
   "delivery",
@@ -1693,29 +1702,33 @@ var sdkConfigV1OutputConfigSchema = zod.z.discriminatedUnion(
 var sdkConfigV1DependencySchema = dependencySchema;
 var sdkConfigV1PackageConfigSchema = packageConfigSchema;
 var sdkConfigV1ReplayConfigSchema = 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",
@@ -1727,27 +1740,30 @@ var sourceSpecTypeSchema = zod.z.enum([
 
 // src/sdk-config/v1/source.ts
 var sourceSpecShape = {
-  id: nonEmptyStringSchema,
-  type: sourceSpecTypeSchema,
-  name: nonEmptyStringSchema.optional(),
-  namespace: nonEmptyStringSchema.optional(),
-  apiImportSettings: apiImportSettingsSchema.optional(),
-  overlays: zod.z.array(relativePathSchema).optional(),
-  overrides: zod.z.array(relativePathSchema).optional()
+  id: nonEmptyStringSchema.describe("A unique identifier for this API source."),
+  type: sourceSpecTypeSchema.describe("The API description format of this 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."),
+  apiImportSettings: apiImportSettingsSchema.optional().describe("Import behavior that overrides the source-level defaults for this spec."),
+  overlays: zod.z.array(relativePathSchema).optional().describe("Relative paths to overlays applied to this source in order."),
+  overrides: zod.z.array(relativePathSchema).optional().describe("Relative paths to source override files applied in order.")
 };
 var sdkConfigV1SourceSpecSchema = zod.z.union(
   [
-    zod.z.strictObject({ ...sourceSpecShape, path: relativePathSchema }),
     zod.z.strictObject({
       ...sourceSpecShape,
-      url: zod.z.url({ protocol: /^https?$/ })
+      path: relativePathSchema.describe("The relative path to the API source file.")
+    }),
+    zod.z.strictObject({
+      ...sourceSpecShape,
+      url: zod.z.url({ protocol: /^https?$/ }).describe("The HTTP or HTTPS URL of the API source file.")
     })
   ],
   { error: "source spec must contain exactly one locator: path or HTTP(S) url" }
 );
 var sdkConfigV1SourceConfigSchema = zod.z.strictObject({
-  specs: zod.z.array(sdkConfigV1SourceSpecSchema).min(1, "source.specs must contain at least one source spec"),
-  apiImportSettings: apiImportSettingsSchema.optional()
+  specs: zod.z.array(sdkConfigV1SourceSpecSchema).min(1, "source.specs must contain at least one source spec").describe("API source files 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) => {
@@ -1762,79 +1778,80 @@ var sdkConfigV1SourceConfigSchema = zod.z.strictObject({
   });
 });
 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(),
-  /** e.g. `1.22.22` — from the customer's own `config.packageJson.packageManager` (`yarn@1.22.22`). */
-  packageManagerVersion: nonEmptyStringSchema.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(),
-  consolidateTypeFiles: zod.z.boolean().optional(),
-  allowCustomFetcher: zod.z.boolean().optional(),
-  useBrandedStringAliases: zod.z.boolean().optional(),
-  useLegacyExports: zod.z.boolean().optional(),
-  useBigInt: zod.z.boolean().optional(),
-  serdeLayer: zod.z.boolean().optional(),
+  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(),
-  scripts: zod.z.array(packageScriptSchema).optional()
+  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
@@ -1849,172 +1866,183 @@ 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 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/v1/target.ts
 var targetOverrideShape = {
-  generatorVersion: exactSemverSchema.optional(),
-  sdkName: nonEmptyStringSchema.optional(),
-  sdkVersion: nonEmptyStringSchema.optional(),
-  client: sdkConfigV1ClientConfigOverrideSchema.optional(),
-  docs: sdkConfigV1DocsConfigSchema.optional(),
-  package: sdkConfigV1PackageConfigSchema.optional(),
-  output: sdkConfigV1OutputConfigSchema.optional()
+  generatorVersion: exactSemverSchema.optional().describe("The exact generator version used for this target."),
+  sdkName: nonEmptyStringSchema.optional().describe("An SDK name that overrides the root value for this target."),
+  sdkVersion: nonEmptyStringSchema.optional().describe("An SDK version that overrides the root value for this target."),
+  client: sdkConfigV1ClientConfigOverrideSchema.optional().describe("Client settings that override root client configuration for this target."),
+  docs: sdkConfigV1DocsConfigSchema.optional().describe("Documentation settings that override root documentation for this target."),
+  package: sdkConfigV1PackageConfigSchema.optional().describe("Package metadata that overrides root package configuration for this target."),
+  output: sdkConfigV1OutputConfigSchema.optional().describe("Output configuration that replaces the root output for this target.")
 };
 var sdkConfigV1TargetSchema = zod.z.discriminatedUnion("language", [
   zod.z.strictObject({
-    language: zod.z.literal("typescript"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(typescriptGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("typescript").describe("Generates a TypeScript SDK."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(typescriptGenerationConfigSchema.shape).optional().describe("Common and TypeScript-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("python"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(pythonGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("python").describe("Generates a Python SDK."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(pythonGenerationConfigSchema.shape).optional().describe("Common and Python-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("java"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(javaGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("java").describe("Generates a Java SDK."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(javaGenerationConfigSchema.shape).optional().describe("Common and Java-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("kotlin"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(kotlinGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("kotlin").describe("Generates a Kotlin SDK."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(kotlinGenerationConfigSchema.shape).optional().describe("Common and Kotlin-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("go"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(goGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("go").describe("Generates a Go SDK."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(goGenerationConfigSchema.shape).optional().describe("Common and Go-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("csharp"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(csharpGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("csharp").describe("Generates a C# SDK."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(csharpGenerationConfigSchema.shape).optional().describe("Common and C#-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("php"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(phpGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("php").describe("Generates a PHP SDK."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(phpGenerationConfigSchema.shape).optional().describe("Common and PHP-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("ruby"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(rubyGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("ruby").describe("Generates a Ruby SDK."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(rubyGenerationConfigSchema.shape).optional().describe("Common and Ruby-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("rust"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(rustGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("rust").describe("Generates a Rust SDK."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(rustGenerationConfigSchema.shape).optional().describe("Common and Rust-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("swift"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(swiftGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("swift").describe("Generates a Swift SDK."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(swiftGenerationConfigSchema.shape).optional().describe("Common and Swift-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("cli"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(cliGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("cli").describe("Generates a command-line interface."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(cliGenerationConfigSchema.shape).optional().describe("Common and CLI-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("mcp"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(mcpGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("mcp").describe("Generates an MCP server."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(mcpGenerationConfigSchema.shape).optional().describe("Common and MCP-specific generation settings for this target."),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
-    language: zod.z.literal("terraform"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(terraformGenerationConfigSchema.shape).optional(),
+    language: zod.z.literal("terraform").describe("Generates a Terraform provider."),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(terraformGenerationConfigSchema.shape).optional().describe("Common and Terraform-specific generation settings for this target."),
     ...targetOverrideShape
   })
 ]);
@@ -2107,19 +2135,21 @@ function validateTargetPublishing(target, targetIndex, globalPackage, globalOutp
   );
 }
 var sdkConfigV1Schema = zod.z.strictObject({
-  schemaVersion: zod.z.literal(SDK_CONFIG_V1_SCHEMA_VERSION),
-  sdkName: nonEmptyStringSchema,
-  sdkVersion: nonEmptyStringSchema.default("1.0.0"),
-  apiVersion: nonEmptyStringSchema.optional(),
-  source: sdkConfigV1SourceConfigSchema,
-  api: sdkConfigV1ApiConfigSchema.prefault({}),
-  client: sdkConfigV1ClientConfigSchema.prefault({}),
-  package: sdkConfigV1PackageConfigSchema.prefault({}),
-  output: sdkConfigV1OutputConfigSchema.optional(),
-  replay: sdkConfigV1ReplayConfigSchema.optional(),
-  docs: sdkConfigV1DocsConfigSchema.prefault({}),
-  generation: sdkConfigV1GenerationConfigSchema.prefault({}),
-  targets: zod.z.array(sdkConfigV1TargetSchema).min(1)
+  schemaVersion: zod.z.literal(SDK_CONFIG_V1_SCHEMA_VERSION).describe("The version of the customer-facing SDK Config schema."),
+  sdkName: nonEmptyStringSchema.describe("The default name used for generated SDKs."),
+  sdkVersion: nonEmptyStringSchema.default("1.0.0").describe("The default version assigned to generated SDKs."),
+  apiVersion: nonEmptyStringSchema.optional().describe("The version of the API represented by the generated SDKs."),
+  source: sdkConfigV1SourceConfigSchema.describe(
+    "The API descriptions used to generate the SDKs."
+  ),
+  api: sdkConfigV1ApiConfigSchema.prefault({}).describe("Shared API behavior for every target."),
+  client: sdkConfigV1ClientConfigSchema.prefault({}).describe("Shared generated-client behavior for every target."),
+  package: sdkConfigV1PackageConfigSchema.prefault({}).describe("Package metadata inherited by every target."),
+  output: sdkConfigV1OutputConfigSchema.optional().describe("The default output delivery and publication configuration."),
+  replay: sdkConfigV1ReplayConfigSchema.optional().describe("Generation replay behavior shared by every target."),
+  docs: sdkConfigV1DocsConfigSchema.prefault({}).describe("Documentation settings inherited by every target."),
+  generation: sdkConfigV1GenerationConfigSchema.prefault({}).describe("Generation settings inherited by every target."),
+  targets: zod.z.array(sdkConfigV1TargetSchema).min(1).describe("Language targets to generate; each language may appear once.")
 }).superRefine(({ output, package: globalPackage, targets }, context) => {
   const configuredLanguages = /* @__PURE__ */ new Set();
   targets.forEach((target, targetIndex) => {
@@ -2399,9 +2429,6 @@ function mapInvocation(generator, language, activeLanguages, index) {
   if (generator.keywords?.length) {
     generation.reservedKeywords = [...generator.keywords];
   }
-  if (generator.generateFullProject !== void 0) {
-    generation.generateFullProject = generator.generateFullProject;
-  }
   const settings = isObject(generator.settings) ? generator.settings : void 0;
   if (settings) {
     const inlinePathParameters = takeBoolean(settings, ["inlinePathParameters"], state, [
@@ -2432,6 +2459,7 @@ function unsupportedResolvedFields(generator, index) {
       "disableExamples",
       generator.disableExamples === false ? void 0 : generator.disableExamples
     ],
+    ["generateFullProject", generator.generateFullProject],
     ["apiOverride", generator.apiOverride]
   ];
   return values.flatMap(([field, value]) => {
@@ -2461,6 +2489,11 @@ function resolvedFieldGuidance(field) {
       suggestedAction: "Preserve this orchestration setting outside SDK Config; public v1 has no idempotency-generation field."
     };
   }
+  if (field === "generateFullProject") {
+    return {
+      suggestedAction: "Preserve this packaging setting on the generation request; it is not customer-authored SDK configuration."
+    };
+  }
   return {
     suggestedAction: "Review this Fern setting and preserve it outside SDK Config, or set an equivalent SDK Config field manually if one is introduced."
   };
@@ -2551,8 +2584,6 @@ function mapCommonConfig(language, config, state, client, generation, packageCon
     const streams = mapTypescriptStreams(config, state, basePath);
     if (streams) generation.streams = streams;
   }
-  const generateFullProject = takeBoolean(config, ["generateFullProject"], state, basePath);
-  if (generateFullProject !== void 0) generation.generateFullProject = generateFullProject;
   const inlineTypes = takeBoolean(config, ["enableInlineTypes"], state, basePath);
   const omitUndefined = takeBoolean(config, ["omitUndefined"], state, basePath);
   const forwardEnums = takeBoolean(config, ["enableForwardCompatibleEnums"], state, basePath);