@postman/sdk-config 0.6.0 → 0.8.0

package/dist/sdk-config/index.js

@@ -32,140 +32,152 @@ var hashAlgorithmSchema = z.enum(["sha1", "sha256", "sha384", "sha512"]);
 var encodingSchema = z.enum(["base64", "hex"]);
 var payloadComponentSchema = z.enum(["body", "timestamp", "notification-url", "message-id"]);
 var payloadFormatSchema = z.strictObject({
-  components: z.array(payloadComponentSchema).min(1),
-  delimiter: z.string().optional(),
+  components: z.array(payloadComponentSchema).min(1).describe("Payload components concatenated in declaration order before signing."),
+  delimiter: 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: z.literal("alphabetical").optional()
+  bodySort: z.literal("alphabetical").optional().describe("Canonicalizes form body keys and values alphabetically before signing.")
 });
 var timestampSchema = z.strictObject({
-  header: nonEmptyStringSchema,
-  format: z.enum(["unix-seconds", "unix-millis", "iso8601"]).optional(),
+  header: nonEmptyStringSchema.describe("The request header containing the signing timestamp."),
+  format: z.enum(["unix-seconds", "unix-millis", "iso8601"]).optional().describe("The timestamp format used in the signature payload."),
   /** Replay window in seconds. */
-  tolerance: z.number().positive().optional()
+  tolerance: z.number().positive().optional().describe("The maximum accepted timestamp age, in seconds.")
 });
 var bodyHashLocationSchema = z.discriminatedUnion("type", [
   z.strictObject({
-    type: z.literal("query-parameter"),
-    name: nonEmptyStringSchema
+    type: 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 = 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 = z.strictObject({
   /** Try the URL with and without an explicit default port. */
-  portVariants: z.boolean().optional(),
+  portVariants: 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: z.boolean().optional()
+  legacyQueryEncoding: 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 = z.discriminatedUnion("type", [
   z.strictObject({
-    type: z.literal("hmac"),
+    type: 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: z.string().optional(),
-    payloadFormat: payloadFormatSchema.optional(),
-    timestamp: timestampSchema.optional(),
-    bodyHashBinding: bodyHashBindingSchema.optional(),
-    urlNormalization: urlNormalizationSchema.optional()
+    signaturePrefix: 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 = z.strictObject({
-  name: nonEmptyStringSchema.optional(),
-  environmentVariable: nonEmptyStringSchema.optional(),
-  description: z.string().optional(),
-  omit: 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: z.string().optional().describe(
+    "A description of the authentication parameter included in generated SDK documentation."
+  ),
+  omit: z.boolean().optional().describe("Whether the parameter is omitted from the SDK surface.")
 });
 var apiKeyAuthSchema = z.strictObject({
-  id: nonEmptyStringSchema,
-  type: z.literal("api-key"),
-  location: z.enum(["header", "query", "cookie"]),
-  name: nonEmptyStringSchema,
-  prefix: nonEmptyStringSchema.optional(),
-  environmentVariable: nonEmptyStringSchema.optional(),
-  description: z.string().optional()
+  id: nonEmptyStringSchema.describe("A unique identifier for this authentication scheme."),
+  type: z.literal("api-key").describe("Identifies an API key authentication scheme."),
+  location: 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: z.string().optional().describe(
+    "A description of the authentication scheme included in generated SDK documentation."
+  )
 });
 var bearerAuthSchema = z.strictObject({
-  id: nonEmptyStringSchema,
-  type: z.literal("bearer"),
-  header: nonEmptyStringSchema.optional(),
-  prefix: nonEmptyStringSchema.optional(),
-  environmentVariable: nonEmptyStringSchema.optional(),
-  description: z.string().optional()
+  id: nonEmptyStringSchema.describe("A unique identifier for this authentication scheme."),
+  type: 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: z.string().optional().describe(
+    "A description of the authentication scheme included in generated SDK documentation."
+  )
 });
 var basicAuthSchema = z.strictObject({
-  id: nonEmptyStringSchema,
-  type: z.literal("basic"),
-  username: authVariableSchema.optional(),
-  password: authVariableSchema.optional(),
-  description: z.string().optional()
+  id: nonEmptyStringSchema.describe("A unique identifier for this authentication scheme."),
+  type: 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: z.string().optional().describe(
+    "A description of the authentication scheme included in generated SDK documentation."
+  )
 });
 var oauthScopeSchema = z.strictObject({
-  name: nonEmptyStringSchema,
-  description: z.string().optional()
+  name: nonEmptyStringSchema.describe("The OAuth scope value requested from the provider."),
+  description: z.string().optional().describe("A description of the OAuth scope included in generated SDK documentation.")
 });
 var oauthFlowSchema = z.discriminatedUnion("type", [
   z.strictObject({
-    type: z.literal("authorization-code"),
-    authorizationUrl: nonEmptyStringSchema,
-    tokenUrl: nonEmptyStringSchema,
-    refreshUrl: nonEmptyStringSchema.optional(),
-    scopes: z.array(oauthScopeSchema).optional()
+    type: 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: z.array(oauthScopeSchema).optional().describe("The scopes supported by this flow.")
   }),
   z.strictObject({
-    type: z.literal("client-credentials"),
-    tokenUrl: nonEmptyStringSchema,
-    refreshUrl: nonEmptyStringSchema.optional(),
-    scopes: z.array(oauthScopeSchema).optional()
+    type: 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: z.array(oauthScopeSchema).optional().describe("The scopes supported by this flow.")
   }),
   z.strictObject({
-    type: z.literal("implicit"),
-    authorizationUrl: nonEmptyStringSchema,
-    refreshUrl: nonEmptyStringSchema.optional(),
-    scopes: z.array(oauthScopeSchema).optional()
+    type: 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: z.array(oauthScopeSchema).optional().describe("The scopes supported by this flow.")
   }),
   z.strictObject({
-    type: z.literal("password"),
-    tokenUrl: nonEmptyStringSchema,
-    refreshUrl: nonEmptyStringSchema.optional(),
-    scopes: z.array(oauthScopeSchema).optional()
+    type: 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: z.array(oauthScopeSchema).optional().describe("The scopes supported by this flow.")
   })
 ]);
 var oauth2AuthSchema = z.strictObject({
-  id: nonEmptyStringSchema,
-  type: z.literal("oauth2"),
-  flows: z.array(oauthFlowSchema).min(1),
-  clientId: authVariableSchema.optional(),
-  clientSecret: authVariableSchema.optional(),
-  tokenHeader: nonEmptyStringSchema.optional(),
-  tokenPrefix: nonEmptyStringSchema.optional(),
-  refreshBufferSeconds: z.number().nonnegative().optional(),
-  description: z.string().optional()
+  id: nonEmptyStringSchema.describe("A unique identifier for this authentication scheme."),
+  type: z.literal("oauth2").describe("Identifies an OAuth 2.0 authentication scheme."),
+  flows: 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: z.number().nonnegative().optional().describe("How early, in seconds, the client refreshes a token before it expires."),
+  description: z.string().optional().describe(
+    "A description of the authentication scheme included in generated SDK documentation."
+  )
 });
 var customAuthParameterSchema = z.strictObject({
-  location: z.enum(["header", "query", "cookie"]),
-  name: nonEmptyStringSchema,
-  prefix: nonEmptyStringSchema.optional(),
-  environmentVariable: nonEmptyStringSchema.optional()
+  location: 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 = z.strictObject({
-  id: nonEmptyStringSchema,
-  type: z.literal("custom"),
-  parameters: z.array(customAuthParameterSchema).min(1),
-  description: z.string().optional()
+  id: nonEmptyStringSchema.describe("A unique identifier for this authentication scheme."),
+  type: z.literal("custom").describe("Identifies a custom authentication scheme."),
+  parameters: z.array(customAuthParameterSchema).min(1).describe("The request parameters that implement the custom scheme."),
+  description: z.string().optional().describe(
+    "A description of the authentication scheme included in generated SDK documentation."
+  )
 });
 var authSchemeSchema = z.discriminatedUnion("type", [
   apiKeyAuthSchema,
@@ -175,12 +187,12 @@ var authSchemeSchema = z.discriminatedUnion("type", [
   customAuthSchema
 ]);
 var authRequirementSchema = z.strictObject({
-  schemes: z.array(nonEmptyStringSchema).min(1)
+  schemes: z.array(nonEmptyStringSchema).min(1).describe("Scheme identifiers that must be satisfied together.")
 });
 var authConfigSchema = z.strictObject({
-  schemes: z.array(authSchemeSchema).min(1),
-  requirements: z.array(authRequirementSchema).optional(),
-  endpointSecurity: z.boolean().optional()
+  schemes: z.array(authSchemeSchema).min(1).describe("Authentication schemes offered by the API."),
+  requirements: z.array(authRequirementSchema).optional().describe("Valid combinations of authentication schemes."),
+  endpointSecurity: 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) => {
@@ -206,45 +218,45 @@ var authConfigSchema = z.strictObject({
   });
 });
 var environmentUrlSchema = 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 = z.strictObject({
-  name: nonEmptyStringSchema,
-  urls: z.array(environmentUrlSchema).min(1),
-  description: z.string().optional()
+  name: nonEmptyStringSchema.describe("The environment name exposed by the SDK."),
+  urls: z.array(environmentUrlSchema).min(1).describe("The base URLs available in this environment."),
+  description: z.string().optional().describe("A description of the environment included in generated SDK documentation.")
 });
 var headerSchema = z.strictObject({
-  name: nonEmptyStringSchema,
-  value: z.string().optional(),
-  description: z.string().optional(),
-  environmentVariable: nonEmptyStringSchema.optional()
+  name: nonEmptyStringSchema.describe("The HTTP header name."),
+  value: z.string().optional().describe("A fixed value for the generated header."),
+  description: 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 = z.strictObject({
-  name: nonEmptyStringSchema,
-  description: z.string().optional(),
-  defaultValue: z.string().optional()
+  name: nonEmptyStringSchema.describe("The environment variable name exposed by the SDK."),
+  description: z.string().optional().describe("A description of the environment variable included in generated SDK documentation."),
+  defaultValue: z.string().optional().describe("The default value used when the variable is unset.")
 });
 var apiConfigSchema = z.strictObject({
-  baseUrl: z.string().default(""),
-  environments: z.array(environmentSchema).default([]),
-  environmentVariables: z.array(environmentVariableSchema).default([]),
-  defaultEnvironment: nonEmptyStringSchema.optional(),
-  auth: authConfigSchema.optional(),
-  headers: z.array(headerSchema).optional(),
+  baseUrl: z.string().default("").describe("The default base URL used by the generated client."),
+  environments: z.array(environmentSchema).default([]).describe("Named API environments and their base URLs."),
+  environmentVariables: 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: 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: z.array(nonEmptyStringSchema).optional(),
+  audiences: 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
@@ -253,16 +265,16 @@ var sdkConfigV1AuthConfigSchema = authConfigSchema;
 var sdkConfigV1ApiConfigSchema = apiConfigSchema;
 var sdkConfigV1WebhookSignatureSchema = webhookSignatureSchema;
 var retryOverrideShape = {
-  enabled: z.boolean().optional(),
-  maxAttempts: z.number().int().min(1).optional(),
-  retryDelayMs: z.number().nonnegative().optional(),
-  maxDelayMs: z.number().nonnegative().optional(),
-  jitterMs: z.number().nonnegative().optional(),
-  backoffFactor: z.number().positive().optional(),
-  statusCodes: z.array(z.number().int().min(100).max(599)).optional(),
-  methods: z.array(nonEmptyStringSchema).optional(),
-  statusCodeProfile: z.enum(["legacy", "recommended"]).optional(),
-  maxRetryAfterDelayMs: z.number().nonnegative().optional()
+  enabled: z.boolean().optional().describe("Whether the generated client retries failed requests."),
+  maxAttempts: z.number().int().min(1).optional().describe("The maximum total request attempts, including the initial attempt."),
+  retryDelayMs: z.number().nonnegative().optional().describe("The initial delay between retry attempts, in milliseconds."),
+  maxDelayMs: z.number().nonnegative().optional().describe("The maximum backoff delay between attempts, in milliseconds."),
+  jitterMs: z.number().nonnegative().optional().describe("The maximum random jitter added to retry delays, in milliseconds."),
+  backoffFactor: z.number().positive().optional().describe("The multiplier applied to the delay after each failed attempt."),
+  statusCodes: z.array(z.number().int().min(100).max(599)).optional().describe("HTTP status codes that are eligible for retries."),
+  methods: z.array(nonEmptyStringSchema).optional().describe("HTTP methods that are eligible for retries."),
+  statusCodeProfile: z.enum(["legacy", "recommended"]).optional().describe("The built-in retryable status-code policy."),
+  maxRetryAfterDelayMs: z.number().nonnegative().optional().describe("The longest Retry-After delay the client will honor, in milliseconds.")
 };
 function validateRetryDelays({
   maxDelayMs,
@@ -279,27 +291,29 @@ function validateRetryDelays({
 var clientRetryOverrideSchema = z.strictObject(retryOverrideShape).superRefine(validateRetryDelays);
 var retryConfigSchema = z.strictObject({
   ...retryOverrideShape,
-  enabled: z.boolean().default(true),
-  maxAttempts: z.number().int().min(1).default(3),
-  retryDelayMs: z.number().nonnegative().default(150),
-  maxDelayMs: z.number().nonnegative().default(5e3),
-  jitterMs: z.number().nonnegative().default(50),
-  backoffFactor: z.number().positive().default(2),
-  methods: z.array(nonEmptyStringSchema).default(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]),
-  maxRetryAfterDelayMs: z.number().nonnegative().default(6e4)
+  enabled: z.boolean().default(true).describe("Whether the generated client retries failed requests."),
+  maxAttempts: z.number().int().min(1).default(3).describe("The maximum total request attempts, including the initial attempt."),
+  retryDelayMs: z.number().nonnegative().default(150).describe("The initial delay between retry attempts, in milliseconds."),
+  maxDelayMs: z.number().nonnegative().default(5e3).describe("The maximum backoff delay between attempts, in milliseconds."),
+  jitterMs: z.number().nonnegative().default(50).describe("The maximum random jitter added to retry delays, in milliseconds."),
+  backoffFactor: z.number().positive().default(2).describe("The multiplier applied to the delay after each failed attempt."),
+  methods: z.array(nonEmptyStringSchema).default(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).describe("HTTP methods that are eligible for retries."),
+  maxRetryAfterDelayMs: z.number().nonnegative().default(6e4).describe("The longest Retry-After delay the client will honor, in milliseconds.")
 }).superRefine(validateRetryDelays);
 var constructorParameterSchema = z.strictObject({
-  name: nonEmptyStringSchema,
-  example: z.string().optional(),
-  description: z.string().optional(),
-  required: z.boolean().optional()
+  name: nonEmptyStringSchema.describe("The parameter name in the generated client constructor."),
+  example: z.string().optional().describe("An example value shown in generated documentation."),
+  description: z.string().optional().describe(
+    "A description of the constructor parameter included in generated SDK documentation."
+  ),
+  required: z.boolean().optional().describe("Whether callers must provide the parameter.")
 });
 var parameterStyleSchema = z.enum(["wrapped", "inline", "language-default"]);
 var tokenRefreshConfigSchema = z.strictObject({
-  enabled: z.boolean(),
-  endpoint: nonEmptyStringSchema.optional(),
-  accessTokenField: nonEmptyStringSchema.optional(),
-  refreshTokenField: nonEmptyStringSchema.optional()
+  enabled: z.boolean().describe("Whether the client can exchange refresh tokens."),
+  endpoint: nonEmptyStringSchema.optional().describe("The API endpoint used to refresh tokens."),
+  accessTokenField: nonEmptyStringSchema.optional().describe("The response field containing the refreshed access token."),
+  refreshTokenField: nonEmptyStringSchema.optional().describe("The response field containing the refreshed refresh token.")
 }).superRefine(({ enabled, endpoint }, context) => {
   if (enabled && endpoint === void 0) {
     context.addIssue({
@@ -310,26 +324,26 @@ var tokenRefreshConfigSchema = z.strictObject({
   }
 });
 var clientOverrideShape = {
-  retry: clientRetryOverrideSchema.optional(),
-  responseHeaders: z.boolean().optional(),
-  responseValidation: z.boolean().optional(),
-  multiTenant: z.boolean().optional(),
-  additionalConstructorParameters: z.array(constructorParameterSchema).optional(),
-  timeoutMs: z.union([z.number().nonnegative(), z.literal("infinity")]).optional(),
-  requestParameterStyle: parameterStyleSchema.optional(),
-  pathParameterStyle: parameterStyleSchema.optional(),
-  filePropertyStyle: parameterStyleSchema.optional(),
-  useDefaultRequestParameterValues: z.boolean().optional(),
-  respectOptionalRequestBody: z.boolean().optional(),
-  tokenRefresh: tokenRefreshConfigSchema.optional()
+  retry: clientRetryOverrideSchema.optional().describe("Retry behavior for generated API requests."),
+  responseHeaders: z.boolean().optional().describe("Whether generated operations expose HTTP response headers."),
+  responseValidation: z.boolean().optional().describe("Whether the client validates API responses against the schema."),
+  multiTenant: z.boolean().optional().describe("Whether the client exposes configuration for tenant-specific API access."),
+  additionalConstructorParameters: z.array(constructorParameterSchema).optional().describe("Additional parameters added to the generated client constructor."),
+  timeoutMs: z.union([z.number().nonnegative(), 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: z.boolean().optional().describe("Whether schema defaults are applied to omitted request parameters."),
+  respectOptionalRequestBody: 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 = z.strictObject(clientOverrideShape);
 var clientConfigSchema = z.strictObject({
   ...clientOverrideShape,
-  retry: retryConfigSchema.prefault({}),
-  responseHeaders: z.boolean().default(false),
-  multiTenant: z.boolean().default(false),
-  additionalConstructorParameters: z.array(constructorParameterSchema).default([])
+  retry: retryConfigSchema.prefault({}).describe("Retry behavior for generated API requests."),
+  responseHeaders: z.boolean().default(false).describe("Whether generated operations expose HTTP response headers."),
+  multiTenant: z.boolean().default(false).describe("Whether the client exposes configuration for tenant-specific API access."),
+  additionalConstructorParameters: z.array(constructorParameterSchema).default([]).describe("Additional parameters added to the generated client constructor.")
 });
 
 // src/sdk-config/v1/client.ts
@@ -344,75 +358,75 @@ var composerPackageNameSchema = nonEmptyStringSchema.regex(
   'Composer package name must be a lowercase "vendor/package" name'
 );
 var authorSchema = z.strictObject({
-  name: nonEmptyStringSchema,
-  email: z.email().optional(),
-  url: nonEmptyStringSchema.optional()
+  name: nonEmptyStringSchema.describe("The package author name."),
+  email: z.email().optional().describe("The package author email address."),
+  url: nonEmptyStringSchema.optional().describe("The package author website.")
 });
 var developerSchema = z.strictObject({
-  name: nonEmptyStringSchema,
-  email: z.email().optional(),
-  organization: nonEmptyStringSchema.optional(),
-  organizationUrl: nonEmptyStringSchema.optional()
+  name: nonEmptyStringSchema.describe("The package developer name."),
+  email: 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 = 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 = z.discriminatedUnion("type", [
   z.strictObject({
-    type: z.literal("registry"),
-    registry: nonEmptyStringSchema.optional()
+    type: z.literal("registry").describe("Resolves the dependency from a package registry."),
+    registry: nonEmptyStringSchema.optional().describe("The registry used to resolve the dependency.")
   }),
   z.strictObject({
-    type: z.literal("git"),
-    url: nonEmptyStringSchema,
-    ref: nonEmptyStringSchema.optional(),
-    subdirectory: nonEmptyStringSchema.optional()
+    type: 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.")
   }),
   z.strictObject({
-    type: z.literal("path"),
-    path: nonEmptyStringSchema
+    type: z.literal("path").describe("Resolves the dependency from a local path."),
+    path: nonEmptyStringSchema.describe("The local path containing the dependency.")
   })
 ]);
 var dependencySchema = z.strictObject({
-  name: nonEmptyStringSchema,
-  version: nonEmptyStringSchema.optional(),
-  source: dependencySourceSchema.optional(),
-  packageName: nonEmptyStringSchema.optional(),
-  features: z.array(nonEmptyStringSchema).optional(),
-  extras: z.array(nonEmptyStringSchema).optional(),
-  optional: z.boolean().optional(),
-  defaultFeatures: z.boolean().optional(),
-  environmentMarker: nonEmptyStringSchema.optional()
+  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: z.array(nonEmptyStringSchema).optional().describe("Cargo features enabled for this dependency."),
+  extras: z.array(nonEmptyStringSchema).optional().describe("Python extras enabled for this dependency."),
+  optional: z.boolean().optional().describe("Whether the dependency is optional."),
+  defaultFeatures: 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 = 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 = z.strictObject({
-  packageName: nonEmptyStringSchema.optional(),
-  moduleName: nonEmptyStringSchema.optional(),
-  modulePath: goModulePathSchema.optional(),
-  namespace: nonEmptyStringSchema.optional(),
-  groupId: nonEmptyStringSchema.optional(),
-  artifactId: nonEmptyStringSchema.optional(),
-  description: z.string().optional(),
-  repository: nonEmptyStringSchema.optional(),
-  homepage: nonEmptyStringSchema.optional(),
-  documentationUrl: nonEmptyStringSchema.optional(),
-  authors: z.array(authorSchema).optional(),
-  developers: z.array(developerSchema).optional(),
-  license: licenseSchema.optional(),
-  keywords: z.array(nonEmptyStringSchema).optional(),
-  classifiers: z.array(nonEmptyStringSchema).optional(),
-  projectUrls: z.array(projectUrlSchema).optional(),
-  extraDependencies: z.array(dependencySchema).optional(),
-  extraDevDependencies: z.array(dependencySchema).optional(),
-  extraPeerDependencies: z.array(dependencySchema).optional()
+  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: 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: z.array(authorSchema).optional().describe("Authors credited in package metadata."),
+  developers: z.array(developerSchema).optional().describe("Developers credited in package metadata."),
+  license: licenseSchema.optional().describe("License metadata for the generated package."),
+  keywords: z.array(nonEmptyStringSchema).optional().describe("Search keywords for package metadata."),
+  classifiers: z.array(nonEmptyStringSchema).optional().describe("Package classifiers used by registries such as PyPI."),
+  projectUrls: z.array(projectUrlSchema).optional().describe("Labeled project links for package metadata."),
+  extraDependencies: z.array(dependencySchema).optional().describe("Additional runtime dependencies added to the generated package."),
+  extraDevDependencies: z.array(dependencySchema).optional().describe("Additional development dependencies added to the generated package."),
+  extraPeerDependencies: z.array(dependencySchema).optional().describe("Additional peer dependencies added to the generated package.")
 });
 var httpMethodSchema = z.enum([
   "GET",
@@ -426,34 +440,34 @@ var httpMethodSchema = z.enum([
   "CONNECT"
 ]);
 var readmeEndpointSchema = z.strictObject({
-  method: httpMethodSchema,
-  path: nonEmptyStringSchema,
-  stream: z.boolean().optional()
+  method: httpMethodSchema.describe("The HTTP method of the documented endpoint."),
+  path: nonEmptyStringSchema.describe("The endpoint path used in generated examples."),
+  stream: z.boolean().optional().describe("Whether the example uses the streaming response API.")
 });
 var readmeCustomSectionSchema = z.strictObject({
-  title: nonEmptyStringSchema,
-  content: z.string()
+  title: nonEmptyStringSchema.describe("The heading displayed for this README section."),
+  content: z.string().describe("The Markdown content of this README section.")
 });
 var readmeConfigSchema = z.strictObject({
-  apiName: nonEmptyStringSchema.optional(),
-  introduction: z.string().optional(),
-  apiReferenceLink: nonEmptyStringSchema.optional(),
-  bannerLink: nonEmptyStringSchema.optional(),
-  disabledSections: z.array(nonEmptyStringSchema).optional(),
-  customSections: z.array(readmeCustomSectionSchema).optional(),
-  defaultEndpoint: readmeEndpointSchema.optional(),
-  features: z.record(z.string(), z.array(readmeEndpointSchema)).optional()
+  apiName: nonEmptyStringSchema.optional().describe("The API name displayed in the README."),
+  introduction: 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: z.array(nonEmptyStringSchema).optional().describe("Generated README sections to omit."),
+  customSections: z.array(readmeCustomSectionSchema).optional().describe("Additional sections inserted into the README."),
+  defaultEndpoint: readmeEndpointSchema.optional().describe("The endpoint used for the primary README example."),
+  features: z.record(z.string(), z.array(readmeEndpointSchema)).optional().describe("Named feature groups and the endpoints demonstrated by each group.")
 });
 var snippetsConfigSchema = z.strictObject({
-  enabled: z.boolean(),
-  format: z.enum(["md", "json"]).optional(),
-  outputPath: nonEmptyStringSchema.optional()
+  enabled: z.boolean().describe("Whether standalone usage snippets are generated."),
+  format: 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 = z.strictObject({
-  readme: readmeConfigSchema.optional(),
-  snippets: snippetsConfigSchema.optional(),
-  referenceBaseUrl: nonEmptyStringSchema.optional(),
-  includeApiReference: 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: z.boolean().optional().describe("Whether API reference documentation is included in the SDK output.")
 });
 
 // src/sdk-config/v1/docs.ts
@@ -784,6 +798,7 @@ function githubOutput(value, publishInfo, rawOutput, language, sourcePath, state
   consume(state, [...sourcePath, "repo"]);
   const publication = publishInfo ? mapPublication(publishInfo, rawOutput, language, [...sourcePath, "publishInfo"], state, index) : void 0;
   const type = stringValue(value.type);
+  const licensePackage = mapGithubLicense(value.license, [...sourcePath, "license"], state);
   const reviewers = mapReviewers(value.reviewers, [...sourcePath, "reviewers"], state);
   if (type) consume(state, [...sourcePath, "type"]);
   if (typeof value.makePr === "boolean") consume(state, [...sourcePath, "makePr"]);
@@ -810,9 +825,20 @@ function githubOutput(value, publishInfo, rawOutput, language, sourcePath, state
       },
       ...publication ? { publish: publication.publish } : {}
     },
-    ...optional("package", publication?.package)
+    // The GitHub license wins over a publication-supplied one; `licensePackage` is `{}` or `{ license }`.
+    ...optionalObject("package", { ...publication?.package, ...licensePackage })
   };
 }
+var basicLicenseTypes = { mit: "MIT", apache: "APACHE" };
+function mapGithubLicense(value, sourcePath, state) {
+  if (!isObject(value) || stringValue(value.type) !== "basic") return {};
+  const id = stringValue(value.id);
+  const type = id ? basicLicenseTypes[id.toLowerCase()] : void 0;
+  if (!type) return {};
+  consume(state, [...sourcePath, "type"]);
+  consume(state, [...sourcePath, "id"]);
+  return { license: { type } };
+}
 function consumeCredentialObject(value, sourcePath, state) {
   if (!isObject(value)) return;
   for (const field of ["username", "password", "token", "apiKey"]) {
@@ -1240,16 +1266,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 ? [
@@ -1320,6 +1340,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;
@@ -1441,59 +1464,48 @@ function deepEqual(left, right) {
   return false;
 }
 var namingConfigSchema = 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: z.boolean().optional(),
+  smartCasing: z.boolean().optional().describe("Whether generated identifiers use initialism-aware casing."),
   /** Preserve a word boundary after digits when Fern smart casing is enabled. */
-  smartCasingDigitWordBoundary: z.boolean().optional()
+  smartCasingDigitWordBoundary: z.boolean().optional().describe("Whether smart casing preserves a word boundary after digits.")
 });
 
 // src/sdk-config/v1/generation.ts
 var customerGenerationAssetSchema = z.discriminatedUnion("type", [
-  z.strictObject({ type: z.literal("path"), location: relativePathSchema }),
-  z.strictObject({ type: z.literal("url"), location: nonEmptyStringSchema })
-]);
-var hookDependencySchema = z.strictObject({
-  name: nonEmptyStringSchema,
-  version: nonEmptyStringSchema,
-  groupId: nonEmptyStringSchema.optional()
-});
-var hooksConfigSchema = z.strictObject({
-  enabled: z.boolean(),
-  source: customerGenerationAssetSchema.optional(),
-  dependencies: z.array(hookDependencySchema).optional()
-});
-var customCodeConfigSchema = z.strictObject({
-  enabled: z.boolean(),
-  source: customerGenerationAssetSchema.optional(),
-  conflictStrategy: z.enum(["mark", "ours", "theirs"]).optional(),
-  trackChanges: z.boolean().optional(),
-  protectedFiles: z.array(nonEmptyStringSchema).optional()
-});
-var workflowConfigSchema = z.strictObject({
-  path: relativePathSchema,
-  outputName: nonEmptyStringSchema.optional()
-});
-var analyticsHeaderSchema = z.union([
-  z.strictObject({ name: nonEmptyStringSchema, value: z.string() }),
   z.strictObject({
-    name: nonEmptyStringSchema,
-    valueRef: nonEmptyStringSchema
+    type: z.literal("path").describe("Loads the generation asset from a relative path."),
+    location: relativePathSchema.describe("The relative path to the generation asset.")
+  }),
+  z.strictObject({
+    type: z.literal("url").describe("Loads the generation asset from a URL."),
+    location: nonEmptyStringSchema.describe("The URL of the generation asset.")
   })
 ]);
+var customCodeConfigSchema = z.strictObject({
+  enabled: z.boolean().describe("Whether customer-authored code is merged into generated output."),
+  source: customerGenerationAssetSchema.optional().describe("The source containing customer-authored code."),
+  conflictStrategy: z.enum(["mark", "ours", "theirs"]).optional().describe("How merge conflicts between generated and custom code are handled."),
+  trackChanges: z.boolean().optional().describe("Whether custom-code changes are tracked between builds."),
+  protectedFiles: z.array(nonEmptyStringSchema).optional().describe("Generated file paths that custom-code merging must not overwrite.")
+});
+var analyticsHeaderSchema = z.strictObject({
+  name: nonEmptyStringSchema.describe("The exported telemetry header name."),
+  value: z.string().describe("The literal telemetry header value.")
+});
 var analyticsConfigSchema = z.strictObject({
-  enabled: z.boolean(),
-  endpoint: nonEmptyStringSchema.optional(),
-  exporter: z.enum(["otlp-http", "console"]).optional(),
-  headers: z.array(analyticsHeaderSchema).optional(),
-  batchSize: z.number().int().positive().optional(),
-  scheduledDelayMs: z.number().nonnegative().optional(),
-  exportTimeoutMs: z.number().nonnegative().optional()
+  enabled: z.boolean().describe("Whether generated clients export usage telemetry."),
+  endpoint: nonEmptyStringSchema.optional().describe("The telemetry export endpoint."),
+  exporter: z.enum(["otlp-http", "console"]).optional().describe("The telemetry exporter implementation."),
+  headers: z.array(analyticsHeaderSchema).optional().describe("Headers sent by the telemetry exporter."),
+  batchSize: z.number().int().positive().optional().describe("The maximum spans in each export batch."),
+  scheduledDelayMs: z.number().nonnegative().optional().describe("The delay between scheduled exports, in milliseconds."),
+  exportTimeoutMs: 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({
@@ -1504,73 +1516,63 @@ var analyticsConfigSchema = z.strictObject({
   }
 });
 var wireTestsSchema = z.strictObject({
-  enabled: z.boolean(),
-  exclusions: z.array(nonEmptyStringSchema).optional(),
-  fallbackToGeneratedErrorExamples: z.boolean().optional(),
-  fixtureSource: z.enum(["synthetic", "recorded", "auto"]).optional()
+  enabled: z.boolean().describe("Whether wire-level request and response tests are generated."),
+  exclusions: z.array(nonEmptyStringSchema).optional().describe("Operations excluded from wire tests."),
+  fallbackToGeneratedErrorExamples: z.boolean().optional().describe("Whether missing error fixtures are synthesized from generated examples."),
+  fixtureSource: z.enum(["synthetic", "recorded", "auto"]).optional().describe("Where wire-test fixtures are obtained.")
 });
 var unitTestsSchema = z.strictObject({
-  enabled: z.boolean(),
-  mode: z.enum(["core-runtime", "schema-driven", "both"]).optional(),
-  exclusions: z.array(nonEmptyStringSchema).optional()
+  enabled: z.boolean().describe("Whether SDK unit tests are generated."),
+  exclusions: z.array(nonEmptyStringSchema).optional().describe("Operations excluded from unit tests.")
 });
 var streamsSchema = z.strictObject({
-  enabled: z.boolean(),
-  responseType: z.enum(["wrapper", "native", "web"]).optional(),
-  fileResponseType: z.enum(["stream", "binary-response"]).optional(),
-  defaultChunkSizeBytes: z.number().int().positive().optional()
+  enabled: z.boolean().describe("Whether generated clients expose streaming response APIs."),
+  responseType: z.enum(["wrapper", "native", "web"]).optional().describe("The streaming response abstraction exposed by generated clients."),
+  fileResponseType: z.enum(["stream", "binary-response"]).optional().describe("The response type used for file downloads."),
+  defaultChunkSizeBytes: z.number().int().positive().optional().describe("The default number of bytes yielded by streaming iterators.")
 });
 var layoutConfigSchema = z.strictObject({
-  outputDirectory: z.enum(["project-root", "source-root"]).optional(),
-  packagePath: nonEmptyStringSchema.optional()
+  outputDirectory: 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 = z.strictObject({
-  enumRepresentation: z.enum(["enum", "union", "literal", "forward-compatible-enum", "language-default"]).optional(),
-  additionalProperties: z.enum(["allow", "forbid", "ignore", "language-default"]).optional(),
-  inlineTypes: z.boolean().optional(),
-  omitUndefined: z.boolean().optional()
+  enumRepresentation: z.enum(["enum", "union", "literal", "forward-compatible-enum", "language-default"]).optional().describe("How schema enums are represented in generated code."),
+  additionalProperties: z.enum(["allow", "forbid", "ignore", "language-default"]).optional().describe("How undeclared object properties are handled."),
+  inlineTypes: z.boolean().optional().describe("Whether inline schemas remain nested under their parent types."),
+  omitUndefined: z.boolean().optional().describe("Whether undefined properties are omitted during serialization.")
 });
 var generationConfigOverrideShape = {
-  includeWatermark: z.boolean().optional(),
-  ai: z.boolean().optional(),
-  includeOptionalSnippetParameters: z.boolean().optional(),
-  buildAllModels: z.boolean().optional(),
-  inferServiceNames: z.boolean().optional(),
-  includeDeprecatedOperations: z.boolean().optional(),
-  multipleResponses: z.boolean().optional(),
-  /** Generate the entire SDK project, including package manifests and publishable artifacts. */
-  generateFullProject: z.boolean().optional(),
-  devContainer: z.boolean().optional(),
-  allowMockClient: z.boolean().optional(),
-  ignoreFiles: z.array(nonEmptyStringSchema).optional(),
-  reservedKeywords: z.array(nonEmptyStringSchema).optional(),
-  hooks: hooksConfigSchema.optional(),
-  customCode: customCodeConfigSchema.optional(),
-  workflows: z.array(workflowConfigSchema).optional(),
-  customQueryPaths: z.array(relativePathSchema).optional(),
-  analytics: analyticsConfigSchema.optional(),
-  wireTests: wireTestsSchema.optional(),
-  unitTests: unitTestsSchema.optional(),
-  webSockets: z.boolean().optional(),
-  streams: streamsSchema.optional(),
-  naming: namingConfigSchema.optional(),
-  layout: layoutConfigSchema.optional(),
-  serialization: serializationConfigSchema.optional()
+  includeOptionalSnippetParameters: z.boolean().optional().describe("Whether usage snippets include optional request parameters."),
+  buildAllModels: z.boolean().optional().describe("Whether models not referenced by operations are also generated."),
+  inferServiceNames: z.boolean().optional().describe("Whether service names are inferred from API structure."),
+  includeDeprecatedOperations: z.boolean().optional().describe("Whether deprecated API operations are generated."),
+  multipleResponses: z.boolean().optional().describe("Whether operations model multiple successful response types."),
+  devContainer: z.boolean().optional().describe("Whether development-container configuration is generated."),
+  allowMockClient: z.boolean().optional().describe("Whether a mock API client is included in the generated SDK."),
+  ignoreFiles: z.array(nonEmptyStringSchema).optional().describe("Generated paths excluded from the final output."),
+  reservedKeywords: z.array(nonEmptyStringSchema).optional().describe("Additional identifiers treated as reserved words."),
+  customCode: customCodeConfigSchema.optional().describe("Customer-authored code merge configuration."),
+  customQueryPaths: 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: 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 = z.strictObject(
   generationConfigOverrideShape
 );
 var sdkConfigV1GenerationConfigSchema = z.strictObject({
   ...generationConfigOverrideShape,
-  includeWatermark: z.boolean().default(false),
-  ai: z.boolean().default(false),
-  buildAllModels: z.boolean().default(false),
-  inferServiceNames: z.boolean().default(false),
-  includeDeprecatedOperations: z.boolean().default(true),
-  multipleResponses: z.boolean().default(false),
-  generateFullProject: z.boolean().default(false),
-  devContainer: z.boolean().default(false),
-  allowMockClient: z.boolean().default(false)
+  buildAllModels: z.boolean().default(false).describe("Whether models not referenced by operations are also generated."),
+  inferServiceNames: z.boolean().default(false).describe("Whether service names are inferred from API structure."),
+  includeDeprecatedOperations: z.boolean().default(true).describe("Whether deprecated API operations are generated."),
+  multipleResponses: z.boolean().default(false).describe("Whether operations model multiple successful response types."),
+  devContainer: z.boolean().default(false).describe("Whether development-container configuration is generated."),
+  allowMockClient: 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) {
@@ -1592,78 +1594,97 @@ var sdkConfigV1PublishRegistrySchema = z.enum([
   "composer"
 ]);
 var mavenSignatureSchema = 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: 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: z.boolean().optional().describe("Whether an already-published package version is treated as non-fatal.")
 };
 var sdkConfigV1PublishConfigSchema = z.discriminatedUnion("registry", [
   z.strictObject({
-    registry: z.literal("npm"),
-    token: nonEmptyStringSchema.optional(),
+    registry: 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
+  }),
+  z.strictObject({
+    registry: 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
   }),
   z.strictObject({
-    registry: z.literal("pypi"),
-    username: nonEmptyStringSchema.optional(),
-    password: nonEmptyStringSchema.optional(),
+    registry: 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
   }),
   z.strictObject({
-    registry: z.literal("maven"),
-    username: nonEmptyStringSchema.optional(),
-    password: nonEmptyStringSchema.optional(),
-    signature: mavenSignatureSchema.optional(),
+    registry: z.literal("nuget").describe("Publishes the package to a NuGet-compatible registry."),
     ...commonPublishShape
   }),
-  z.strictObject({ registry: z.literal("nuget"), ...commonPublishShape }),
-  z.strictObject({ registry: z.literal("rubygems"), ...commonPublishShape }),
   z.strictObject({
-    registry: z.literal("crates"),
-    token: nonEmptyStringSchema.optional(),
+    registry: z.literal("rubygems").describe("Publishes the package to a RubyGems-compatible registry."),
     ...commonPublishShape
   }),
-  z.strictObject({ registry: z.literal("go"), ...commonPublishShape }),
-  z.strictObject({ registry: z.literal("composer"), ...commonPublishShape })
+  z.strictObject({
+    registry: 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
+  }),
+  z.strictObject({
+    registry: z.literal("go").describe("Publishes the SDK as a Go module."),
+    ...commonPublishShape
+  }),
+  z.strictObject({
+    registry: z.literal("composer").describe("Publishes the package to a Composer-compatible registry."),
+    ...commonPublishShape
+  })
 ]);
 var reviewersSchema = z.strictObject({
-  teams: z.array(nonEmptyStringSchema).optional(),
-  users: z.array(nonEmptyStringSchema).optional()
+  teams: z.array(nonEmptyStringSchema).optional().describe("GitHub teams requested as reviewers."),
+  users: z.array(nonEmptyStringSchema).optional().describe("GitHub users requested as reviewers.")
 });
 var githubCredentialsSchema = 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 = z.strictObject({
-  repository: nonEmptyStringSchema,
-  host: nonEmptyStringSchema.optional(),
-  branch: nonEmptyStringSchema.optional(),
-  mode: 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: 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: 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: z.boolean().optional().describe("Whether the destination repository is private.")
 });
 var filesOutputSchema = z.strictObject({
-  delivery: z.literal("files"),
-  path: nonEmptyStringSchema.optional(),
-  publish: sdkConfigV1PublishConfigSchema.optional()
+  delivery: 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 = z.strictObject({
-  delivery: z.literal("zip"),
-  fileName: nonEmptyStringSchema.optional(),
-  publish: sdkConfigV1PublishConfigSchema.optional()
+  delivery: 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 = z.strictObject({
-  delivery: z.literal("github"),
-  github: githubOutputSchema,
-  publish: sdkConfigV1PublishConfigSchema.optional()
+  delivery: 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 = z.discriminatedUnion(
   "delivery",
@@ -1675,29 +1696,33 @@ var sdkConfigV1OutputConfigSchema = z.discriminatedUnion(
 var sdkConfigV1DependencySchema = dependencySchema;
 var sdkConfigV1PackageConfigSchema = packageConfigSchema;
 var sdkConfigV1ReplayConfigSchema = z.strictObject({
-  enabled: z.boolean()
+  enabled: z.boolean().describe("Whether regeneration reapplies customer-authored repository changes.")
 });
 var apiImportSettingsSchema = z.strictObject({
-  respectNullableSchemas: z.boolean().optional(),
-  titleAsSchemaName: z.boolean().optional(),
-  coerceEnumsToLiterals: z.boolean().optional(),
-  idiomaticRequestNames: z.boolean().optional(),
-  wrapReferencesToNullableInOptional: z.boolean().optional(),
-  coerceOptionalSchemasToNullable: z.boolean().optional(),
-  pathParameterOrder: z.enum(["url-order", "spec-order"]).optional(),
-  onlyIncludeReferencedSchemas: z.boolean().optional(),
-  objectQueryParameters: z.boolean().optional(),
-  typeDatesAsStrings: z.boolean().optional(),
-  groupMultiApiEnvironments: z.boolean().optional(),
-  ignoreTags: z.boolean().optional(),
-  disambiguateRequestNames: z.boolean().optional(),
-  respectReadonlySchemas: z.boolean().optional(),
-  discriminatedUnionV2: z.boolean().optional(),
-  undiscriminatedUnionsWithLiterals: z.boolean().optional(),
-  inlineAllOfSchemas: z.boolean().optional(),
-  resolveSchemaCollisions: z.boolean().optional(),
-  asyncApiMessageNaming: z.enum(["v1", "v2"]).optional(),
-  defaultIntegerFormat: z.enum(["int32", "int64", "uint32", "uint64"]).optional()
+  respectNullableSchemas: z.boolean().optional().describe("Whether nullable schemas remain nullable in generated types."),
+  titleAsSchemaName: z.boolean().optional().describe("Whether a schema title can determine the generated type name."),
+  coerceEnumsToLiterals: z.boolean().optional().describe("Whether single-value enums are imported as literal values."),
+  idiomaticRequestNames: z.boolean().optional().describe("Whether request types use concise, idiomatic generated names."),
+  wrapReferencesToNullableInOptional: z.boolean().optional().describe("Whether nullable schema references are also treated as optional."),
+  coerceOptionalSchemasToNullable: z.boolean().optional().describe("Whether optional properties are represented as nullable required properties."),
+  pathParameterOrder: z.enum(["url-order", "spec-order"]).optional().describe("Whether path parameters follow their URL order or specification order."),
+  onlyIncludeReferencedSchemas: z.boolean().optional().describe("Whether unreferenced schemas are omitted from the generated SDK."),
+  objectQueryParameters: z.boolean().optional().describe("Whether object-valued query parameters are preserved as objects."),
+  typeDatesAsStrings: z.boolean().optional().describe("Whether date and date-time schemas are generated as strings."),
+  groupMultiApiEnvironments: z.boolean().optional().describe(
+    "Whether environments from multiple API sources are merged into shared named groups."
+  ),
+  ignoreTags: z.boolean().optional().describe("Whether API tags are ignored when organizing generated resources."),
+  disambiguateRequestNames: z.boolean().optional().describe("Whether colliding request type names are automatically disambiguated."),
+  respectReadonlySchemas: z.boolean().optional().describe(
+    "Whether read-only properties are modeled separately for request and response types."
+  ),
+  discriminatedUnionV2: z.boolean().optional().describe("Whether oneOf and anyOf schemas use the newer discriminator inference rules."),
+  undiscriminatedUnionsWithLiterals: z.boolean().optional().describe("Whether literal-bearing unions remain undiscriminated during import."),
+  inlineAllOfSchemas: z.boolean().optional().describe("Whether schemas composed with allOf are inlined when possible."),
+  resolveSchemaCollisions: z.boolean().optional().describe("Whether colliding imported schema names are resolved automatically."),
+  asyncApiMessageNaming: z.enum(["v1", "v2"]).optional().describe("The naming strategy used for messages imported from AsyncAPI."),
+  defaultIntegerFormat: z.enum(["int32", "int64", "uint32", "uint64"]).optional().describe("The integer format used when a schema does not declare one.")
 });
 var sourceSpecTypeSchema = z.enum([
   "openapi",
@@ -1709,27 +1734,30 @@ var sourceSpecTypeSchema = z.enum([
 
 // src/sdk-config/v1/source.ts
 var sourceSpecShape = {
-  id: nonEmptyStringSchema,
-  type: sourceSpecTypeSchema,
-  name: nonEmptyStringSchema.optional(),
-  namespace: nonEmptyStringSchema.optional(),
-  apiImportSettings: apiImportSettingsSchema.optional(),
-  overlays: z.array(relativePathSchema).optional(),
-  overrides: 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: z.array(relativePathSchema).optional().describe("Relative paths to overlays applied to this source in order."),
+  overrides: z.array(relativePathSchema).optional().describe("Relative paths to source override files applied in order.")
 };
 var sdkConfigV1SourceSpecSchema = z.union(
   [
-    z.strictObject({ ...sourceSpecShape, path: relativePathSchema }),
     z.strictObject({
       ...sourceSpecShape,
-      url: z.url({ protocol: /^https?$/ })
+      path: relativePathSchema.describe("The relative path to the API source file.")
+    }),
+    z.strictObject({
+      ...sourceSpecShape,
+      url: 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 = z.strictObject({
-  specs: z.array(sdkConfigV1SourceSpecSchema).min(1, "source.specs must contain at least one source spec"),
-  apiImportSettings: apiImportSettingsSchema.optional()
+  specs: 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) => {
@@ -1744,74 +1772,80 @@ var sdkConfigV1SourceConfigSchema = z.strictObject({
   });
 });
 var cliGenerationConfigSchema = z.strictObject({
-  paginationParameters: z.array(nonEmptyStringSchema).optional(),
-  skills: z.boolean().optional()
+  paginationParameters: z.array(nonEmptyStringSchema).optional().describe("Request parameter names treated as pagination controls by the CLI."),
+  skills: z.boolean().optional().describe("Whether the generated CLI includes skills that teach AI agents to invoke commands.")
 });
 var csharpGenerationConfigSchema = z.strictObject({
-  useOptionalWrapper: z.boolean().optional(),
-  simplifyObjectDictionaries: z.boolean().optional(),
-  explicitNamespaces: z.boolean().optional(),
-  rootNamespaceForCoreClasses: z.boolean().optional(),
-  includeExceptionHandler: z.boolean().optional(),
-  experimentalExplicitNullableOptional: z.boolean().optional()
+  useOptionalWrapper: z.boolean().optional().describe("Whether optional values use an explicit Optional wrapper."),
+  simplifyObjectDictionaries: z.boolean().optional().describe("Whether object schemas with arbitrary values use simplified dictionary types."),
+  explicitNamespaces: z.boolean().optional().describe("Whether generated resource groups use explicit nested namespaces."),
+  rootNamespaceForCoreClasses: z.boolean().optional().describe("Whether shared client classes are emitted in the root namespace."),
+  includeExceptionHandler: z.boolean().optional().describe("Whether generated client operations use a configurable exception handler."),
+  experimentalExplicitNullableOptional: z.boolean().optional().describe(
+    "Whether optional nullable properties distinguish omitted values from explicit nulls."
+  )
 });
 var goGenerationConfigSchema = z.strictObject({
-  legacyComplexModels: z.boolean().optional(),
+  legacyComplexModels: z.boolean().optional().describe("Whether complex models use the legacy Go representation."),
   /** Uppercase common initialisms in generated names (`UserID` rather than `UserId`). */
-  smartCasing: z.boolean().optional(),
+  smartCasing: 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: z.enum(["v0", "v1"]).optional(),
-  includeLegacyClientOptions: z.boolean().optional()
+  clientConstructorName: nonEmptyStringSchema.optional().describe("The generated root-client constructor name."),
+  unionVersion: z.enum(["v0", "v1"]).optional().describe("The representation used for generated Go unions."),
+  includeLegacyClientOptions: z.boolean().optional().describe("Whether the client retains legacy constructor option helpers.")
 });
 var jvmGenerationConfigSchema = z.strictObject({
-  packageLayout: z.enum(["flat", "nested"]).optional(),
-  useLocalDateForDates: z.boolean().optional(),
-  collapseOptionalNullable: z.boolean().optional(),
-  gradleDistributionUrl: z.string().min(1).optional(),
-  gradlePluginManagement: z.string().optional(),
-  gradleCentralDependencyManagement: z.boolean().optional(),
+  packageLayout: z.enum(["flat", "nested"]).optional().describe("Whether generated JVM packages use a flat or nested resource layout."),
+  useLocalDateForDates: z.boolean().optional().describe("Whether date-only values use LocalDate instead of OffsetDateTime."),
+  collapseOptionalNullable: z.boolean().optional().describe("Whether optional nullable values collapse into a single nullable representation."),
+  gradleDistributionUrl: z.string().min(1).optional().describe("The Gradle distribution URL written to the generated wrapper."),
+  gradlePluginManagement: z.string().optional().describe("Plugin management configuration added to the generated Gradle settings."),
+  gradleCentralDependencyManagement: 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: z.enum(["dedicated-client", "twin-methods"]).optional()
+  asyncStyle: 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: z.boolean().optional()
+  includeKotlinSnippets: 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 = z.strictObject({
-  target: nonEmptyStringSchema.optional(),
-  module: nonEmptyStringSchema.optional(),
-  lib: 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: z.array(nonEmptyStringSchema).optional().describe("The runtime library definitions passed to TypeScript.")
 });
 var packageScriptSchema = 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 = z.strictObject({
-  name: z.enum(["axios", "fetch"])
+  name: z.enum(["axios", "fetch"]).describe("The HTTP client used by generated TypeScript code.")
 });
 var typescriptGenerationConfigSchema = z.strictObject({
-  typescriptVersion: nonEmptyStringSchema.optional(),
-  zodVersion: nonEmptyStringSchema.optional(),
-  compilerOptions: compilerOptionsSchema.optional(),
-  httpClient: httpClientSchema.optional(),
-  packageManager: z.enum(["pnpm", "yarn"]).optional(),
-  testFramework: z.enum(["jest", "vitest"]).optional(),
-  namingStrategy: z.enum(["base", "originalPropertyNames"]).optional(),
-  bundle: z.boolean().optional(),
-  exportClassDefault: z.boolean().optional(),
+  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: 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: z.enum(["jest", "vitest"]).optional().describe("The test framework used by generated tests."),
+  namingStrategy: z.enum(["base", "originalPropertyNames"]).optional().describe("How schema property names are converted into TypeScript identifiers."),
+  bundle: z.boolean().optional().describe("Whether the generated package includes bundled output."),
+  exportClassDefault: z.boolean().optional().describe("Whether the client class is also exported as the default export."),
   /** Name of the top-level namespace export emitted by Fern-compatible TypeScript SDKs. */
-  namespaceExportName: nonEmptyStringSchema.optional(),
-  allowCustomFetcher: z.boolean().optional(),
-  useBrandedStringAliases: z.boolean().optional(),
-  useLegacyExports: z.boolean().optional(),
-  useBigInt: z.boolean().optional(),
-  serdeLayer: z.boolean().optional(),
-  scripts: z.array(packageScriptSchema).optional()
+  namespaceExportName: nonEmptyStringSchema.optional().describe("The top-level namespace export name."),
+  consolidateTypeFiles: z.boolean().optional().describe("Whether generated types are consolidated into fewer source files."),
+  allowCustomFetcher: z.boolean().optional().describe("Whether callers can supply a custom fetch implementation."),
+  useBrandedStringAliases: z.boolean().optional().describe("Whether string aliases are emitted as distinct branded types."),
+  useLegacyExports: z.boolean().optional().describe("Whether the package emits the legacy export layout."),
+  useBigInt: z.boolean().optional().describe("Whether 64-bit integer values are represented with bigint."),
+  serdeLayer: 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: z.boolean().optional().describe("Whether the package emits only ECMAScript modules."),
+  scripts: z.array(packageScriptSchema).optional().describe("Additional scripts added to the generated package manifest.")
 });
 
 // src/sdk-config-domain/v1/language/mcp.ts
@@ -1826,172 +1860,183 @@ var mcpAvailabilityStatuses = [
   "LEGACY"
 ];
 var mcpToolFilterSchema = z.strictObject({
-  include: z.array(nonEmptyStringSchema).optional(),
-  exclude: z.array(nonEmptyStringSchema).optional()
+  include: z.array(nonEmptyStringSchema).optional().describe("Operations explicitly included as MCP tools."),
+  exclude: 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: z.array(z.enum(mcpAvailabilityStatuses)).optional(),
-  tools: mcpToolFilterSchema.optional(),
-  toolsets: 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: z.array(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: z.record(mcpToolsetNameSchema, mcpToolFilterSchema).optional().describe("Named MCP toolsets and the operation filters for each toolset.")
 });
 var phpGenerationConfigSchema = z.strictObject({
-  propertyAccess: z.enum(["public", "private"]).optional(),
-  generateClientInterfaces: z.boolean().optional()
+  propertyAccess: z.enum(["public", "private"]).optional().describe("The visibility of generated PHP model properties."),
+  generateClientInterfaces: z.boolean().optional().describe("Whether interfaces are generated for PHP client classes.")
 });
 var pythonClientSchema = 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 = z.strictObject({
-  versionCompatibility: z.enum(["v1", "v2", "both", "v1-on-v2"]).optional(),
-  frozen: z.boolean().optional(),
-  requireOptionalFields: z.boolean().optional(),
-  unionNaming: z.enum(["v0", "v1"]).optional(),
-  useFieldAliases: z.boolean().optional()
+  versionCompatibility: z.enum(["v1", "v2", "both", "v1-on-v2"]).optional().describe("The Pydantic major versions supported by generated models."),
+  frozen: z.boolean().optional().describe("Whether generated Pydantic models are immutable."),
+  requireOptionalFields: z.boolean().optional().describe("Whether Optional fields remain required unless they declare a default."),
+  unionNaming: z.enum(["v0", "v1"]).optional().describe("The naming strategy for generated union types."),
+  useFieldAliases: z.boolean().optional().describe("Whether Pydantic field aliases preserve wire names.")
 });
 var additionalInitExportSchema = z.strictObject({
-  from: nonEmptyStringSchema,
-  imports: z.array(nonEmptyStringSchema).min(1)
+  from: nonEmptyStringSchema.describe("The module from which names are re-exported."),
+  imports: z.array(nonEmptyStringSchema).min(1).describe("Names re-exported from the module.")
 });
 var pythonGenerationConfigSchema = 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: z.boolean().optional(),
+  followRedirectsByDefault: z.boolean().optional().describe("Whether generated HTTP clients follow redirects by default."),
   /** Chunk size passed to Python byte-stream iterators. */
-  defaultBytesStreamChunkSize: z.number().int().positive().optional(),
+  defaultBytesStreamChunkSize: 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: z.number().int().gt(1e3).optional(),
+  recursionLimit: 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: z.record(nonEmptyStringSchema, z.array(nonEmptyStringSchema)).optional(),
-  alwaysInitializeOptionals: z.boolean().optional(),
-  useTypedDictRequests: z.boolean().optional(),
-  additionalInitExports: z.array(additionalInitExportSchema).optional()
+  extras: z.record(nonEmptyStringSchema, z.array(nonEmptyStringSchema)).optional().describe("Published Python extras and their dependency names."),
+  alwaysInitializeOptionals: z.boolean().optional().describe("Whether optional model fields are initialized even when omitted."),
+  useTypedDictRequests: z.boolean().optional().describe("Whether request bodies are generated as TypedDict types."),
+  additionalInitExports: z.array(additionalInitExportSchema).optional().describe("Additional names re-exported from the package initializer.")
 });
 var rubyGenerationConfigSchema = z.strictObject({
-  requirePaths: z.array(nonEmptyStringSchema).optional()
+  requirePaths: z.array(nonEmptyStringSchema).optional().describe("Ruby load paths included in the generated gem specification.")
 });
 var rustGenerationConfigSchema = z.strictObject({
   /**
    * Rust type for datetime primitives. `offset` maps to `DateTime<FixedOffset>` and preserves the
    * timezone the payload carried; `utc` maps to `DateTime<Utc>` and normalizes to UTC.
    */
-  dateTimeType: z.enum(["offset", "utc"]).optional(),
+  dateTimeType: 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: z.boolean().optional(),
+  capitalizeInitialisms: 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: z.record(z.string(), z.array(nonEmptyStringSchema)).optional(),
+  features: z.record(z.string(), 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: z.array(nonEmptyStringSchema).optional()
+  defaultFeatures: z.array(nonEmptyStringSchema).optional().describe("Cargo features included in the crate default feature set.")
 });
 var swiftGenerationConfigSchema = z.strictObject({
-  moduleName: nonEmptyStringSchema.optional(),
-  nullableAsOptional: z.boolean().optional()
+  moduleName: nonEmptyStringSchema.optional().describe("The Swift module name for the generated package."),
+  nullableAsOptional: z.boolean().optional().describe("Whether nullable values are represented as Swift optionals.")
 });
 var planModifierSourceSchema = z.discriminatedUnion("enabled", [
-  z.strictObject({ enabled: z.literal(true), sourceDir: nonEmptyStringSchema }),
-  z.strictObject({ enabled: z.literal(false) })
+  z.strictObject({
+    enabled: z.literal(true).describe("Enables custom Terraform plan modifiers."),
+    sourceDir: nonEmptyStringSchema.describe(
+      "The directory containing custom plan modifier source files."
+    )
+  }),
+  z.strictObject({
+    enabled: z.literal(false).describe("Disables custom Terraform plan modifiers.")
+  })
 ]);
 var planModifiersSchema = 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 = 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 = z.strictObject({
-  providerName: nonEmptyStringSchema.optional(),
-  providerVersion: nonEmptyStringSchema.optional(),
-  providerModulePath: goModulePathSchema.optional(),
-  mockAcceptance: z.boolean().optional(),
-  hideComputedDiff: 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: z.boolean().optional().describe("Whether acceptance tests use a mock API server."),
+  hideComputedDiff: 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 = z.discriminatedUnion("language", [
   z.strictObject({
-    language: z.literal("typescript"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(typescriptGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("python"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(pythonGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("java"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(javaGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("kotlin"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(kotlinGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("go"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(goGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("csharp"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(csharpGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("php"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(phpGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("ruby"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(rubyGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("rust"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(rustGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("swift"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(swiftGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("cli"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(cliGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("mcp"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(mcpGenerationConfigSchema.shape).optional(),
+    language: 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
   }),
   z.strictObject({
-    language: z.literal("terraform"),
-    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(terraformGenerationConfigSchema.shape).optional(),
+    language: 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
   })
 ]);
@@ -2084,19 +2129,21 @@ function validateTargetPublishing(target, targetIndex, globalPackage, globalOutp
   );
 }
 var sdkConfigV1Schema = z.strictObject({
-  schemaVersion: 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: z.array(sdkConfigV1TargetSchema).min(1)
+  schemaVersion: 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: 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) => {
@@ -2376,9 +2423,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, [
@@ -2409,6 +2453,7 @@ function unsupportedResolvedFields(generator, index) {
       "disableExamples",
       generator.disableExamples === false ? void 0 : generator.disableExamples
     ],
+    ["generateFullProject", generator.generateFullProject],
     ["apiOverride", generator.apiOverride]
   ];
   return values.flatMap(([field, value]) => {
@@ -2438,6 +2483,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."
   };
@@ -2484,15 +2534,23 @@ function mapCommonConfig(language, config, state, client, generation, packageCon
     };
   }
   const pythonClient = language === "python" ? takeObject(config, ["client"], state, basePath) : void 0;
+  const typescriptNaming = language === "typescript" || language === "mcp" ? takeObject(config, ["naming"], state, basePath) : void 0;
   const directClientName = takeString(config, ["clientName", "clientClassName"], state, basePath);
-  const nestedClientName = pythonClient ? takeString(pythonClient.value, ["className"], state, pythonClient.path) : void 0;
+  const nestedClientName = pythonClient ? takeString(pythonClient.value, ["className"], state, pythonClient.path) : typescriptNaming ? takeString(typescriptNaming.value, ["client"], state, typescriptNaming.path) : void 0;
   const directExportedClientName = takeString(
     config,
     ["exportedClientName", "exportedClientClassName"],
     state,
     basePath
   );
-  const nestedExportedClientName = pythonClient ? takeString(pythonClient.value, ["exportedClassName"], state, pythonClient.path) : void 0;
+  const nestedExportedClientName = pythonClient ? takeString(pythonClient.value, ["exportedClassName"], state, pythonClient.path) : typescriptNaming ? (
+    // TypeScript's `naming.namespace` is the base every other naming.* field defaults from
+    // (Fern's docs: `client` defaults to `${PascalCase(namespace)}Client`, same for
+    // `environment`/`error`/etc.) — the same role `exportedClientName` already plays for every
+    // other language's `clientPrefix` derivation.
+    takeString(typescriptNaming.value, ["namespace"], state, typescriptNaming.path)
+  ) : void 0;
+  const nestedEnvironmentTypeName = typescriptNaming ? takeString(typescriptNaming.value, ["environment"], state, typescriptNaming.path) : void 0;
   const naming = compact({
     pagerName: takeString(
       config,
@@ -2502,12 +2560,7 @@ function mapCommonConfig(language, config, state, client, generation, packageCon
     ),
     clientName: directClientName ?? nestedClientName,
     exportedClientName: directExportedClientName ?? nestedExportedClientName,
-    environmentTypeName: takeString(
-      config,
-      ["environmentClassName", "environmentEnumName"],
-      state,
-      basePath
-    ),
+    environmentTypeName: takeString(config, ["environmentClassName", "environmentEnumName"], state, basePath) ?? nestedEnvironmentTypeName,
     apiErrorName: takeString(config, ["baseApiExceptionClassName"], state, basePath),
     baseErrorName: takeString(config, ["baseExceptionClassName"], state, basePath)
   });
@@ -2521,8 +2574,10 @@ function mapCommonConfig(language, config, state, client, generation, packageCon
     basePath
   );
   if (webSockets !== void 0) generation.webSockets = webSockets;
-  const generateFullProject = takeBoolean(config, ["generateFullProject"], state, basePath);
-  if (generateFullProject !== void 0) generation.generateFullProject = generateFullProject;
+  if (language === "typescript") {
+    const streams = mapTypescriptStreams(config, state, basePath);
+    if (streams) generation.streams = streams;
+  }
   const inlineTypes = takeBoolean(config, ["enableInlineTypes"], state, basePath);
   const omitUndefined = takeBoolean(config, ["omitUndefined"], state, basePath);
   const forwardEnums = takeBoolean(config, ["enableForwardCompatibleEnums"], state, basePath);
@@ -2538,6 +2593,18 @@ function mapCommonConfig(language, config, state, client, generation, packageCon
   if (packagePath !== void 0) generation.layout = { packagePath };
   mapDependencies(config, state, packageConfig, basePath);
 }
+function mapTypescriptStreams(config, state, basePath) {
+  const responseType = takeEnum(config, ["streamType"], ["wrapper", "web"], state, basePath);
+  const fileResponseType = takeEnum(
+    config,
+    ["fileResponseType"],
+    ["stream", "binary-response"],
+    state,
+    basePath
+  );
+  if (responseType === void 0 && fileResponseType === void 0) return void 0;
+  return { enabled: true, ...compact({ responseType, fileResponseType }) };
+}
 function mapLanguageConfig(language, config, state, packageConfig, basePath) {
   switch (language) {
     case "typescript":
@@ -2571,29 +2638,39 @@ function mapLanguageConfig(language, config, state, packageConfig, basePath) {
   }
 }
 function mapTypescript(config, state, packageConfig, basePath) {
-  mapPackageManifest(config, ["packageJson"], state, packageConfig, basePath);
+  const packageJsonManifest = mapPackageManifest(
+    config,
+    ["packageJson"],
+    state,
+    packageConfig,
+    basePath
+  );
+  const packageJsonPackageManager = packageJsonManifest ? takeString(packageJsonManifest.value, ["packageManager"], state, packageJsonManifest.path) : void 0;
+  const packageManagerAtIndex = packageJsonPackageManager ? packageJsonPackageManager.indexOf("@", packageJsonPackageManager.startsWith("@") ? 1 : 0) : -1;
+  const packageManagerVersionPart = packageManagerAtIndex >= 0 ? packageJsonPackageManager?.slice(packageManagerAtIndex + 1).split("+")[0] : void 0;
+  const packageManagerVersion = packageManagerVersionPart || void 0;
   const serdeLayer = takeBoolean(config, ["serdeLayer"], state, basePath);
   const noSerdeLayer = takeBoolean(config, ["noSerdeLayer"], state, basePath);
   const fetchSupport = takeEnum(config, ["fetchSupport"], ["native"], state, basePath);
+  const namingObject = takeObject(config, ["naming"], state, basePath);
+  const nestedNamespace = namingObject ? takeString(namingObject.value, ["namespace"], state, namingObject.path) : void 0;
   return compact({
     typescriptVersion: takeString(config, ["typescriptVersion"], state, basePath),
     zodVersion: takeString(config, ["zodVersion"], state, basePath),
     packageManager: takeEnum(config, ["packageManager"], ["pnpm", "yarn"], state, basePath),
+    packageManagerVersion,
     testFramework: takeEnum(config, ["testFramework"], ["jest", "vitest"], state, basePath),
     httpClient: fetchSupport === "native" ? { name: "fetch" } : void 0,
     bundle: takeBoolean(config, ["bundle"], state, basePath),
     exportClassDefault: takeBoolean(config, ["exportClassDefault"], state, basePath),
-    namespaceExportName: takeString(
-      config,
-      ["namespaceExportName", "namespaceExport"],
-      state,
-      basePath
-    ),
+    namespaceExportName: takeString(config, ["namespaceExportName", "namespaceExport"], state, basePath) ?? nestedNamespace,
+    consolidateTypeFiles: takeBoolean(config, ["consolidateTypeFiles"], state, basePath),
     allowCustomFetcher: takeBoolean(config, ["allowCustomFetcher"], state, basePath),
     useBrandedStringAliases: takeBoolean(config, ["useBrandedStringAliases"], state, basePath),
     useLegacyExports: takeBoolean(config, ["useLegacyExports"], state, basePath),
     useBigInt: takeBoolean(config, ["useBigInt"], state, basePath),
-    serdeLayer: serdeLayer ?? (noSerdeLayer === void 0 ? void 0 : !noSerdeLayer)
+    serdeLayer: serdeLayer ?? (noSerdeLayer === void 0 ? void 0 : !noSerdeLayer),
+    esmOnly: takeBoolean(config, ["esmOnly"], state, basePath)
   });
 }
 function mapPython(config, state, packageConfig, basePath) {
@@ -2704,7 +2781,8 @@ function mapCsharp(config, state, packageConfig, basePath) {
   });
 }
 function mapPhp(config, state, packageConfig, basePath) {
-  mapPackageManifest(config, ["composerJson"], state, packageConfig, basePath);
+  const manifest = mapPackageManifest(config, ["composerJson"], state, packageConfig, basePath);
+  if (manifest) mapComposerRequirements(manifest, state, packageConfig);
   const packageName = takeString(config, ["packageName"], state, basePath);
   if (packageName !== void 0) packageConfig.packageName = packageName;
   return compact({
@@ -2712,6 +2790,20 @@ function mapPhp(config, state, packageConfig, basePath) {
     generateClientInterfaces: takeBoolean(config, ["generateClientInterfaces"], state, basePath)
   });
 }
+function mapComposerRequirements(manifest, state, packageConfig) {
+  const fields = [
+    ["require", "extraDependencies"],
+    ["require-dev", "extraDevDependencies"]
+  ];
+  for (const [composerField, packageField] of fields) {
+    const located = takeObject(manifest.value, [composerField], state, manifest.path);
+    if (!located) continue;
+    const dependencies = Object.entries(located.value).flatMap(
+      ([name, dependency]) => mapDependency(name, dependency, state, [...located.path, name])
+    );
+    if (dependencies.length) packageConfig[packageField] = dependencies;
+  }
+}
 function mapRuby(config, state, packageConfig, basePath) {
   const moduleName = takeString(config, ["moduleName"], state, basePath);
   if (moduleName !== void 0) packageConfig.moduleName = moduleName;
@@ -2881,28 +2973,52 @@ function takeCustomSections(value, language, activeLanguages, state, basePath) {
 }
 function mapPackageManifest(config, aliases, state, packageConfig, basePath) {
   const manifest = takeObject(config, aliases, state, basePath);
-  if (!manifest) return;
+  if (!manifest) return void 0;
   const packageName = takeString(manifest.value, ["name"], state, manifest.path);
   const description = takeString(manifest.value, ["description"], state, manifest.path);
+  const keywords = takeStringArray(manifest.value, ["keywords"], state, manifest.path);
   const license = takeString(manifest.value, ["license"], state, manifest.path);
   const author = takeObject(manifest.value, ["author"], state, manifest.path);
   const authorName = author ? takeString(author.value, ["name"], state, author.path) : void 0;
-  const authors = authorName && author ? [
-    compact({
-      name: authorName,
-      email: takeString(author.value, ["email"], state, author.path),
-      url: takeString(author.value, ["url"], state, author.path)
-    })
-  ] : void 0;
+  const authors = [
+    ...authorName && author ? [
+      compact({
+        name: authorName,
+        email: takeString(author.value, ["email"], state, author.path),
+        url: takeString(author.value, ["url"], state, author.path)
+      })
+    ] : [],
+    ...takeManifestAuthors(manifest, state)
+  ];
   Object.assign(
     packageConfig,
     compact({
       packageName,
       description,
-      authors,
+      homepage: takeString(manifest.value, ["homepage"], state, manifest.path),
+      keywords,
+      authors: authors.length ? authors : void 0,
       license: license ? { type: license } : void 0
     })
   );
+  return manifest;
+}
+function takeManifestAuthors(manifest, state) {
+  const located = locate(manifest.value, ["authors"], manifest.path);
+  if (!located || !Array.isArray(located.value)) return [];
+  return located.value.flatMap((entry, index) => {
+    if (!isObject(entry)) return [];
+    const path = [...located.path, index];
+    const name = takeString(entry, ["name"], state, path);
+    if (!name) return [];
+    return [
+      compact({
+        name,
+        email: takeString(entry, ["email"], state, path),
+        url: takeString(entry, ["url"], state, path)
+      })
+    ];
+  });
 }
 function takePythonAdditionalInitExports(config, state, basePath) {
   const located = locate(config, ["additionalInitExports"], basePath);