@postman/sdk-config 0.1.0 → 0.2.0

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

@@ -9,6 +9,10 @@ var semver__default = /*#__PURE__*/_interopDefault(semver);
 
 // src/sdk-config-domain/v1/api.ts
 var nonEmptyStringSchema = zod.z.string().min(1);
+var relativePathSchema = nonEmptyStringSchema.refine(
+  (value) => !/^(?:[\\/]|[A-Za-z]:)/.test(value) && !value.split(/[\\/]/).some((segment) => segment === ".."),
+  { message: "must be a relative path without parent directory segments" }
+);
 var exactSemverSchema = zod.z.string().refine(
   (value) => {
     if (value.trim() !== value || !/^\d/.test(value)) {
@@ -195,26 +199,42 @@ var apiConfigSchema = zod.z.strictObject({
 var sdkConfigV1AuthSchemeSchema = authSchemeSchema;
 var sdkConfigV1AuthConfigSchema = authConfigSchema;
 var sdkConfigV1ApiConfigSchema = apiConfigSchema;
+var retryOverrideShape = {
+  enabled: zod.z.boolean().optional(),
+  maxAttempts: zod.z.number().int().min(1).optional(),
+  retryDelayMs: zod.z.number().nonnegative().optional(),
+  maxDelayMs: zod.z.number().nonnegative().optional(),
+  jitterMs: zod.z.number().nonnegative().optional(),
+  backoffFactor: zod.z.number().positive().optional(),
+  statusCodes: zod.z.array(zod.z.number().int().min(100).max(599)).optional(),
+  methods: zod.z.array(nonEmptyStringSchema).optional(),
+  statusCodeProfile: zod.z.enum(["legacy", "recommended"]).optional(),
+  maxRetryAfterDelayMs: zod.z.number().nonnegative().optional()
+};
+function validateRetryDelays({
+  maxDelayMs,
+  retryDelayMs
+}, context) {
+  if (maxDelayMs !== void 0 && retryDelayMs !== void 0 && maxDelayMs < retryDelayMs) {
+    context.addIssue({
+      code: "custom",
+      message: "maxDelayMs must be greater than or equal to retryDelayMs",
+      path: ["maxDelayMs"]
+    });
+  }
+}
+var clientRetryOverrideSchema = zod.z.strictObject(retryOverrideShape).superRefine(validateRetryDelays);
 var retryConfigSchema = zod.z.strictObject({
+  ...retryOverrideShape,
   enabled: zod.z.boolean().default(true),
   maxAttempts: zod.z.number().int().min(1).default(3),
   retryDelayMs: zod.z.number().nonnegative().default(150),
   maxDelayMs: zod.z.number().nonnegative().default(5e3),
   jitterMs: zod.z.number().nonnegative().default(50),
   backoffFactor: zod.z.number().positive().default(2),
-  statusCodes: zod.z.array(zod.z.number().int().min(100).max(599)).optional(),
   methods: zod.z.array(nonEmptyStringSchema).default(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]),
-  statusCodeProfile: zod.z.enum(["legacy", "recommended"]).optional(),
   maxRetryAfterDelayMs: zod.z.number().nonnegative().default(6e4)
-}).superRefine(({ maxDelayMs, retryDelayMs }, context) => {
-  if (maxDelayMs < retryDelayMs) {
-    context.addIssue({
-      code: "custom",
-      message: "maxDelayMs must be greater than or equal to retryDelayMs",
-      path: ["maxDelayMs"]
-    });
-  }
-});
+}).superRefine(validateRetryDelays);
 var constructorParameterSchema = zod.z.strictObject({
   name: nonEmptyStringSchema,
   example: zod.z.string().optional(),
@@ -236,12 +256,12 @@ var tokenRefreshConfigSchema = zod.z.strictObject({
     });
   }
 });
-var clientConfigSchema = zod.z.strictObject({
-  retry: retryConfigSchema.prefault({}),
-  responseHeaders: zod.z.boolean().default(false),
+var clientOverrideShape = {
+  retry: clientRetryOverrideSchema.optional(),
+  responseHeaders: zod.z.boolean().optional(),
   responseValidation: zod.z.boolean().optional(),
-  multiTenant: zod.z.boolean().default(false),
-  additionalConstructorParameters: zod.z.array(constructorParameterSchema).default([]),
+  multiTenant: zod.z.boolean().optional(),
+  additionalConstructorParameters: zod.z.array(constructorParameterSchema).optional(),
   timeoutMs: zod.z.union([zod.z.number().nonnegative(), zod.z.literal("infinity")]).optional(),
   requestParameterStyle: parameterStyleSchema.optional(),
   pathParameterStyle: parameterStyleSchema.optional(),
@@ -249,11 +269,20 @@ var clientConfigSchema = zod.z.strictObject({
   useDefaultRequestParameterValues: zod.z.boolean().optional(),
   respectOptionalRequestBody: zod.z.boolean().optional(),
   tokenRefresh: tokenRefreshConfigSchema.optional()
+};
+var clientConfigOverrideSchema = zod.z.strictObject(clientOverrideShape);
+var clientConfigSchema = zod.z.strictObject({
+  ...clientOverrideShape,
+  retry: retryConfigSchema.prefault({}),
+  responseHeaders: zod.z.boolean().default(false),
+  multiTenant: zod.z.boolean().default(false),
+  additionalConstructorParameters: zod.z.array(constructorParameterSchema).default([])
 });
 
 // src/sdk-config/v1/client.ts
 var sdkConfigV1ClientConfigSchema = clientConfigSchema;
-var goModulePathSchema = nonEmptyStringSchema.regex(
+var sdkConfigV1ClientConfigOverrideSchema = clientConfigOverrideSchema;
+var goModulePathSchema = relativePathSchema.regex(
   /^(?!.*(?:^|\/)\.{1,2}(?:\/|$))[A-Za-z0-9._~-]+(?:\/[A-Za-z0-9._~-]+)+$/,
   "Go module path must be a slash-delimited path using letters, numbers, dots, dashes, underscores, or tildes"
 );
@@ -857,26 +886,32 @@ function finishOutputMapping(mapping, outputMode, sourcePath, state, index) {
   for (const path of collectLeafPaths(outputMode, sourcePath)) {
     if (path[path.length - 1] === "_visit") consume(state, path);
   }
+  const unsupported = collectUnsupported(outputMode, sourcePath, state);
+  const hasCredentials = unsupported.some((diagnostic) => isCredentialPath(diagnostic.path));
   return {
     ...mapping,
-    unsupportedFields: collectUnsupported(outputMode, sourcePath, state).map(
-      (diagnostic) => outputDiagnostic(diagnostic.path, index)
-    )
+    unsupportedFields: [
+      ...hasCredentials ? [
+        {
+          code: "FERN_OUTPUT_CREDENTIAL_UNSUPPORTED",
+          severity: "warning",
+          path: sourcePath,
+          reason: "Fern output credentials and signatures are intentionally excluded from SDK Config v1",
+          suggestedAction: "Provide publishing credentials through the build request or external secret resolution."
+        }
+      ] : [],
+      ...unsupported.filter((diagnostic) => !isCredentialPath(diagnostic.path)).map((diagnostic) => outputDiagnostic(diagnostic.path, index))
+    ]
   };
 }
+function isCredentialPath(path) {
+  const fields = path.filter((part) => typeof part === "string");
+  const field = fields[fields.length - 1];
+  return fields.some((part) => part === "credentials" || part === "signature") || ["apiKey", "keyId", "password", "secretKey", "token", "username"].includes(field ?? "");
+}
 function outputDiagnostic(path, index) {
   const fields = path.filter((part) => typeof part === "string");
   const field = fields[fields.length - 1];
-  const credential = fields.some((part) => part === "credentials" || part === "signature") || ["apiKey", "keyId", "password", "secretKey", "token", "username"].includes(field ?? "");
-  if (credential) {
-    return {
-      code: "FERN_OUTPUT_CREDENTIAL_UNSUPPORTED",
-      severity: "warning",
-      path,
-      reason: "Fern output credentials and signatures are not represented by SDK Config v1",
-      suggestedAction: "Configure publication credentials and signing secrets outside SDK Config."
-    };
-  }
   const guidance = {
     directory: {
       suggestedAction: "Preserve the GitHub output subdirectory outside SDK Config; public v1 has no repository subdirectory field."
@@ -933,8 +968,22 @@ function outputDiagnostic(path, index) {
     suggestedAction: resolvedGuidance?.suggestedAction ?? "Review this output setting and preserve it outside SDK Config when no equivalent exists."
   };
 }
+var namingConfigSchema = zod.z.strictObject({
+  clientName: nonEmptyStringSchema.optional(),
+  exportedClientName: nonEmptyStringSchema.optional(),
+  environmentTypeName: nonEmptyStringSchema.optional(),
+  apiErrorName: nonEmptyStringSchema.optional(),
+  baseErrorName: nonEmptyStringSchema.optional(),
+  pagerName: nonEmptyStringSchema.optional(),
+  /** Apply Fern's initialism-aware casing rules when deriving generated identifiers. */
+  smartCasing: zod.z.boolean().optional(),
+  /** Preserve a word boundary after digits when Fern smart casing is enabled. */
+  smartCasingDigitWordBoundary: zod.z.boolean().optional()
+});
+
+// src/sdk-config/v1/generation.ts
 var customerGenerationAssetSchema = zod.z.discriminatedUnion("type", [
-  zod.z.strictObject({ type: zod.z.literal("path"), location: nonEmptyStringSchema }),
+  zod.z.strictObject({ type: zod.z.literal("path"), location: relativePathSchema }),
   zod.z.strictObject({ type: zod.z.literal("url"), location: nonEmptyStringSchema })
 ]);
 var hookDependencySchema = zod.z.strictObject({
@@ -955,7 +1004,7 @@ var customCodeConfigSchema = zod.z.strictObject({
   protectedFiles: zod.z.array(nonEmptyStringSchema).optional()
 });
 var workflowConfigSchema = zod.z.strictObject({
-  path: nonEmptyStringSchema,
+  path: relativePathSchema,
   outputName: nonEmptyStringSchema.optional()
 });
 var analyticsHeaderSchema = zod.z.union([
@@ -999,14 +1048,6 @@ var streamsSchema = zod.z.strictObject({
   fileResponseType: zod.z.enum(["stream", "binary-response"]).optional(),
   defaultChunkSizeBytes: zod.z.number().int().positive().optional()
 });
-var namingConfigSchema = zod.z.strictObject({
-  clientName: nonEmptyStringSchema.optional(),
-  exportedClientName: nonEmptyStringSchema.optional(),
-  environmentTypeName: nonEmptyStringSchema.optional(),
-  apiErrorName: nonEmptyStringSchema.optional(),
-  baseErrorName: nonEmptyStringSchema.optional(),
-  pagerName: nonEmptyStringSchema.optional()
-});
 var layoutConfigSchema = zod.z.strictObject({
   outputDirectory: zod.z.enum(["project-root", "source-root"]).optional(),
   packagePath: nonEmptyStringSchema.optional()
@@ -1017,22 +1058,22 @@ var serializationConfigSchema = zod.z.strictObject({
   inlineTypes: zod.z.boolean().optional(),
   omitUndefined: zod.z.boolean().optional()
 });
-var sdkConfigV1GenerationConfigSchema = zod.z.strictObject({
-  includeWatermark: zod.z.boolean().default(false),
-  ai: zod.z.boolean().default(false),
+var generationConfigOverrideShape = {
+  includeWatermark: zod.z.boolean().optional(),
+  ai: zod.z.boolean().optional(),
   includeOptionalSnippetParameters: zod.z.boolean().optional(),
-  buildAllModels: zod.z.boolean().default(false),
-  inferServiceNames: zod.z.boolean().default(false),
-  includeDeprecatedOperations: zod.z.boolean().default(true),
-  multipleResponses: zod.z.boolean().default(false),
-  devContainer: zod.z.boolean().default(false),
-  allowMockClient: zod.z.boolean().default(false),
+  buildAllModels: zod.z.boolean().optional(),
+  inferServiceNames: zod.z.boolean().optional(),
+  includeDeprecatedOperations: zod.z.boolean().optional(),
+  multipleResponses: zod.z.boolean().optional(),
+  devContainer: zod.z.boolean().optional(),
+  allowMockClient: zod.z.boolean().optional(),
   ignoreFiles: zod.z.array(nonEmptyStringSchema).optional(),
   reservedKeywords: zod.z.array(nonEmptyStringSchema).optional(),
   hooks: hooksConfigSchema.optional(),
   customCode: customCodeConfigSchema.optional(),
   workflows: zod.z.array(workflowConfigSchema).optional(),
-  customQueryPaths: zod.z.array(nonEmptyStringSchema).optional(),
+  customQueryPaths: zod.z.array(relativePathSchema).optional(),
   analytics: analyticsConfigSchema.optional(),
   wireTests: wireTestsSchema.optional(),
   unitTests: unitTestsSchema.optional(),
@@ -1041,7 +1082,30 @@ var sdkConfigV1GenerationConfigSchema = zod.z.strictObject({
   naming: namingConfigSchema.optional(),
   layout: layoutConfigSchema.optional(),
   serialization: serializationConfigSchema.optional()
-});
+};
+var sdkConfigV1GenerationConfigOverrideSchema = zod.z.strictObject(
+  generationConfigOverrideShape
+);
+var sdkConfigV1GenerationConfigSchema = zod.z.strictObject({
+  ...generationConfigOverrideShape,
+  includeWatermark: zod.z.boolean().default(false),
+  ai: zod.z.boolean().default(false),
+  buildAllModels: zod.z.boolean().default(false),
+  inferServiceNames: zod.z.boolean().default(false),
+  includeDeprecatedOperations: zod.z.boolean().default(true),
+  multipleResponses: zod.z.boolean().default(false),
+  devContainer: zod.z.boolean().default(false),
+  allowMockClient: zod.z.boolean().default(false)
+});
+var commonGenerationKeys = new Set(Object.keys(generationConfigOverrideShape));
+function splitSdkConfigV1TargetGeneration(generation) {
+  const common = {};
+  const language = {};
+  for (const [key, value] of Object.entries(generation ?? {})) {
+    (commonGenerationKeys.has(key) ? common : language)[key] = value;
+  }
+  return { common, language };
+}
 var sdkConfigV1PublishRegistrySchema = zod.z.enum([
   "npm",
   "pypi",
@@ -1103,6 +1167,64 @@ var sdkConfigV1OutputConfigSchema = zod.z.discriminatedUnion(
 // src/sdk-config/v1/package.ts
 var sdkConfigV1DependencySchema = dependencySchema;
 var sdkConfigV1PackageConfigSchema = packageConfigSchema;
+var apiImportSettingsSchema = zod.z.strictObject({
+  respectNullableSchemas: zod.z.boolean().optional(),
+  titleAsSchemaName: zod.z.boolean().optional(),
+  coerceEnumsToLiterals: zod.z.boolean().optional(),
+  idiomaticRequestNames: zod.z.boolean().optional(),
+  wrapReferencesToNullableInOptional: zod.z.boolean().optional(),
+  coerceOptionalSchemasToNullable: zod.z.boolean().optional(),
+  pathParameterOrder: zod.z.enum(["url-order", "spec-order"]).optional(),
+  onlyIncludeReferencedSchemas: zod.z.boolean().optional(),
+  objectQueryParameters: zod.z.boolean().optional(),
+  typeDatesAsStrings: zod.z.boolean().optional(),
+  groupMultiApiEnvironments: zod.z.boolean().optional(),
+  defaultIntegerFormat: zod.z.enum(["int32", "int64", "uint32", "uint64"]).optional()
+});
+var sourceSpecTypeSchema = zod.z.enum([
+  "openapi",
+  "swagger",
+  "postman",
+  "asyncapi",
+  "graphql"
+]);
+
+// src/sdk-config/v1/source.ts
+var sourceSpecShape = {
+  id: nonEmptyStringSchema,
+  type: sourceSpecTypeSchema,
+  name: nonEmptyStringSchema.optional(),
+  namespace: nonEmptyStringSchema.optional(),
+  apiImportSettings: apiImportSettingsSchema.optional(),
+  overlays: zod.z.array(relativePathSchema).optional(),
+  overrides: zod.z.array(relativePathSchema).optional()
+};
+var sdkConfigV1SourceSpecSchema = zod.z.union(
+  [
+    zod.z.strictObject({ ...sourceSpecShape, path: relativePathSchema }),
+    zod.z.strictObject({
+      ...sourceSpecShape,
+      url: zod.z.url({ protocol: /^https?$/ })
+    })
+  ],
+  { error: "source spec must contain exactly one locator: path or HTTP(S) url" }
+);
+var sdkConfigV1SourceConfigSchema = zod.z.strictObject({
+  specs: zod.z.array(sdkConfigV1SourceSpecSchema).min(1, "source.specs must contain at least one source spec"),
+  apiImportSettings: apiImportSettingsSchema.optional()
+}).superRefine(({ specs }, context) => {
+  const seenIds = /* @__PURE__ */ new Set();
+  specs.forEach(({ id }, index) => {
+    if (seenIds.has(id)) {
+      context.addIssue({
+        code: "custom",
+        message: `source spec id "${id}" must be unique`,
+        path: ["specs", index, "id"]
+      });
+    }
+    seenIds.add(id);
+  });
+});
 var cliGenerationConfigSchema = zod.z.strictObject({
   paginationParameters: zod.z.array(nonEmptyStringSchema).optional(),
   skills: zod.z.boolean().optional()
@@ -1164,6 +1286,8 @@ var typescriptGenerationConfigSchema = zod.z.strictObject({
   namingStrategy: zod.z.enum(["base", "originalPropertyNames"]).optional(),
   bundle: zod.z.boolean().optional(),
   exportClassDefault: zod.z.boolean().optional(),
+  /** Name of the top-level namespace export emitted by Fern-compatible TypeScript SDKs. */
+  namespaceExportName: nonEmptyStringSchema.optional(),
   allowCustomFetcher: zod.z.boolean().optional(),
   useBrandedStringAliases: zod.z.boolean().optional(),
   useLegacyExports: zod.z.boolean().optional(),
@@ -1268,73 +1392,75 @@ var targetOverrideShape = {
   generatorVersion: exactSemverSchema.optional(),
   sdkName: nonEmptyStringSchema.optional(),
   sdkVersion: nonEmptyStringSchema.optional(),
+  client: sdkConfigV1ClientConfigOverrideSchema.optional(),
+  docs: sdkConfigV1DocsConfigSchema.optional(),
   package: sdkConfigV1PackageConfigSchema.optional(),
   output: sdkConfigV1OutputConfigSchema.optional()
 };
 var sdkConfigV1TargetSchema = zod.z.discriminatedUnion("language", [
   zod.z.strictObject({
     language: zod.z.literal("typescript"),
-    generation: typescriptGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(typescriptGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("python"),
-    generation: pythonGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(pythonGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("java"),
-    generation: javaGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(javaGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("kotlin"),
-    generation: kotlinGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(kotlinGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("go"),
-    generation: goGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(goGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("csharp"),
-    generation: csharpGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(csharpGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("php"),
-    generation: phpGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(phpGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("ruby"),
-    generation: rubyGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(rubyGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("rust"),
-    generation: rustGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(rustGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("swift"),
-    generation: swiftGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(swiftGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("cli"),
-    generation: cliGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(cliGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("mcp"),
-    generation: mcpGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(mcpGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   }),
   zod.z.strictObject({
     language: zod.z.literal("terraform"),
-    generation: terraformGenerationConfigSchema.optional(),
+    generation: sdkConfigV1GenerationConfigOverrideSchema.extend(terraformGenerationConfigSchema.shape).optional(),
     ...targetOverrideShape
   })
 ]);
@@ -1399,6 +1525,14 @@ function validatePublishingIdentity(packageConfig, registry, targetIndex, contex
 }
 function validateTargetPublishing(target, targetIndex, globalPackage, globalOutput, context) {
   const output = target.output ?? globalOutput;
+  if (!output) {
+    context.addIssue({
+      code: "custom",
+      message: "output is required on the target when no global output is configured",
+      path: ["targets", targetIndex, "output"]
+    });
+    return;
+  }
   if (!output.publish) {
     return;
   }
@@ -1423,10 +1557,11 @@ var sdkConfigV1Schema = zod.z.strictObject({
   sdkName: nonEmptyStringSchema,
   sdkVersion: nonEmptyStringSchema.default("1.0.0"),
   apiVersion: nonEmptyStringSchema.optional(),
+  source: sdkConfigV1SourceConfigSchema,
   api: sdkConfigV1ApiConfigSchema,
   client: sdkConfigV1ClientConfigSchema,
   package: sdkConfigV1PackageConfigSchema,
-  output: sdkConfigV1OutputConfigSchema,
+  output: sdkConfigV1OutputConfigSchema.optional(),
   docs: sdkConfigV1DocsConfigSchema,
   generation: sdkConfigV1GenerationConfigSchema,
   targets: zod.z.array(sdkConfigV1TargetSchema).min(1)
@@ -1444,6 +1579,10 @@ var sdkConfigV1Schema = zod.z.strictObject({
     validateTargetPublishing(target, targetIndex, globalPackage, output, context);
   });
 });
+function validateSdkConfigV1(value) {
+  sdkConfigV1Schema.parse(value);
+  return value;
+}
 function parseSdkConfigV1(value) {
   return sdkConfigV1Schema.parse(value);
 }
@@ -1489,21 +1628,9 @@ function mapFernConfigToSdkConfigV1(input) {
     };
   });
   requireUniqueLanguages(mapped.map(({ language }) => language));
-  const client = requireSharedBlock(
-    mapped.map(({ invocation }) => invocation.client),
-    "client",
-    (value) => sdkConfigV1ClientConfigSchema.parse(value)
-  );
-  const docs = requireSharedBlock(
-    mapped.map(({ invocation }) => invocation.docs),
-    "docs",
-    (value) => sdkConfigV1DocsConfigSchema.parse(value)
-  );
-  const generation = requireSharedBlock(
-    mapped.map(({ invocation }) => invocation.generation),
-    "generation",
-    (value) => sdkConfigV1GenerationConfigSchema.parse(value)
-  );
+  const clients = partitionSharedBlock(mapped.map(({ invocation }) => invocation.client));
+  const docs = partitionSharedBlock(mapped.map(({ invocation }) => invocation.docs));
+  const generations = partitionSharedBlock(mapped.map(({ invocation }) => invocation.generation));
   const api = { ...input.api ?? {} };
   delete api.audiences;
   if (input.group.audiences.type === "select") {
@@ -1515,13 +1642,19 @@ function mapFernConfigToSdkConfigV1(input) {
         language,
         output,
         ...optional("sdkName", generator.sdkName),
-        ...optional("sdkVersion", generator.sdkVersion)
+        ...optional("sdkVersion", generator.sdkVersion),
+        ...optional("client", clients.targetOverrides[index]),
+        ...optional("docs", docs.targetOverrides[index])
       };
       if (Object.keys(invocation.package).length > 0 || outputPackage || generator.package) {
         target.package = { ...invocation.package, ...outputPackage, ...generator.package };
       }
-      if (Object.keys(invocation.targetGeneration).length > 0) {
-        target.generation = invocation.targetGeneration;
+      const targetGeneration = {
+        ...generations.targetOverrides[index],
+        ...invocation.targetGeneration
+      };
+      if (Object.keys(targetGeneration).length > 0) {
+        target.generation = targetGeneration;
       }
       if (generator.version) {
         if (exactSemverSchema.safeParse(generator.version).success) {
@@ -1540,19 +1673,20 @@ function mapFernConfigToSdkConfigV1(input) {
       return target;
     }
   );
-  const parsed = sdkConfigV1Schema.safeParse({
+  const sdkConfig = {
     schemaVersion: "sdk-config/v1",
     sdkName: input.apiName,
+    source: input.source,
     ...optional("sdkVersion", input.sdkVersion),
     ...optional("apiVersion", input.apiVersion),
     api,
-    client,
+    client: clients.shared,
     package: {},
-    output: mapped[0].output,
-    docs,
-    generation,
+    docs: docs.shared,
+    generation: generations.shared,
     targets
-  });
+  };
+  const parsed = sdkConfigV1Schema.safeParse(sdkConfig);
   if (!parsed.success) {
     throw new FernConfigMappingError(
       parsed.error.issues.map((issue) => {
@@ -1570,8 +1704,9 @@ function mapFernConfigToSdkConfigV1(input) {
       })
     );
   }
+  const validatedSdkConfig = sdkConfig;
   return {
-    sdkConfig: parsed.data,
+    sdkConfig: validatedSdkConfig,
     unsupportedFields: mapped.flatMap(({ invocation, unsupportedFields }) => [
       ...invocation.unsupportedFields,
       ...unsupportedFields
@@ -1623,19 +1758,46 @@ function requireUniqueLanguages(languages) {
     seen.add(language);
   }
 }
-function requireSharedBlock(values, name, normalize) {
-  const first = normalize(values[0]);
-  const serialized = stableJson(first);
-  if (values.some((value) => stableJson(normalize(value)) !== serialized)) {
-    fail(
-      "FERN_TARGET_SPECIFIC_SHARED_CONFIG",
-      ["group", "generators"],
-      `SDK Config v1 cannot represent target-specific Fern ${name} configuration`,
-      `Choose one shared ${name} configuration manually or create separate SDK Config documents for the differing targets.`,
-      [name]
-    );
+function partitionSharedBlock(values) {
+  const partition = partitionObjectValues(values);
+  return {
+    shared: partition.shared,
+    targetOverrides: partition.overrides.map(
+      (override) => Object.keys(override).length > 0 ? override : void 0
+    )
+  };
+}
+function partitionObjectValues(values) {
+  const shared = {};
+  const overrides = values.map(() => ({}));
+  const keys = new Set(values.flatMap((value) => Object.keys(value)));
+  for (const key of keys) {
+    const fieldValues = values.map((value) => value[key]);
+    const presentOnEveryTarget = fieldValues.every((value) => value !== void 0);
+    if (!presentOnEveryTarget) {
+      fieldValues.forEach((value, index) => {
+        if (value !== void 0) overrides[index][key] = value;
+      });
+      continue;
+    }
+    if (fieldValues.every(isObject)) {
+      const nested = partitionObjectValues(fieldValues);
+      if (Object.keys(nested.shared).length > 0) shared[key] = nested.shared;
+      nested.overrides.forEach((override, index) => {
+        if (Object.keys(override).length > 0) overrides[index][key] = override;
+      });
+      continue;
+    }
+    const first = fieldValues[0];
+    if (fieldValues.every((value) => stableJson(value) === stableJson(first))) {
+      shared[key] = first;
+    } else {
+      fieldValues.forEach((value, index) => {
+        overrides[index][key] = value;
+      });
+    }
   }
-  return first;
+  return { shared, overrides };
 }
 function mapInvocation(generator, language, index) {
   const prefix = ["group", "generators", index];
@@ -1645,14 +1807,21 @@ function mapInvocation(generator, language, index) {
   const generation = {};
   const packageConfig = {};
   mapCommonConfig(config, state, client, generation, packageConfig, [...prefix, "config"]);
+  const rawGenerator = isObject(generator.raw) ? generator.raw : void 0;
+  const smartCasing = typeof rawGenerator?.["smart-casing"] === "boolean" ? rawGenerator["smart-casing"] : generator.smartCasing === false ? false : void 0;
+  const smartCasingDigitWordBoundary = typeof rawGenerator?.["smart-casing-digit-word-boundary"] === "boolean" ? rawGenerator["smart-casing-digit-word-boundary"] : generator.smartCasingDigitWordBoundary === true ? true : void 0;
+  if (smartCasing !== void 0 || smartCasingDigitWordBoundary !== void 0) {
+    generation.naming = {
+      ...generation.naming,
+      ...optional("smartCasing", smartCasing),
+      ...optional("smartCasingDigitWordBoundary", smartCasingDigitWordBoundary)
+    };
+  }
   const targetGeneration = mapLanguageConfig(language, config, state, packageConfig, [
     ...prefix,
     "config"
   ]);
   mapPublishMetadata(generator.publishMetadata, packageConfig);
-  if (language === "go" && generator.smartCasing !== void 0) {
-    targetGeneration.smartCasing = generator.smartCasing;
-  }
   if (generator.keywords?.length) {
     generation.reservedKeywords = [...generator.keywords];
   }
@@ -1671,27 +1840,22 @@ function mapInvocation(generator, language, index) {
     ...collectUnsupported(config, [...prefix, "config"], state),
     ...settings ? collectUnsupported(settings, [...prefix, "settings"], state) : [],
     ...isObject(generator.readme) ? collectUnsupported(generator.readme, [...prefix, "readme"], state) : [],
-    ...unsupportedResolvedFields(generator, index, language)
+    ...unsupportedResolvedFields(generator, index)
   ];
   return { client, docs, generation, package: packageConfig, targetGeneration, unsupportedFields };
 }
-function unsupportedResolvedFields(generator, index, language) {
+function unsupportedResolvedFields(generator, index) {
   const values = [
     ["automation", isDefaultAutomation(generator.automation) ? void 0 : generator.automation],
     ["containerImage", generator.containerImage],
     ["irVersionOverride", generator.irVersionOverride],
     ["idempotencyKeyGenerationConfig", generator.idempotencyKeyGenerationConfig],
     ["absolutePathToLocalSnippets", generator.absolutePathToLocalSnippets],
-    [
-      "smartCasingDigitWordBoundary",
-      generator.smartCasingDigitWordBoundary === false ? void 0 : generator.smartCasingDigitWordBoundary
-    ],
     [
       "disableExamples",
       generator.disableExamples === false ? void 0 : generator.disableExamples
     ],
-    ["apiOverride", generator.apiOverride],
-    ...language === "go" || generator.smartCasing === true ? [] : [["smartCasing", generator.smartCasing]]
+    ["apiOverride", generator.apiOverride]
   ];
   return values.flatMap(([field, value]) => {
     if (value === void 0) return [];
@@ -1855,6 +2019,12 @@ function mapTypescript(config, state, packageConfig, basePath) {
     testFramework: takeEnum(config, ["testFramework"], ["jest", "vitest"], state, basePath),
     bundle: takeBoolean(config, ["bundle"], state, basePath),
     exportClassDefault: takeBoolean(config, ["exportClassDefault"], state, basePath),
+    namespaceExportName: takeString(
+      config,
+      ["namespaceExportName", "namespaceExport"],
+      state,
+      basePath
+    ),
     allowCustomFetcher: takeBoolean(config, ["allowCustomFetcher"], state, basePath),
     useBrandedStringAliases: takeBoolean(config, ["useBrandedStringAliases"], state, basePath),
     useLegacyExports: takeBoolean(config, ["useLegacyExports"], state, basePath),
@@ -2201,12 +2371,14 @@ exports.sdkConfigV1ApiConfigSchema = sdkConfigV1ApiConfigSchema;
 exports.sdkConfigV1AuthConfigSchema = sdkConfigV1AuthConfigSchema;
 exports.sdkConfigV1AuthSchemeSchema = sdkConfigV1AuthSchemeSchema;
 exports.sdkConfigV1CliGenerationConfigSchema = cliGenerationConfigSchema;
+exports.sdkConfigV1ClientConfigOverrideSchema = sdkConfigV1ClientConfigOverrideSchema;
 exports.sdkConfigV1ClientConfigSchema = sdkConfigV1ClientConfigSchema;
 exports.sdkConfigV1ComposerPackageNameSchema = composerPackageNameSchema;
 exports.sdkConfigV1CsharpGenerationConfigSchema = csharpGenerationConfigSchema;
 exports.sdkConfigV1DependencySchema = sdkConfigV1DependencySchema;
 exports.sdkConfigV1DocsConfigSchema = sdkConfigV1DocsConfigSchema;
 exports.sdkConfigV1ExactSemverSchema = exactSemverSchema;
+exports.sdkConfigV1GenerationConfigOverrideSchema = sdkConfigV1GenerationConfigOverrideSchema;
 exports.sdkConfigV1GenerationConfigSchema = sdkConfigV1GenerationConfigSchema;
 exports.sdkConfigV1GoGenerationConfigSchema = goGenerationConfigSchema;
 exports.sdkConfigV1GoModulePathSchema = goModulePathSchema;
@@ -2222,12 +2394,17 @@ exports.sdkConfigV1PublishRegistrySchema = sdkConfigV1PublishRegistrySchema;
 exports.sdkConfigV1PythonGenerationConfigSchema = pythonGenerationConfigSchema;
 exports.sdkConfigV1ReadmeCustomSectionSchema = sdkConfigV1ReadmeCustomSectionSchema;
 exports.sdkConfigV1ReadmeEndpointSchema = sdkConfigV1ReadmeEndpointSchema;
+exports.sdkConfigV1RelativePathSchema = relativePathSchema;
 exports.sdkConfigV1RubyGenerationConfigSchema = rubyGenerationConfigSchema;
 exports.sdkConfigV1RustGenerationConfigSchema = rustGenerationConfigSchema;
 exports.sdkConfigV1Schema = sdkConfigV1Schema;
+exports.sdkConfigV1SourceConfigSchema = sdkConfigV1SourceConfigSchema;
+exports.sdkConfigV1SourceSpecSchema = sdkConfigV1SourceSpecSchema;
 exports.sdkConfigV1SwiftGenerationConfigSchema = swiftGenerationConfigSchema;
 exports.sdkConfigV1TargetSchema = sdkConfigV1TargetSchema;
 exports.sdkConfigV1TerraformGenerationConfigSchema = terraformGenerationConfigSchema;
 exports.sdkConfigV1TypescriptGenerationConfigSchema = typescriptGenerationConfigSchema;
+exports.splitSdkConfigV1TargetGeneration = splitSdkConfigV1TargetGeneration;
+exports.validateSdkConfigV1 = validateSdkConfigV1;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map