@workos/oagen-emitters 0.4.0 → 0.6.0

package/src/python/tests.ts

@@ -9,16 +9,60 @@ import type {
   ResolvedOperation,
 } from '@workos/oagen';
 import { planOperation, toSnakeCase, assignModelsToServices } from '@workos/oagen';
-import { className, fileName, fieldName, resolveMethodName, buildMountDirMap, dirToModule } from './naming.js';
+import {
+  className,
+  fileName,
+  fieldName,
+  moduleName,
+  resolveMethodName,
+  buildMountDirMap,
+  dirToModule,
+} from './naming.js';
 import { resolveResourceClassName, bodyParamName } from './resources.js';
 import { buildServiceAccessPaths } from './client.js';
 import { generateFixtures, generateModelFixture } from './fixtures.js';
 import { isListWrapperModel, isListMetadataModel } from './models.js';
 import { assignEnumsToServices } from './enums.js';
-import { groupByMount, buildResolvedLookup, lookupResolved, buildHiddenParams } from '../shared/resolved-ops.js';
+import {
+  groupByMount,
+  buildResolvedLookup,
+  lookupResolved,
+  buildHiddenParams,
+  collectGroupedParamNames,
+} from '../shared/resolved-ops.js';
 import { resolveWrapperParams } from '../shared/wrapper-utils.js';
 import { pythonLiteral } from './wrappers.js';
 
+/**
+ * Resolve the Python class name to use for isinstance checks on paginated items.
+ * For discriminated unions, generates the fixture and determines which variant
+ * the discriminator value maps to. For regular models, returns the model class.
+ */
+function resolvePaginatedItemClass(itemName: string | null, spec: ApiSpec): string | null {
+  if (!itemName) return null;
+  const itemModel = spec.models.find((m) => m.name === itemName);
+  if (!itemModel) return className(itemName);
+
+  const disc = (itemModel as any).discriminator as { property: string; mapping: Record<string, string> } | undefined;
+  if (!disc) return className(itemName);
+
+  // Generate the fixture to determine which discriminator value appears
+  const modelMap = new Map(spec.models.map((m) => [m.name, m]));
+  const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
+  const fixture = generateModelFixture(itemModel, modelMap, enumMap);
+  const discValue = fixture[disc.property];
+
+  if (typeof discValue === 'string' && disc.mapping[discValue]) {
+    return className(disc.mapping[discValue]);
+  }
+
+  // Fallback: first variant alphabetically
+  const sortedEntries = Object.entries(disc.mapping).sort(([a], [b]) => a.localeCompare(b));
+  if (sortedEntries.length > 0) return className(sortedEntries[0][1]);
+
+  return className(itemName);
+}
+
 /** Check if an operation is a redirect endpoint (same logic as resources.ts). */
 function isRedirectEndpoint(op: Operation): boolean {
   if (op.successResponses?.some((r) => r.statusCode >= 300 && r.statusCode < 400)) return true;
@@ -39,6 +83,14 @@ function pushAsyncTestDef(lines: string[], def: string): void {
   lines.push(def);
 }
 
+function buildDeleteSuccessResponseSetup(op: Operation): string {
+  const statusCode = op.successResponses?.[0]?.statusCode ?? 204;
+  if (statusCode === 204) {
+    return 'httpx_mock.add_response(status_code=204)';
+  }
+  return `httpx_mock.add_response(status_code=${statusCode}, content=b"\\n")`;
+}
+
 /**
  * Generate pytest test files and JSON fixtures for the Python SDK.
  */
@@ -117,12 +169,41 @@ function generateServiceTest(
     if (plan.responseModelName) modelImports.add(plan.responseModelName);
     if (op.pagination?.itemType.kind === 'model') {
       modelImports.add(op.pagination.itemType.name);
+      // Unwrap list wrapper to find the inner item model (may be a discriminated union)
+      let paginationItemName = op.pagination.itemType.name;
+      const wrapperModel = spec.models.find((m) => m.name === paginationItemName);
+      if (wrapperModel && isListWrapperModel(wrapperModel)) {
+        const dataField = wrapperModel.fields.find((f) => f.name === 'data');
+        if (dataField && dataField.type.kind === 'array' && dataField.type.items.kind === 'model') {
+          paginationItemName = dataField.type.items.name;
+          modelImports.add(paginationItemName);
+        }
+      }
+      // For discriminated union pagination items, import the variant that the fixture resolves to
+      const resolvedVariantClass = resolvePaginatedItemClass(paginationItemName, spec);
+      if (resolvedVariantClass && resolvedVariantClass !== className(paginationItemName)) {
+        // Find the model name from the class name — reverse-lookup through the discriminator mapping
+        const paginationModel = spec.models.find((m) => m.name === paginationItemName);
+        const disc =
+          paginationModel &&
+          ((paginationModel as any).discriminator as { property: string; mapping: Record<string, string> } | undefined);
+        if (disc) {
+          for (const variantName of Object.values(disc.mapping)) {
+            if (className(variantName) === resolvedVariantClass) {
+              modelImports.add(variantName);
+              break;
+            }
+          }
+        }
+      }
     }
     // Collect model-typed and enum-typed body fields (used as method arguments)
     if (plan.hasBody && op.requestBody?.kind === 'model') {
       const bodyModel = spec.models.find((m) => m.name === (op.requestBody as any).name);
       if (bodyModel) {
+        const testGroupedParams = collectGroupedParamNames(op);
         for (const f of bodyModel.fields) {
+          if (testGroupedParams.has(f.name)) continue;
           if (f.type.kind === 'model') modelImports.add(f.type.name);
           if (f.type.kind === 'nullable' && f.type.inner.kind === 'model') modelImports.add(f.type.inner.name);
           if (f.type.kind === 'array' && f.type.items.kind === 'model') modelImports.add(f.type.items.name);
@@ -186,6 +267,20 @@ function generateServiceTest(
     `from ${ctx.namespace}._errors import AuthenticationError, BadRequestError, NotFoundError, RateLimitExceededError, ServerError, UnprocessableEntityError`,
   );
 
+  // Import parameter group variant classes
+  const groupVariantImports = new Set<string>();
+  for (const op of service.operations) {
+    for (const group of op.parameterGroups ?? []) {
+      for (const variant of group.variants) {
+        groupVariantImports.add(className(`${group.name}_${variant.name}`));
+      }
+    }
+  }
+  if (groupVariantImports.size > 0) {
+    const mountDir = dirToModule(buildMountDirMap(ctx).get(service.name) ?? moduleName(service.name));
+    lines.push(`from ${ctx.namespace}.${mountDir}._resource import ${[...groupVariantImports].join(', ')}`);
+  }
+
   lines.push('');
   lines.push('');
   lines.push(`class Test${resolvedName}:`);
@@ -229,12 +324,19 @@ function generateServiceTest(
         }
       }
       // Skip fixture-based testing for models with no fields (discriminated unions)
+      // Save the unwrapped name before nulling — needed for discriminator check below
+      const unwrappedItemName = itemName;
       if (itemName) {
         const itemModel = spec.models.find((m) => m.name === itemName);
         if (itemModel && itemModel.fields.length === 0) itemName = null;
       }
       const fixtureName = itemName ? `list_${fileName(itemName)}.json` : null;
 
+      // Determine the class name to use for isinstance checks on paginated items.
+      // If the item model is a discriminated union (has a discriminator), the fixture
+      // will deserialize to a concrete variant, so assert on that variant class.
+      const paginatedItemClass = resolvePaginatedItemClass(itemName, spec);
+
       const paginatedArgs = buildTestArgs(op, spec, hiddenParams);
       lines.push(`    def test_${method}(self, workos, httpx_mock):`);
       if (fixtureName) {
@@ -243,22 +345,44 @@ function generateServiceTest(
         lines.push('        )');
         lines.push(`        page = workos.${propName}.${method}(${paginatedArgs})`);
         lines.push('        assert isinstance(page, SyncPage)');
-        lines.push('        assert isinstance(page.data, list)');
+        lines.push('        assert len(page.data) == 1');
+        lines.push(`        assert isinstance(page.data[0], ${paginatedItemClass})`);
 
         lines.push('');
         lines.push(`    def test_${method}_empty_page(self, workos, httpx_mock):`);
         lines.push('        httpx_mock.add_response(json={"data": [], "list_metadata": {}})');
         lines.push(`        page = workos.${propName}.${method}(${paginatedArgs})`);
+
         lines.push('        assert isinstance(page, SyncPage)');
         lines.push('        assert page.data == []');
       } else {
-        lines.push('        httpx_mock.add_response(json={"data": [], "list_metadata": {}})');
-        lines.push(`        page = workos.${propName}.${method}(${paginatedArgs})`);
-        lines.push('        assert isinstance(page, SyncPage)');
+        // Check if the unwrapped item is a discriminated union — test dispatch through pagination
+        const discModel = unwrappedItemName ? spec.models.find((m) => m.name === unwrappedItemName) : null;
+        const disc =
+          discModel && (discModel as any).discriminator
+            ? ((discModel as any).discriminator as { property: string; mapping: Record<string, string> })
+            : null;
+        const discEntries = disc ? Object.entries(disc.mapping).sort(([a], [b]) => a.localeCompare(b)) : [];
+        if (disc && discEntries.length > 0) {
+          const [, firstVariantName] = discEntries[0];
+          const variantFixture = `${fileName(firstVariantName)}.json`;
+          const variantClass = className(firstVariantName);
+          lines.push('        httpx_mock.add_response(');
+          lines.push(`            json={"data": [load_fixture("${variantFixture}")], "list_metadata": {}},`);
+          lines.push('        )');
+          lines.push(`        page = workos.${propName}.${method}(${paginatedArgs})`);
+          lines.push('        assert isinstance(page, SyncPage)');
+          lines.push('        assert len(page.data) == 1');
+          lines.push(`        assert isinstance(page.data[0], ${variantClass})`);
+        } else {
+          lines.push('        httpx_mock.add_response(json={"data": [], "list_metadata": {}})');
+          lines.push(`        page = workos.${propName}.${method}(${paginatedArgs})`);
+          lines.push('        assert isinstance(page, SyncPage)');
+        }
       }
     } else if (isDelete) {
       lines.push(`    def test_${method}(self, workos, httpx_mock):`);
-      lines.push('        httpx_mock.add_response(status_code=204)');
+      lines.push(`        ${buildDeleteSuccessResponseSetup(op)}`);
       const args = buildTestArgs(op, spec, hiddenParams);
       lines.push(`        result = workos.${propName}.${method}(${args})`);
       lines.push('        assert result is None');
@@ -505,17 +629,23 @@ function generateServiceTest(
         }
       }
       // Skip fixture-based testing for models with no fields (discriminated unions)
+      // Save the unwrapped name before nulling — needed for discriminator check below
+      const unwrappedItemName = itemName;
       if (itemName) {
         const itemModel = spec.models.find((m) => m.name === itemName);
         if (itemModel && itemModel.fields.length === 0) itemName = null;
       }
       const fixtureName = itemName ? `list_${fileName(itemName)}.json` : null;
+
+      const asyncPaginatedItemClass = resolvePaginatedItemClass(itemName, spec);
+
       pushAsyncTestDef(lines, `    async def test_${method}(self, async_workos, httpx_mock):`);
       if (fixtureName) {
         lines.push(`        httpx_mock.add_response(json=load_fixture("${fixtureName}"))`);
         lines.push(`        page = await async_workos.${propName}.${method}(${asyncArgs})`);
         lines.push('        assert isinstance(page, AsyncPage)');
-        lines.push('        assert isinstance(page.data, list)');
+        lines.push('        assert len(page.data) == 1');
+        lines.push(`        assert isinstance(page.data[0], ${asyncPaginatedItemClass})`);
 
         lines.push('');
         pushAsyncTestDef(lines, `    async def test_${method}_empty_page(self, async_workos, httpx_mock):`);
@@ -524,14 +654,34 @@ function generateServiceTest(
         lines.push('        assert isinstance(page, AsyncPage)');
         lines.push('        assert page.data == []');
       } else {
-        lines.push('        httpx_mock.add_response(json={"data": [], "list_metadata": {}})');
-        lines.push(`        page = await async_workos.${propName}.${method}(${asyncArgs})`);
-        lines.push('        assert isinstance(page, AsyncPage)');
+        // Check if the unwrapped item is a discriminated union — test dispatch through pagination
+        const discModel = unwrappedItemName ? spec.models.find((m) => m.name === unwrappedItemName) : null;
+        const disc =
+          discModel && (discModel as any).discriminator
+            ? ((discModel as any).discriminator as { property: string; mapping: Record<string, string> })
+            : null;
+        const discEntries = disc ? Object.entries(disc.mapping).sort(([a], [b]) => a.localeCompare(b)) : [];
+        if (disc && discEntries.length > 0) {
+          const [, firstVariantName] = discEntries[0];
+          const variantFixture = `${fileName(firstVariantName)}.json`;
+          const variantClass = className(firstVariantName);
+          lines.push('        httpx_mock.add_response(');
+          lines.push(`            json={"data": [load_fixture("${variantFixture}")], "list_metadata": {}},`);
+          lines.push('        )');
+          lines.push(`        page = await async_workos.${propName}.${method}(${asyncArgs})`);
+          lines.push('        assert isinstance(page, AsyncPage)');
+          lines.push('        assert len(page.data) == 1');
+          lines.push(`        assert isinstance(page.data[0], ${variantClass})`);
+        } else {
+          lines.push('        httpx_mock.add_response(json={"data": [], "list_metadata": {}})');
+          lines.push(`        page = await async_workos.${propName}.${method}(${asyncArgs})`);
+          lines.push('        assert isinstance(page, AsyncPage)');
+        }
       }
     } else if (isDelete) {
       const deletePath = buildExpectedPath(op);
       pushAsyncTestDef(lines, `    async def test_${method}(self, async_workos, httpx_mock):`);
-      lines.push('        httpx_mock.add_response(status_code=204)');
+      lines.push(`        ${buildDeleteSuccessResponseSetup(op)}`);
       lines.push(`        result = await async_workos.${propName}.${method}(${asyncArgs})`);
       lines.push('        assert result is None');
       lines.push('        request = httpx_mock.get_request()');
@@ -884,11 +1034,22 @@ function buildTestArgs(op: Operation, spec: ApiSpec, hiddenParams?: Set<string>)
     args.push(`${tokenParamName}="test_${tokenParamName}"`);
   }
 
+  // Parameter group args — emit first variant constructor
+  const groupedParamNames = collectGroupedParamNames(op);
+  for (const group of op.parameterGroups ?? []) {
+    const variant = group.variants[0];
+    const variantClass = className(`${group.name}_${variant.name}`);
+    const variantArgs = variant.parameters.map((p) => `${fieldName(p.name)}="test_value"`).join(', ');
+    args.push(`${fieldName(group.name)}=${variantClass}(${variantArgs})`);
+  }
+
   // Required query params (for all methods, including paginated)
   if (plan.hasQueryParams) {
     for (const param of op.queryParams) {
       // Skip hidden/injected params
       if (hiddenParams?.has(param.name)) continue;
+      // Skip params that belong to parameter groups
+      if (groupedParamNames.has(param.name)) continue;
       // Skip pagination params (they're optional)
       if (plan.isPaginated && ['limit', 'before', 'after', 'order'].includes(param.name)) continue;
       // Skip params already covered by body fields
@@ -908,6 +1069,7 @@ function buildTestArgs(op: Operation, spec: ApiSpec, hiddenParams?: Set<string>)
 
 function buildQueryEncodingTestArgs(op: Operation, spec: ApiSpec): string {
   const args: string[] = [];
+  const groupedParamNames = collectGroupedParamNames(op);
 
   for (const param of op.pathParams) {
     args.push(`"test_${param.name}"`);
@@ -918,7 +1080,8 @@ function buildQueryEncodingTestArgs(op: Operation, spec: ApiSpec): string {
 
   if (plan.hasBody && op.requestBody?.kind === 'model') {
     const bodyModel = spec.models.find((m) => m.name === (op.requestBody as { kind: string; name: string }).name);
-    for (const field of bodyModel?.fields.filter((f) => f.required) ?? []) {
+    const bodyArgGrouped = collectGroupedParamNames(op);
+    for (const field of bodyModel?.fields.filter((f) => f.required && !bodyArgGrouped.has(f.name)) ?? []) {
       args.push(`${bodyParamName(field, pathParamNames)}=${generateTestValue(field.type, field.name)}`);
     }
   } else if (plan.hasBody && op.requestBody?.kind === 'union') {
@@ -927,6 +1090,16 @@ function buildQueryEncodingTestArgs(op: Operation, spec: ApiSpec): string {
     args.push(firstModelVariant ? `body=load_fixture("${fileName(firstModelVariant.name)}.json")` : 'body={}');
   }
 
+  // Parameter group args — emit first variant constructor
+  for (const group of op.parameterGroups ?? []) {
+    const variant = group.variants[0];
+    const variantClass = className(`${group.name}_${variant.name}`);
+    const variantArgs = variant.parameters
+      .map((p) => `${fieldName(p.name)}=${generateQueryEncodingValue(p.type, p.name)}`)
+      .join(', ');
+    args.push(`${fieldName(group.name)}=${variantClass}(${variantArgs})`);
+  }
+
   if (plan.isPaginated) {
     args.push('limit=10');
     args.push('before="cursor before"');
@@ -939,6 +1112,7 @@ function buildQueryEncodingTestArgs(op: Operation, spec: ApiSpec): string {
 
   for (const param of op.queryParams) {
     if (plan.isPaginated && ['limit', 'before', 'after', 'order'].includes(param.name)) continue;
+    if (groupedParamNames.has(param.name)) continue;
     // Include explode=false array params; skip other array params (complex serialization)
     if (param.type.kind === 'array' && (param as any).explode !== false) continue;
     const paramName = fieldName(param.name);
@@ -962,7 +1136,7 @@ function buildQueryEncodingResponseSetup(op: Operation, plan: ReturnType<typeof
     return ['httpx_mock.add_response(json={"data": [], "list_metadata": {}})'];
   }
   if (plan.isDelete) {
-    return ['httpx_mock.add_response(status_code=204)'];
+    return [buildDeleteSuccessResponseSetup(op)];
   }
   if (op.response.kind === 'array') {
     if (op.response.items.kind === 'model') {
@@ -980,6 +1154,17 @@ function buildQueryEncodingAssertions(op: Operation, spec: ApiSpec): string[] {
   const assertions: string[] = [];
   const plan = planOperation(op);
   const pathParamNames = new Set(op.pathParams.map((param) => fieldName(param.name)));
+  const groupedParamNames = collectGroupedParamNames(op);
+
+  // Assert first variant's params from parameter groups
+  for (const group of op.parameterGroups ?? []) {
+    const variant = group.variants[0];
+    for (const param of variant.parameters) {
+      assertions.push(
+        `assert request.url.params["${param.name}"] == ${toPythonLiteral(expectedQueryEncodingValue(param.type, param.name))}`,
+      );
+    }
+  }
 
   if (plan.isPaginated) {
     assertions.push('assert request.url.params["limit"] == "10"');
@@ -995,6 +1180,7 @@ function buildQueryEncodingAssertions(op: Operation, spec: ApiSpec): string[] {
 
   for (const param of op.queryParams) {
     if (plan.isPaginated && ['limit', 'before', 'after', 'order'].includes(param.name)) continue;
+    if (groupedParamNames.has(param.name)) continue;
     // Include explode=false array params; skip other array params (complex serialization)
     if (param.type.kind === 'array' && (param as any).explode !== false) continue;
     const paramName = fieldName(param.name);
@@ -1237,6 +1423,14 @@ function generateModelRoundTripTests(spec: ApiSpec, ctx: EmitterContext): Genera
     if (!importsByDir.has(dirName)) importsByDir.set(dirName, []);
     importsByDir.get(dirName)!.push(className(model.name));
   }
+  // Add discriminator Unknown variant classes to imports for dispatch tests
+  for (const model of models) {
+    if (!(model as any).discriminator) continue;
+    const service = modelToService.get(model.name);
+    const dirName = resolveDir(service);
+    if (!importsByDir.has(dirName)) importsByDir.set(dirName, []);
+    importsByDir.get(dirName)!.push(`${className(model.name)}Unknown`);
+  }
 
   for (const [dirName, names] of [...importsByDir].sort()) {
     lines.push(`from ${ctx.namespace}.${dirToModule(dirName)}.models import ${names.sort().join(', ')}`);
@@ -1247,9 +1441,10 @@ function generateModelRoundTripTests(spec: ApiSpec, ctx: EmitterContext): Genera
   lines.push('class TestModelRoundTrip:');
 
   for (const model of models) {
-    // Skip models with no fields — these are typically discriminated unions
-    // with hand-maintained @oagen-ignore overrides whose fixtures would not match.
+    // Skip models with no fields or discriminated union dispatchers — these
+    // don't have a to_dict() and their round-trip semantics differ.
     if (model.fields.length === 0) continue;
+    if ((model as any).discriminator) continue;
     // Deduplicate fields that map to the same snake_case name (mirrors models.ts)
     const seenFieldNames = new Set<string>();
     const dedupFields = model.fields.filter((f) => {
@@ -1326,6 +1521,55 @@ function generateModelRoundTripTests(spec: ApiSpec, ctx: EmitterContext): Genera
     }
   }
 
+  // Discriminator dispatch tests — targeted coverage for from_dict routing
+  const discriminatorModels = models.filter((m) => (m as any).discriminator);
+  if (discriminatorModels.length > 0) {
+    lines.push('');
+    lines.push('');
+    lines.push('class TestDiscriminatorDispatch:');
+
+    for (const model of discriminatorModels) {
+      const disc = (model as any).discriminator as { property: string; mapping: Record<string, string> };
+      const modelClass = className(model.name);
+      const unknownClass = `${modelClass}Unknown`;
+
+      // Pick the first variant (alphabetically by discriminator value) for tests
+      const sortedEntries = Object.entries(disc.mapping).sort(([a], [b]) => a.localeCompare(b));
+      if (sortedEntries.length === 0) continue;
+      const [, firstVariantName] = sortedEntries[0];
+      const firstVariantClass = className(firstVariantName);
+      const firstVariantFixture = `${fileName(firstVariantName)}.json`;
+
+      lines.push('');
+      lines.push(`    def test_${fileName(model.name)}_dispatches_known_variant(self):`);
+      lines.push(`        data = load_fixture("${firstVariantFixture}")`);
+      lines.push(`        result = ${modelClass}.from_dict(data)`);
+      lines.push(`        assert isinstance(result, ${firstVariantClass})`);
+
+      lines.push('');
+      lines.push(`    def test_${fileName(model.name)}_returns_unknown_for_unrecognized_type(self):`);
+      lines.push(`        data = load_fixture("${firstVariantFixture}")`);
+      lines.push(`        data = {**data, "${disc.property}": "future.unrecognized.type"}`);
+      lines.push(`        result = ${modelClass}.from_dict(data)`);
+      lines.push(`        assert isinstance(result, ${unknownClass})`);
+      lines.push('        assert result.raw_data == data');
+
+      lines.push('');
+      lines.push(`    def test_${fileName(model.name)}_raises_on_missing_discriminator(self):`);
+      lines.push(`        data = load_fixture("${firstVariantFixture}")`);
+      lines.push(`        data = {k: v for k, v in data.items() if k != "${disc.property}"}`);
+      lines.push('        with pytest.raises(Exception):');
+      lines.push(`            ${modelClass}.from_dict(data)`);
+
+      lines.push('');
+      lines.push(`    def test_${fileName(model.name)}_raises_on_none_discriminator(self):`);
+      lines.push(`        data = load_fixture("${firstVariantFixture}")`);
+      lines.push(`        data = {**data, "${disc.property}": None}`);
+      lines.push('        with pytest.raises(Exception):');
+      lines.push(`            ${modelClass}.from_dict(data)`);
+    }
+  }
+
   return {
     path: 'tests/test_models_round_trip.py',
     content: lines.join('\n'),

package/src/python/type-map.ts

@@ -21,7 +21,11 @@ export function mapTypeRef(ref: TypeRef): string {
       return `Optional[${inner}]`;
     },
     literal: (r) =>
-      typeof r.value === 'string' ? `Literal["${r.value}"]` : r.value === null ? 'None' : `Literal[${String(r.value)}]`,
+      typeof r.value === 'string'
+        ? `Literal["${r.value}"]`
+        : r.value === null
+          ? 'None'
+          : `Literal[${toPythonLiteral(r.value)}]`,
     map: (ref, value) => {
       void ref;
       return `Dict[str, ${value}]`;
@@ -52,7 +56,11 @@ export function mapTypeRefUnquoted(ref: TypeRef, knownEnums?: Set<string>, allow
       return `Optional[${inner}]`;
     },
     literal: (r) =>
-      typeof r.value === 'string' ? `Literal["${r.value}"]` : r.value === null ? 'None' : `Literal[${String(r.value)}]`,
+      typeof r.value === 'string'
+        ? `Literal["${r.value}"]`
+        : r.value === null
+          ? 'None'
+          : `Literal[${toPythonLiteral(r.value)}]`,
     map: (ref, value) => {
       void ref;
       return `Dict[str, ${value}]`;
@@ -60,6 +68,12 @@ export function mapTypeRefUnquoted(ref: TypeRef, knownEnums?: Set<string>, allow
   });
 }
 
+/** Convert a JS value to a Python literal string (capitalizes booleans). */
+function toPythonLiteral(value: unknown): string {
+  if (typeof value === 'boolean') return value ? 'True' : 'False';
+  return String(value);
+}
+
 function mapPrimitive(ref: PrimitiveType): string {
   if (ref.format) {
     switch (ref.format) {