@postman/sdk-config 0.11.0 → 0.13.0

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

@@ -432,6 +432,12 @@ var dependencySchema = z.strictObject({
 }).refine(({ source, version }) => source !== void 0 || version !== void 0, {
   message: "dependency must define a version or a source"
 });
+var bugsSchema = z.strictObject({
+  url: nonEmptyStringSchema.optional().describe("The issue tracker URL."),
+  email: nonEmptyStringSchema.optional().describe("The address for reporting issues.")
+}).refine(({ url, email }) => url !== void 0 || email !== void 0, {
+  message: "bugs must define a url or an email"
+});
 var projectUrlSchema = z.strictObject({
   label: nonEmptyStringSchema.describe("The label displayed for the project link."),
   url: nonEmptyStringSchema.describe("The project link URL.")
@@ -446,6 +452,7 @@ var packageConfigSchema = z.strictObject({
   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."),
+  bugs: bugsSchema.optional().describe("Where issues with the package are reported."),
   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."),
@@ -501,7 +508,10 @@ var cliDistributionConfigSchema = z.strictObject({
     "A GitHub App used to mint short-lived tokens for every channel without its own tokenSecretName."
   ),
   homebrew: cliDistributionHomebrewSchema.optional().describe("Publishes a Homebrew formula to a tap repository on each tagged release."),
-  scoop: cliDistributionScoopSchema.optional().describe("Publishes a Scoop manifest to a bucket repository on each tagged release.")
+  scoop: cliDistributionScoopSchema.optional().describe("Publishes a Scoop manifest to a bucket repository on each tagged release."),
+  githubAttestations: z.union([z.literal("auto"), z.boolean()], { error: 'must be "auto", true, or false' }).optional().describe(
+    'Whether the generated release workflow attests build provenance. "auto" (the generator default) attests only on public repositories; true always attests, for private repositories on GitHub Enterprise Cloud; false omits the attestation step and its permissions.'
+  )
 }).superRefine((distribution, context) => {
   if (distribution.homebrew !== void 0 || distribution.scoop !== void 0) {
     return;
@@ -514,6 +524,9 @@ var cliDistributionConfigSchema = z.strictObject({
     });
     return;
   }
+  if (distribution.githubAttestations !== void 0) {
+    return;
+  }
   context.addIssue({
     code: "custom",
     message: "distribution must configure at least one channel: homebrew or scoop"
@@ -525,14 +538,17 @@ var CLI_DISTRIBUTION_NON_RELEASE_MODE_CODE = "CLI_DISTRIBUTION_NON_RELEASE_MODE"
 var nonReleaseGithubModes = /* @__PURE__ */ new Set(["pull-request", "push", "commit"]);
 function cliDistributionModeDiagnostic(output, outputPath) {
   const mode = output?.github?.mode;
-  if (output?.distribution === void 0 || mode === void 0 || !nonReleaseGithubModes.has(mode)) {
+  const distribution = output?.distribution;
+  if (distribution === void 0 || mode === void 0 || !nonReleaseGithubModes.has(mode)) {
     return void 0;
   }
+  const hasChannel = distribution.homebrew !== void 0 || distribution.scoop !== void 0;
+  const consequence = hasChannel ? "Homebrew and Scoop publish only after a semantic-version tag is pushed to the repository." : "the release workflow, including its githubAttestations setting, runs only after a semantic-version tag is pushed to the repository.";
   return {
     code: CLI_DISTRIBUTION_NON_RELEASE_MODE_CODE,
     severity: "warning",
     path: [...outputPath, "github", "mode"],
-    reason: `GitHub mode "${mode}" does not create a release tag, so Homebrew and Scoop publish only after a semantic-version tag is pushed to the repository.`,
+    reason: `GitHub mode "${mode}" does not create a release tag, so ${consequence}`,
     suggestedAction: 'Use mode "release" or "commit-and-release", or push a version tag after merging generated changes.'
   };
 }
@@ -967,6 +983,7 @@ var DISTRIBUTION_KEYS = {
   homebrew: { tap: "tap", formula: "formula", tokenEnvironmentVariable: "tokenSecretName" },
   scoop: { bucket: "bucket", tokenEnvironmentVariable: "tokenSecretName" }
 };
+var DISTRIBUTION_SCALAR_KEYS = ["githubAttestations"];
 function mapCliDistribution(config, state, basePath, targetIndex) {
   if (!Object.hasOwn(config, "distribution")) return;
   const raw = config.distribution;
@@ -1013,6 +1030,11 @@ function translateDistribution(distribution, path) {
     }
     value[block] = translatedBlock;
   }
+  for (const key of DISTRIBUTION_SCALAR_KEYS) {
+    if (!Object.hasOwn(distribution, key)) continue;
+    value[key] = distribution[key];
+    consumedPaths.push([...path, key]);
+  }
   return { value, consumedPaths, legacyKeys };
 }
 function invalidDistributionDiagnostic(issue, path, legacyKeys, targetIndex) {
@@ -1152,6 +1174,7 @@ function mapOutput(generator, language, index) {
         output.publishV2,
         rawOutput,
         language,
+        "zip",
         [...outputPath, "publishV2"],
         state,
         index
@@ -1173,6 +1196,7 @@ function mapOutput(generator, language, index) {
         output.registryOverrides,
         rawOutput,
         language,
+        "zip",
         [...outputPath, "registryOverrides"],
         state,
         index
@@ -1200,7 +1224,14 @@ function mapOutput(generator, language, index) {
   }
 }
 function sanitizeNormalizedOutput(output, rawOutput, state, index) {
-  const publish = output.publish ? sanitizePublishConfig(output.publish, output.publish, rawOutput, state, index) : void 0;
+  const publish = output.publish ? sanitizePublishConfig(
+    output.publish,
+    output.publish,
+    rawOutput,
+    output.delivery,
+    state,
+    index
+  ) : void 0;
   const publishShape = publish ? { publish } : {};
   if (output.delivery !== "github") return { ...output, ...publishShape };
   const { credentials, ...github } = output.github;
@@ -1227,12 +1258,21 @@ function githubOutput(value, publishInfo, rawOutput, language, sourcePath, state
     );
   consume(state, [...sourcePath, "owner"]);
   consume(state, [...sourcePath, "repo"]);
-  const publication = publishInfo ? mapPublication(publishInfo, rawOutput, language, [...sourcePath, "publishInfo"], state, index) : void 0;
+  const publication = publishInfo ? mapPublication(
+    publishInfo,
+    rawOutput,
+    language,
+    "github",
+    [...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"]);
+  if (value.workflows === true) consume(state, [...sourcePath, "workflows"]);
   if (stringValue(value.host)) consume(state, [...sourcePath, "host"]);
   if (stringValue(value.branch)) consume(state, [...sourcePath, "branch"]);
   consumeCredentialObject(value.credentials, [...sourcePath, "credentials"], state);
@@ -1319,7 +1359,7 @@ function reviewerNames(value, expectedType, sourcePath, state) {
   });
   return names.length ? names : void 0;
 }
-function mapPublication(value, rawOutput, language, sourcePath, state, index) {
+function mapPublication(value, rawOutput, language, delivery, sourcePath, state, index) {
   if (!isObject(value))
     fail(
       "FERN_PUBLICATION_INVALID",
@@ -1340,6 +1380,7 @@ function mapPublication(value, rawOutput, language, sourcePath, state, index) {
     compact({ registry, url: registryUrl }),
     nested,
     rawOutput,
+    delivery,
     state,
     index
   );
@@ -1360,7 +1401,7 @@ function mapPublication(value, rawOutput, language, sourcePath, state, index) {
     ...packageName || Object.keys(metadata).length ? { package: { ...optional("packageName", packageName), ...metadata } } : {}
   };
 }
-function sanitizePublishConfig(publish, resolvedPublication, rawOutput, state, index) {
+function sanitizePublishConfig(publish, resolvedPublication, rawOutput, delivery, state, index) {
   const rawPublication = rawOutput?.location === publish.registry ? rawOutput : void 0;
   const rawPath = ["group", "generators", index, "output"];
   if (publish.registry === "npm" || publish.registry === "crates") {
@@ -1456,6 +1497,33 @@ function sanitizePublishConfig(publish, resolvedPublication, rawOutput, state, i
       signature
     });
   }
+  if (publish.registry === "nuget" || publish.registry === "rubygems") {
+    const apiKey = mapApiKeyExpression(
+      publish.registry,
+      rawPublication,
+      resolvedPublication,
+      rawPath,
+      state,
+      index,
+      fernDefaultApiKey(publish.registry, rawOutput, delivery)
+    );
+    warnForUnexpectedCredentialFields(
+      rawPublication,
+      resolvedPublication,
+      ["apiKey"],
+      rawPath,
+      state,
+      index
+    );
+    return compact({
+      registry: publish.registry,
+      url: publish.url,
+      releaseBranch: publish.releaseBranch,
+      tolerateRepublish: publish.tolerateRepublish,
+      apiKey,
+      trustedPublishing: usesTrustedPublishing(rawPublication) || void 0
+    });
+  }
   warnForUnrepresentableCredentials(rawPublication, resolvedPublication, rawPath, state, index);
   return compact({
     registry: publish.registry,
@@ -1464,11 +1532,19 @@ function sanitizePublishConfig(publish, resolvedPublication, rawOutput, state, i
     tolerateRepublish: publish.tolerateRepublish
   });
 }
-function mapLegacyPublication(value, rawOutput, language, sourcePath, state, index) {
+function mapLegacyPublication(value, rawOutput, language, delivery, sourcePath, state, index) {
   const registry = defaultRegistry(language, sourcePath, index);
   const overrides = isObject(value) ? value : {};
   const override = isObject(overrides[registry]) ? overrides[registry] : {};
-  return mapPublication(override, rawOutput, language, [...sourcePath, registry], state, index);
+  return mapPublication(
+    override,
+    rawOutput,
+    language,
+    delivery,
+    [...sourcePath, registry],
+    state,
+    index
+  );
 }
 function mapCredentialExpression(rawPublication, resolvedPublication, field, rawPath, state, index) {
   const rawValue = rawPublication?.[field];
@@ -1483,6 +1559,45 @@ function mapCredentialExpression(rawPublication, resolvedPublication, field, raw
   }
   return void 0;
 }
+var TRUSTED_PUBLISHING_VALUES = /* @__PURE__ */ new Set(["OIDC", "<USE_OIDC>"]);
+function rawApiKeyValue(raw) {
+  return raw?.apiKey ?? raw?.["api-key"];
+}
+function usesTrustedPublishing(rawPublication) {
+  const rawValue = rawApiKeyValue(rawPublication);
+  return typeof rawValue === "string" && TRUSTED_PUBLISHING_VALUES.has(rawValue);
+}
+function mapApiKeyExpression(registry, rawPublication, resolvedPublication, rawPath, state, index, defaultSecretName) {
+  const rawValue = rawApiKeyValue(rawPublication);
+  if (isEnvironmentExpression(rawValue)) return rawValue;
+  if (usesTrustedPublishing(rawPublication)) return void 0;
+  if (defaultSecretName !== void 0) return defaultSecretName;
+  if (rawValue === void 0 && !hasResolvedCredential(resolvedPublication, "apiKey")) {
+    return void 0;
+  }
+  addCredentialDiagnostic(
+    state,
+    [...rawPath, "apiKey"],
+    ["targets", index, "output", "publish", "apiKey"],
+    apiKeyOmissionReason(registry)
+  );
+  return void 0;
+}
+function apiKeyOmissionReason(registry) {
+  const label = registry === "nuget" ? "NuGet" : "RubyGems";
+  return `Fern ${label} apiKey is not an exact environment expression naming a secret`;
+}
+var FERN_DEFAULT_NUGET_API_KEY = "${NUGET_API_TOKEN}";
+function fernDefaultApiKey(registry, rawOutput, delivery) {
+  if (registry !== "nuget" || delivery !== "github" || rawOutput?.location !== "nuget") {
+    return void 0;
+  }
+  const rawApiKey = rawApiKeyValue(rawOutput);
+  if (typeof rawApiKey === "string" && TRUSTED_PUBLISHING_VALUES.has(rawApiKey)) {
+    return void 0;
+  }
+  return FERN_DEFAULT_NUGET_API_KEY;
+}
 function mapPypiCredentialExpressions(rawPublication, resolvedPublication, rawPath, state, index) {
   const rawToken = rawPublication?.token;
   if (isEnvironmentExpression(rawToken)) {
@@ -2186,6 +2301,29 @@ var mavenSignatureSchema = z.strictObject({
     "The armored secret key, or an environment expression that resolves to it."
   )
 });
+function apiKeySecretSchema(registry, example) {
+  return nonEmptyStringSchema.regex(
+    /^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/,
+    `${registry} apiKey must be an environment expression naming a secret, such as ${example}`
+  );
+}
+function apiKeySecretDescription(registry, example) {
+  return `An environment expression naming the repository secret that the generated release workflow reads the ${registry} API key from, such as ${example}. This is a secret name, never the key itself.`;
+}
+function trustedPublishingSchema(registry) {
+  return z.boolean().optional().describe(
+    `Whether ${registry} publication uses trusted publishing (OIDC) instead of an API key secret.`
+  );
+}
+function refineApiKeyAgainstTrustedPublishing(publish, context) {
+  if (publish.trustedPublishing === true && publish.apiKey !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "apiKey must be omitted when trustedPublishing is true",
+      path: ["apiKey"]
+    });
+  }
+}
 var commonPublishShape = {
   url: nonEmptyStringSchema.optional().describe("A custom package registry URL."),
   releaseBranch: nonEmptyStringSchema.optional().describe("The branch used by generated package release workflows."),
@@ -2221,12 +2359,16 @@ var sdkConfigV1PublishConfigSchema = z.discriminatedUnion("registry", [
   }),
   z.strictObject({
     registry: z.literal("nuget").describe("Publishes the package to a NuGet-compatible registry."),
+    apiKey: apiKeySecretSchema("NuGet", "${NUGET_API_KEY}").optional().describe(apiKeySecretDescription("NuGet", "${NUGET_API_KEY}")),
+    trustedPublishing: trustedPublishingSchema("NuGet"),
     ...commonPublishShape
-  }),
+  }).superRefine(refineApiKeyAgainstTrustedPublishing),
   z.strictObject({
     registry: z.literal("rubygems").describe("Publishes the package to a RubyGems-compatible registry."),
+    apiKey: apiKeySecretSchema("RubyGems", "${RUBYGEMS_API_KEY}").optional().describe(apiKeySecretDescription("RubyGems", "${RUBYGEMS_API_KEY}")),
+    trustedPublishing: trustedPublishingSchema("RubyGems"),
     ...commonPublishShape
-  }),
+  }).superRefine(refineApiKeyAgainstTrustedPublishing),
   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."),
@@ -2284,7 +2426,7 @@ var sdkConfigV1OutputConfigSchema = z.discriminatedUnion(
 );
 var cliDistributionShape = {
   distribution: cliDistributionConfigSchema.optional().describe(
-    "CLI release channels published by the generated release workflow; credentials are GitHub Actions secret names."
+    "CLI release channels and build attestation settings for the generated release workflow; credentials are GitHub Actions secret names."
   )
 };
 function rejectDistributionWithoutGithub(output, context) {
@@ -2330,6 +2472,9 @@ var apiImportSettingsSchema = z.strictObject({
   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."),
+  inferDiscriminatedUnionBaseProperties: z.boolean().optional().describe(
+    "Whether properties every discriminated-union variant shares are lifted onto the union."
+  ),
   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.")
@@ -2428,7 +2573,7 @@ var packageScriptSchema = z.strictObject({
   command: nonEmptyStringSchema.describe("The command executed by the package script.")
 });
 var httpClientSchema = z.strictObject({
-  name: z.enum(["axios", "fetch"]).describe("The HTTP client used by generated TypeScript code.")
+  name: z.enum(["axios", "fetch", "node-fetch"]).describe("The HTTP client used by generated TypeScript code.")
 });
 var typescriptGenerationConfigSchema = z.strictObject({
   typescriptVersion: nonEmptyStringSchema.optional().describe("The TypeScript version used by the generated project."),
@@ -2444,6 +2589,37 @@ var typescriptGenerationConfigSchema = z.strictObject({
   /** Name of the top-level namespace export emitted by Fern-compatible TypeScript SDKs. */
   namespaceExportName: nonEmptyStringSchema.optional().describe("The top-level namespace export name."),
   consolidateTypeFiles: z.boolean().optional().describe("Whether generated types are consolidated into fewer source files."),
+  formDataSupport: z.enum(["Node16", "Node18"]).optional().describe(
+    "The multipart form-data implementation: Node16 uses the form-data packages, Node18 uses the platform FormData."
+  ),
+  allowExtraFields: z.boolean().optional().describe(
+    "Whether response parsing keeps unrecognized object keys and accepts unrecognized union members and enum values."
+  ),
+  generateSubpackageExports: z.boolean().optional().describe(
+    "Whether the package manifest exports each subpackage client as its own entry point."
+  ),
+  exportAllRequestsAtRoot: z.boolean().optional().describe("Whether every request type is also exported from the package root."),
+  generateEndpointMetadata: z.boolean().optional().describe("Whether generated clients expose metadata for each endpoint."),
+  outputEsm: z.boolean().optional().describe(
+    "Whether the package is marked as an ES module while still shipping its CommonJS build."
+  ),
+  neverThrowErrors: z.boolean().optional().describe(
+    "Whether client methods return a wrapped response instead of throwing on a non-2xx status."
+  ),
+  includeOtherInUnionTypes: z.boolean().optional().describe("Whether union types gain a member for variants the SDK does not recognize."),
+  includeUtilsOnUnionMembers: z.boolean().optional().describe("Whether helper utilities are generated on each member of a union type."),
+  omitFernHeaders: z.boolean().optional().describe("Whether requests omit the SDK identification headers and the User-Agent header."),
+  linter: z.enum(["biome", "oxlint", "none"]).optional().describe("The linter configured in the generated project."),
+  formatter: z.enum(["prettier", "biome", "oxfmt", "none"]).optional().describe("The formatter configured in the generated project."),
+  exports: jsonObjectSchema.optional().describe(
+    "package.json exports entries, keyed by subpath, applied over the generated exports. Each subpath replaces the generated one."
+  ),
+  files: z.array(nonEmptyStringSchema).optional().describe("package.json files entries, listed ahead of the generated ones."),
+  engines: z.record(nonEmptyStringSchema, nonEmptyStringSchema).optional().describe("package.json engines version ranges, keyed by engine name such as node."),
+  lintStaged: z.record(nonEmptyStringSchema, z.array(nonEmptyStringSchema).min(1)).optional().describe("lint-staged commands to run, keyed by file glob."),
+  browser: z.record(nonEmptyStringSchema, z.union([z.boolean(), nonEmptyStringSchema])).optional().describe(
+    "package.json browser field: a module or file is excluded (false) or replaced by another path."
+  ),
   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."),
@@ -2517,7 +2693,7 @@ var pythonGenerationConfigSchema = z.strictObject({
   additionalInitExports: z.array(additionalInitExportSchema).optional().describe("Additional names re-exported from the package initializer.")
 });
 var rubyGenerationConfigSchema = z.strictObject({
-  requirePaths: z.array(nonEmptyStringSchema).optional().describe("Ruby load paths included in the generated gem specification.")
+  requirePaths: z.array(nonEmptyStringSchema).optional().describe("Files the generated entry file loads with `require`.")
 });
 var rustGenerationConfigSchema = z.strictObject({
   /**
@@ -2859,16 +3035,21 @@ function mapFernConfigToSdkConfigV1(input) {
         ...optional("client", clients.targetOverrides[index]),
         ...optional("docs", docs.targetOverrides[index])
       };
-      const targetPackage = { ...invocation.package, ...outputPackage, ...generator.package };
+      const mappedPackage = { ...invocation.package, ...outputPackage, ...generator.package };
       invocation.unsupportedFields.push(
         ...resolveTargetPackage(
-          targetPackage,
+          mappedPackage,
           invocation.packageFallbacks,
           generator,
           output.delivery,
           index
         )
       );
+      const targetPackage = withRustCratesPublishDefaults(mappedPackage, {
+        language,
+        output,
+        generator
+      });
       if (Object.keys(targetPackage).length > 0 || outputPackage || generator.package) {
         target.package = targetPackage;
       }
@@ -2937,6 +3118,21 @@ function mapFernConfigToSdkConfigV1(input) {
     ])
   };
 }
+function withRustCratesPublishDefaults(packageConfig, { language, output, generator }) {
+  if (language !== "rust" || !("publish" in output) || output.publish?.registry !== "crates") {
+    return packageConfig;
+  }
+  const { packageName } = packageConfig;
+  return {
+    ...packageName ? { description: `Rust SDK for ${packageName} generated by Fern` } : {},
+    ...usesCustomLicenseFile(generator) ? {} : { license: { type: "MIT" } },
+    ...packageConfig
+  };
+}
+function usesCustomLicenseFile({ config, raw }) {
+  const metadata = isObject(raw) && isObject(raw.metadata) ? raw.metadata : void 0;
+  return isObject(config) && typeof config.packageLicenseFile === "string" || isObject(metadata?.license);
+}
 function resolveLanguage(generator, index) {
   const language = generator.sdkLanguage ?? generatorLanguages[generator.name];
   if (!language || !isFernLanguage(language)) {
@@ -3075,6 +3271,13 @@ function mapInvocation(generator, language, activeLanguages, index) {
     }
   }
   const docs = mapReadme(generator.readme, language, activeLanguages, state, [...prefix, "readme"]);
+  if (language === "typescript") {
+    const includeApiReference = takeBoolean(config, ["includeApiReference"], state, [
+      ...prefix,
+      "config"
+    ]);
+    if (includeApiReference !== void 0) docs.includeApiReference = includeApiReference;
+  }
   const unsupportedFields = [
     ...state.valueDiagnostics ?? [],
     ...collectUnsupported(config, [...prefix, "config"], state),
@@ -3221,7 +3424,12 @@ 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 directClientName = takeString(
+    config,
+    language === "ruby" ? ["clientName"] : ["clientName", "clientClassName"],
+    state,
+    basePath
+  );
   const nestedClientName = pythonClient ? takeString(pythonClient.value, ["className"], state, pythonClient.path) : typescriptNaming ? takeString(typescriptNaming.value, ["client"], state, typescriptNaming.path) : language === "ruby" ? (
     // Fern's Ruby generator renames the root client class (`Auth0::Management`) with it.
     takeString(config, ["clientModuleName"], state, basePath)
@@ -3255,7 +3463,13 @@ function mapCommonConfig(language, config, state, client, generation, packageCon
   });
   if (Object.keys(naming).length) generation.naming = naming;
   const wireTests = takeBoolean(config, ["enableWireTests", "generateWireTests"], state, basePath);
-  if (wireTests !== void 0) generation.wireTests = { enabled: wireTests };
+  const wireTestsFallback = language === "typescript" ? takeBoolean(config, ["wireTestsFallbackToAutoGeneratedErrorExamples"], state, basePath) : void 0;
+  if (wireTests !== void 0 || wireTestsFallback !== void 0) {
+    generation.wireTests = { enabled: wireTests ?? true };
+    if (wireTestsFallback !== void 0) {
+      generation.wireTests.fallbackToGeneratedErrorExamples = wireTestsFallback;
+    }
+  }
   const webSockets = takeBoolean(
     config,
     ["generateWebSocketClients", "shouldGenerateWebsocketClients", "enableWebsockets"],
@@ -3298,10 +3512,10 @@ function mapTypescriptStreams(config, state, basePath) {
 function mapLanguageConfig(language, config, state, packageConfig, basePath, targetIndex) {
   switch (language) {
     case "typescript":
-      return mapTypescript(config, state, packageConfig, basePath);
+      return mapTypescript(config, state, packageConfig, basePath, true);
     case "mcp":
       return {
-        ...mapTypescript(config, state, packageConfig, basePath),
+        ...mapTypescript(config, state, packageConfig, basePath, false),
         ...mapMcp(config, state, basePath)
       };
     case "python":
@@ -3327,7 +3541,7 @@ function mapLanguageConfig(language, config, state, packageConfig, basePath, tar
       return mapTerraform(config, state, packageConfig, basePath);
   }
 }
-function mapTypescript(config, state, packageConfig, basePath) {
+function mapTypescript(config, state, packageConfig, basePath, sdkTarget) {
   const packageJsonManifest = mapPackageManifest(
     config,
     ["packageJson"],
@@ -3340,18 +3554,74 @@ function mapTypescript(config, state, packageConfig, basePath) {
   const packageManagerVersionPart = packageManagerAtIndex >= 0 ? packageJsonPackageManager?.slice(packageManagerAtIndex + 1).split("+")[0] : void 0;
   const packageManagerVersion = packageManagerVersionPart || void 0;
   if (packageJsonManifest) liftPackageJsonDependencies(packageJsonManifest, state, packageConfig);
+  const manifestOptions = sdkTarget && packageJsonManifest ? mapPackageManifestOptions(packageJsonManifest, state, packageConfig) : {};
   const serdeLayer = takeBoolean(config, ["serdeLayer"], state, basePath);
   const noSerdeLayer = takeBoolean(config, ["noSerdeLayer"], state, basePath);
-  const fetchSupport = takeEnum(config, ["fetchSupport"], ["native"], state, basePath);
+  const fetchSupport = takeEnum(
+    config,
+    ["fetchSupport"],
+    sdkTarget ? ["native", "node-fetch"] : ["native"],
+    state,
+    basePath
+  );
   const namingObject = takeObject(config, ["naming"], state, basePath);
   const nestedNamespace = namingObject ? takeString(namingObject.value, ["namespace"], state, namingObject.path) : void 0;
+  const sdkOnlyOptions = sdkTarget ? {
+    formDataSupport: takeEnum(
+      config,
+      ["formDataSupport"],
+      ["Node16", "Node18"],
+      state,
+      basePath
+    ),
+    allowExtraFields: takeBoolean(config, ["allowExtraFields"], state, basePath),
+    generateSubpackageExports: takeBoolean(
+      config,
+      ["generateSubpackageExports"],
+      state,
+      basePath
+    ),
+    exportAllRequestsAtRoot: takeBoolean(config, ["exportAllRequestsAtRoot"], state, basePath),
+    generateEndpointMetadata: takeBoolean(
+      config,
+      ["generateEndpointMetadata"],
+      state,
+      basePath
+    ),
+    outputEsm: takeBoolean(config, ["outputEsm"], state, basePath),
+    neverThrowErrors: takeBoolean(config, ["neverThrowErrors"], state, basePath),
+    includeOtherInUnionTypes: takeBoolean(
+      config,
+      ["includeOtherInUnionTypes"],
+      state,
+      basePath
+    ),
+    includeUtilsOnUnionMembers: takeBoolean(
+      config,
+      ["includeUtilsOnUnionMembers"],
+      state,
+      basePath
+    ),
+    omitFernHeaders: takeBoolean(config, ["omitFernHeaders"], state, basePath),
+    linter: takeEnum(config, ["linter"], ["biome", "oxlint", "none"], state, basePath),
+    formatter: takeEnum(
+      config,
+      ["formatter"],
+      ["prettier", "biome", "oxfmt", "none"],
+      state,
+      basePath
+    )
+  } : {};
   return compact({
+    ...sdkOnlyOptions,
+    // Only the manifest writes these keys; nothing in sdkOnlyOptions or below shares a name.
+    ...manifestOptions,
     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,
+    httpClient: fetchSupport === void 0 ? void 0 : { name: fetchSupport === "native" ? "fetch" : "node-fetch" },
     bundle: takeBoolean(config, ["bundle"], state, basePath),
     exportClassDefault: takeBoolean(config, ["exportClassDefault"], state, basePath),
     namespaceExportName: takeString(config, ["namespaceExportName", "namespaceExport"], state, basePath) ?? nestedNamespace,
@@ -3748,6 +4018,83 @@ function mapPackageManifest(config, aliases, state, packageConfig, basePath) {
   );
   return manifest;
 }
+function mapPackageManifestOptions(manifest, state, packageConfig) {
+  const bugs = takeManifestBugs(manifest, state);
+  if (bugs) packageConfig.bugs = bugs;
+  const repository = takeManifestRepository(manifest, state);
+  if (repository !== void 0 && packageConfig.repository === void 0) {
+    packageConfig.repository = repository;
+  }
+  const exports = takeObject(manifest.value, ["exports"], state, manifest.path);
+  if (exports) consume(state, exports.path);
+  return compact({
+    exports: exports?.value,
+    scripts: takeManifestScripts(manifest, state),
+    files: takeStringArray(manifest.value, ["files"], state, manifest.path),
+    engines: takeManifestStringRecord(manifest, "engines", state),
+    lintStaged: takeManifestLintStaged(manifest, state),
+    browser: takeManifestBrowser(manifest, state)
+  });
+}
+function takeManifestBugs(manifest, state) {
+  const text = takeString(manifest.value, ["bugs"], state, manifest.path);
+  if (text !== void 0) return { url: text };
+  const located = takeObject(manifest.value, ["bugs"], state, manifest.path);
+  if (!located) return void 0;
+  const url = takeString(located.value, ["url"], state, located.path);
+  const email = takeString(located.value, ["email"], state, located.path);
+  return url === void 0 && email === void 0 ? void 0 : compact({ url, email });
+}
+function takeManifestRepository(manifest, state) {
+  const text = takeString(manifest.value, ["repository"], state, manifest.path);
+  if (text !== void 0) return text;
+  const located = takeObject(manifest.value, ["repository"], state, manifest.path);
+  if (!located) return void 0;
+  const url = takeString(located.value, ["url"], state, located.path);
+  if (url !== void 0) void takeEnum(located.value, ["type"], ["git"], state, located.path);
+  return url;
+}
+function takeManifestScripts(manifest, state) {
+  const located = takeObject(manifest.value, ["scripts"], state, manifest.path);
+  if (!located) return void 0;
+  const scripts = Object.entries(located.value).flatMap(([name, command]) => {
+    if (typeof command !== "string" || !command) return [];
+    consume(state, [...located.path, name]);
+    return [{ name, command }];
+  });
+  return scripts.length ? scripts : void 0;
+}
+function takeManifestStringRecord(manifest, key, state) {
+  const located = takeObject(manifest.value, [key], state, manifest.path);
+  if (!located) return void 0;
+  const entries = Object.entries(located.value).flatMap(([name, value]) => {
+    if (typeof value !== "string" || !value) return [];
+    consume(state, [...located.path, name]);
+    return [[name, value]];
+  });
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
+function takeManifestLintStaged(manifest, state) {
+  const located = takeObject(manifest.value, ["lint-staged"], state, manifest.path);
+  if (!located) return void 0;
+  const entries = Object.entries(located.value).flatMap(([glob, commands]) => {
+    const list = typeof commands === "string" ? [commands] : stringArrayValue(commands);
+    if (!list?.length || list.some((command) => !command)) return [];
+    consume(state, [...located.path, glob]);
+    return [[glob, list]];
+  });
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
+function takeManifestBrowser(manifest, state) {
+  const located = takeObject(manifest.value, ["browser"], state, manifest.path);
+  if (!located) return void 0;
+  const entries = Object.entries(located.value).flatMap(([name, value]) => {
+    if (typeof value !== "boolean" && (typeof value !== "string" || !value)) return [];
+    consume(state, [...located.path, name]);
+    return [[name, value]];
+  });
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
 function takeManifestAuthors(manifest, state) {
   const located = locate(manifest.value, ["authors"], manifest.path);
   if (!located || !Array.isArray(located.value)) return [];