@workos/oagen-emitters 0.14.4 → 0.15.0

package/src/python/resources.ts

@@ -363,9 +363,16 @@ function emitMethodSignature(
       : className(resolvedItem);
     returnType = `${pageType}[${itemTypeName}]`;
   } else if (isArrayResponse) {
-    returnType = `List[${className(plan.responseModelName!)}]`;
+    const arrayItemModel = ctx.spec.models.find((m) => m.name === plan.responseModelName);
+    const arrayItemTypeName = (arrayItemModel as any)?.discriminator
+      ? className(plan.responseModelName!) + 'Variant'
+      : className(plan.responseModelName!);
+    returnType = `List[${arrayItemTypeName}]`;
   } else if (plan.responseModelName) {
-    returnType = className(plan.responseModelName);
+    const singleResponseModel = ctx.spec.models.find((m) => m.name === plan.responseModelName);
+    returnType = (singleResponseModel as any)?.discriminator
+      ? className(plan.responseModelName) + 'Variant'
+      : className(plan.responseModelName);
   } else {
     returnType = 'None';
   }
@@ -772,6 +779,10 @@ function emitMethodBody(
     lines.push('        )');
   } else if (plan.hasBody && op.requestBody) {
     const responseModel = plan.responseModelName ? className(plan.responseModelName) : 'None';
+    const bodyResponseModelObj = plan.responseModelName
+      ? ctx.spec.models.find((m) => m.name === plan.responseModelName)
+      : null;
+    const isBodyResponseDiscriminator = !!(bodyResponseModelObj as any)?.discriminator;
     // Build body dict
     const bodyGroupedParams = collectGroupedParamNames(op);
     const bodyModel = ctx.spec.models.find((m) => op.requestBody?.kind === 'model' && m.name === op.requestBody.name);
@@ -847,6 +858,26 @@ function emitMethodBody(
       lines.push('            request_options=request_options,');
       lines.push('        )');
       lines.push(`        return [${itemModel}.from_dict(cast(Dict[str, Any], item)) for item in raw]`);
+    } else if (isBodyResponseDiscriminator && responseModel !== 'None') {
+      const variantType = responseModel + 'Variant';
+      lines.push(`        return cast(`);
+      lines.push(`            ${variantType},`);
+      lines.push(`            ${awaitPrefix}self._client.request(`);
+      lines.push(`                method="${httpMethod}",`);
+      lines.push(`                path=${pathStr},`);
+      lines.push(`                body=${bodyVarName},`);
+      if (bodyHasParams) {
+        lines.push('                params=params,');
+      }
+      lines.push(
+        `                model=${responseModel},  # type: ignore[arg-type]  # dispatcher; request only calls from_dict`,
+      );
+      if (plan.isIdempotentPost) {
+        lines.push('                idempotency_key=idempotency_key,');
+      }
+      lines.push('                request_options=request_options,');
+      lines.push('            )');
+      lines.push('        )');
     } else {
       const bodyReturnPrefix = responseModel !== 'None' ? 'return ' : '';
       lines.push(`        ${bodyReturnPrefix}${awaitPrefix}self._client.request(`);
@@ -868,6 +899,10 @@ function emitMethodBody(
   } else {
     // GET or similar with query params
     const responseModel = plan.responseModelName ? className(plan.responseModelName) : 'None';
+    const getResponseModelObj = plan.responseModelName
+      ? ctx.spec.models.find((m) => m.name === plan.responseModelName)
+      : null;
+    const isGetResponseDiscriminator = !!(getResponseModelObj as any)?.discriminator;
     const getGroupedParams = collectGroupedParamNames(op);
     const hasGroups = (op.parameterGroups?.length ?? 0) > 0;
     const visibleQueryParams = op.queryParams.filter((p) => !hiddenParams.has(p.name) && !getGroupedParams.has(p.name));
@@ -937,6 +972,22 @@ function emitMethodBody(
       lines.push('            request_options=request_options,');
       lines.push('        )');
       lines.push(`        return [${itemModel}.from_dict(cast(Dict[str, Any], item)) for item in raw]`);
+    } else if (isGetResponseDiscriminator && responseModel !== 'None') {
+      const variantType = responseModel + 'Variant';
+      lines.push(`        return cast(`);
+      lines.push(`            ${variantType},`);
+      lines.push(`            ${awaitPrefix}self._client.request(`);
+      lines.push(`                method="${httpMethod}",`);
+      lines.push(`                path=${pathStr},`);
+      if (emittedParams) {
+        lines.push('                params=params,');
+      }
+      lines.push(
+        `                model=${responseModel},  # type: ignore[arg-type]  # dispatcher; request only calls from_dict`,
+      );
+      lines.push('                request_options=request_options,');
+      lines.push('            )');
+      lines.push('        )');
     } else {
       const returnPrefix = responseModel !== 'None' ? 'return ' : '';
       lines.push(`        ${returnPrefix}${awaitPrefix}self._client.request(`);
@@ -1061,6 +1112,13 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
         if (!listWrapperNames.has(plan.responseModelName) || !plan.isPaginated) {
           modelImports.add(plan.responseModelName);
         }
+        // For discriminator (dispatcher) models also import the variant union type alias
+        if (!plan.isPaginated) {
+          const responseModelObj = ctx.spec.models.find((m) => m.name === plan.responseModelName);
+          if ((responseModelObj as any)?.discriminator) {
+            modelImports.add(plan.responseModelName + 'Variant');
+          }
+        }
       }
       if (op.requestBody?.kind === 'model') {
         const requestBodyRef = op.requestBody;
@@ -1161,13 +1219,23 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
     // Deduplicate: skip cross-service imports for models already available locally
     const localSet = new Set(localModels);
 
+    // Build a mapping from variant type aliases to their dispatcher's file name
+    // (e.g. ConnectApplicationVariant -> connect_application, not connect_application_variant)
+    const variantToFile = new Map<string, string>();
+    for (const model of ctx.spec.models) {
+      if ((model as any).discriminator) {
+        variantToFile.set(model.name + 'Variant', fileName(model.name));
+      }
+    }
+
     if (localModels.length > 0) {
       lines.push(`from .models import ${localModels.map((n) => className(n)).join(', ')}`);
     }
     for (const [csDir, names] of [...crossServiceModels].sort()) {
       const unique = names.filter((n) => !localSet.has(n));
       for (const n of unique) {
-        lines.push(`from ${ctx.namespace}.${dirToModule(csDir)}.models.${fileName(n)} import ${className(n)}`);
+        const filePath = variantToFile.get(n) ?? fileName(n);
+        lines.push(`from ${ctx.namespace}.${dirToModule(csDir)}.models.${filePath} import ${className(n)}`);
       }
     }
 

package/src/python/tests.ts

@@ -167,7 +167,27 @@ function generateServiceTest(
   const enumImports = new Set<string>();
   for (const op of service.operations) {
     const plan = planOperation(op);
-    if (plan.responseModelName) modelImports.add(plan.responseModelName);
+    if (plan.responseModelName) {
+      modelImports.add(plan.responseModelName);
+      // For non-paginated discriminated union responses, import the resolved variant class
+      if (!plan.isPaginated) {
+        const resolvedVariantClass = resolvePaginatedItemClass(plan.responseModelName, spec);
+        if (resolvedVariantClass && resolvedVariantClass !== className(plan.responseModelName)) {
+          const responseModel = spec.models.find((m) => m.name === plan.responseModelName);
+          const disc =
+            responseModel &&
+            ((responseModel 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;
+              }
+            }
+          }
+        }
+      }
+    }
     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)
@@ -220,11 +240,13 @@ function generateServiceTest(
     }
   }
 
-  // Filter out list wrapper models
+  // Filter out list wrapper models, but keep non-paginated response wrappers
+  const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
   const actualImports = [...modelImports].filter((name) => {
     const model = spec.models.find((m) => m.name === name);
     if (!model) return true;
-    return !isListWrapperModel(model);
+    if (isListWrapperModel(model) && !nonPaginatedRefs.has(name)) return false;
+    return true;
   });
 
   // Group imports by their actual service directory (models may live in different services)
@@ -414,16 +436,33 @@ function generateServiceTest(
       const fixtureName = `${fileName(modelName)}.json`;
       const modelClass = className(modelName);
 
+      // For discriminated union responses, resolve to the concrete variant class
+      const resolvedClass = resolvePaginatedItemClass(modelName, spec) ?? modelClass;
+      // Pick assertable fields from the resolved variant, not the dispatcher
+      const resolvedModelName =
+        resolvedClass !== modelClass
+          ? (() => {
+              const responseModel = spec.models.find((m) => m.name === modelName);
+              const disc = (responseModel as any)?.discriminator as { mapping: Record<string, string> } | undefined;
+              if (disc) {
+                for (const variantName of Object.values(disc.mapping)) {
+                  if (className(variantName) === resolvedClass) return variantName;
+                }
+              }
+              return modelName;
+            })()
+          : modelName;
+
       lines.push(`    def test_${method}(self, workos, httpx_mock):`);
       lines.push(`        httpx_mock.add_response(`);
       lines.push(`            json=load_fixture("${fixtureName}"),`);
       lines.push('        )');
       const args = buildTestArgs(op, spec, hiddenParams);
       lines.push(`        result = workos.${propName}.${method}(${args})`);
-      lines.push(`        assert isinstance(result, ${modelClass})`);
+      lines.push(`        assert isinstance(result, ${resolvedClass})`);
 
       // Field-value assertions: verify at least 2 scalar fields from fixture
-      const assertFields = pickAssertableFields(modelName, spec);
+      const assertFields = pickAssertableFields(resolvedModelName, spec);
       for (const af of assertFields) {
         const op_ = af.isBool ? 'is' : '==';
         lines.push(`        assert result.${af.field} ${op_} ${af.value}`);
@@ -706,12 +745,29 @@ function generateServiceTest(
       const modelName = plan.responseModelName;
       const fixtureName = `${fileName(modelName)}.json`;
       const modelClass = className(modelName);
+
+      // For discriminated union responses, resolve to the concrete variant class
+      const asyncResolvedClass = resolvePaginatedItemClass(modelName, spec) ?? modelClass;
+      const asyncResolvedModelName =
+        asyncResolvedClass !== modelClass
+          ? (() => {
+              const responseModel = spec.models.find((m) => m.name === modelName);
+              const disc = (responseModel as any)?.discriminator as { mapping: Record<string, string> } | undefined;
+              if (disc) {
+                for (const variantName of Object.values(disc.mapping)) {
+                  if (className(variantName) === asyncResolvedClass) return variantName;
+                }
+              }
+              return modelName;
+            })()
+          : modelName;
+
       pushAsyncTestDef(lines, `    async def test_${method}(self, async_workos, httpx_mock):`);
       lines.push(`        httpx_mock.add_response(json=load_fixture("${fixtureName}"))`);
       lines.push(`        result = await async_workos.${propName}.${method}(${asyncArgs})`);
-      lines.push(`        assert isinstance(result, ${modelClass})`);
+      lines.push(`        assert isinstance(result, ${asyncResolvedClass})`);
       // Field-value assertions
-      const assertFields = pickAssertableFields(modelName, spec);
+      const assertFields = pickAssertableFields(asyncResolvedModelName, spec);
       for (const af of assertFields) {
         const op_ = af.isBool ? 'is' : '==';
         lines.push(`        assert result.${af.field} ${op_} ${af.value}`);
@@ -889,7 +945,9 @@ function emitWrapperTests(
     for (const wrapper of r.wrappers) {
       const method = wrapper.name;
       const wrapperParams = resolveWrapperParams(wrapper, ctx);
-      const responseType = wrapper.responseModelName ? className(wrapper.responseModelName) : null;
+      const resolvedResponseClass = wrapper.responseModelName
+        ? (resolvePaginatedItemClass(wrapper.responseModelName, spec) ?? className(wrapper.responseModelName))
+        : null;
       const fixtureName = wrapper.responseModelName ? `${fileName(wrapper.responseModelName)}.json` : null;
 
       // Build test args for required wrapper params
@@ -908,8 +966,8 @@ function emitWrapperTests(
         if (fixtureName) {
           lines.push(`        httpx_mock.add_response(json=load_fixture("${fixtureName}"))`);
           lines.push(`        result = await async_workos.${propName}.${method}(${args})`);
-          if (responseType) {
-            lines.push(`        assert isinstance(result, ${responseType})`);
+          if (resolvedResponseClass) {
+            lines.push(`        assert isinstance(result, ${resolvedResponseClass})`);
           }
         } else {
           lines.push('        httpx_mock.add_response(json={})');
@@ -920,8 +978,8 @@ function emitWrapperTests(
         if (fixtureName) {
           lines.push(`        httpx_mock.add_response(json=load_fixture("${fixtureName}"))`);
           lines.push(`        result = workos.${propName}.${method}(${args})`);
-          if (responseType) {
-            lines.push(`        assert isinstance(result, ${responseType})`);
+          if (resolvedResponseClass) {
+            lines.push(`        assert isinstance(result, ${resolvedResponseClass})`);
           }
         } else {
           lines.push('        httpx_mock.add_response(json={})');

package/src/python/wrappers.ts

@@ -1,4 +1,4 @@
-import type { EmitterContext, ResolvedOperation, ResolvedWrapper } from '@workos/oagen';
+import type { EmitterContext, ResolvedOperation, ResolvedWrapper, Model } from '@workos/oagen';
 import { toSnakeCase } from '@workos/oagen';
 import { className, fieldName } from './naming.js';
 import { resolveWrapperParams, formatWrapperDescription } from '../shared/wrapper-utils.js';
@@ -75,8 +75,15 @@ function emitWrapperMethod(
 
   lines.push('        request_options: Optional[RequestOptions] = None,');
 
-  // Return type
-  const responseType = wrapper.responseModelName ? className(wrapper.responseModelName) : 'None';
+  // Return type — use Variant type for discriminated union responses
+  const isDiscriminatorResponse = wrapper.responseModelName
+    ? !!(ctx.spec.models.find((m: Model) => m.name === wrapper.responseModelName) as any)?.discriminator
+    : false;
+  const responseType = wrapper.responseModelName
+    ? isDiscriminatorResponse
+      ? className(wrapper.responseModelName) + 'Variant'
+      : className(wrapper.responseModelName)
+    : 'None';
 
   lines.push(`    ) -> ${responseType}:`);
 
@@ -122,7 +129,21 @@ function emitWrapperMethod(
   const awaitPrefix = isAsync ? 'await ' : '';
   lines.push('');
 
-  if (wrapper.responseModelName) {
+  if (wrapper.responseModelName && isDiscriminatorResponse) {
+    const variantType = className(wrapper.responseModelName) + 'Variant';
+    lines.push(`        return cast(`);
+    lines.push(`            ${variantType},`);
+    lines.push(`            ${awaitPrefix}self._client.request(`);
+    lines.push(`                method="${op.httpMethod.toUpperCase()}",`);
+    lines.push(`                path=${pathExpr},`);
+    lines.push('                body=body,');
+    lines.push(
+      `                model=${className(wrapper.responseModelName)},  # type: ignore[arg-type]  # dispatcher; request only calls from_dict`,
+    );
+    lines.push('                request_options=request_options,');
+    lines.push('            )');
+    lines.push('        )');
+  } else if (wrapper.responseModelName) {
     lines.push(`        return ${awaitPrefix}self._client.request(`);
     lines.push(`            method="${op.httpMethod.toUpperCase()}",`);
     lines.push(`            path=${pathExpr},`);

package/src/ruby/client.ts

@@ -27,7 +27,6 @@ import { NON_SPEC_SERVICES } from '../shared/non-spec-services.js';
  */
 const NON_SPEC_ACCESSORS: Record<string, { prop: string; className: string; ctorArg: 'self' | '' }> = {
   passwordless: { prop: 'passwordless', className: 'Passwordless', ctorArg: 'self' },
-  vault: { prop: 'vault', className: 'Vault', ctorArg: 'self' },
   actions: { prop: 'actions', className: 'Actions', ctorArg: 'self' },
   session_manager: { prop: 'session_manager', className: 'SessionManager', ctorArg: 'self' },
   pkce: { prop: 'pkce', className: 'PKCE', ctorArg: '' },

package/src/rust/resources.ts

@@ -355,6 +355,7 @@ function renderParamsStruct(
 ): string {
   const bodyRequired = isBodyRequired(op);
   const hidden = new Set<string>([...Object.keys(resolved.defaults ?? {}), ...(resolved.inferFromClient ?? [])]);
+  const materializeSpecDefaults = !resolved.urlBuilder;
 
   // Names of params that belong to a parameter group; these are folded into
   // the enum field and must be omitted from the flat params struct.
@@ -412,9 +413,14 @@ function renderParamsStruct(
     });
     if (!p.required && !rust.startsWith('Option<')) rust = makeOptional(rust);
     rust = applySecretRedaction(rust, p.name);
-    // Spec-level default → materialise it as a Rust expression so
-    // `Default::default()` and `new(…)` actually produce the documented value.
-    const defaultExpr = p.default != null ? rustDefaultExpr(p.default, p.type, rust.startsWith('Option<'), ctx) : null;
+    // Spec-level defaults on HTTP params are materialized so
+    // `Default::default()` and `new(…)` produce the documented value. URL
+    // builders keep optional query params omitted unless the caller supplies
+    // them, because the query string is the public redirect target.
+    const defaultExpr =
+      materializeSpecDefaults && p.default != null
+        ? rustDefaultExpr(p.default, p.type, rust.startsWith('Option<'), ctx)
+        : null;
     // Field-level documentation derived from the spec.
     const desc = p.description?.trim();
     if (desc) {
@@ -1317,10 +1323,7 @@ function renderResourcesBarrel(exports: { module: string; struct: string }[]): s
   unique.sort((a, b) => a.module.localeCompare(b.module));
 
   const lines: string[] = [];
-  // Declare modules privately — see the matching comment in `models.ts`.
-  // `pub mod resources::organization_membership` would collide with the
-  // same-named module re-exported via `pub use models::*` in lib.rs.
-  for (const { module } of unique) lines.push(`mod ${module};`);
+  for (const { module } of unique) lines.push(`pub mod ${module};`);
   lines.push('');
   for (const { module, struct } of unique) lines.push(`pub use ${module}::${struct};`);
   return lines.join('\n') + '\n';

package/src/shared/non-spec-services.ts

@@ -42,11 +42,6 @@ export const NON_SPEC_SERVICES: readonly NonSpecService[] = [
     description: 'Passwordless (magic-link) session endpoints, not yet in the OpenAPI spec.',
     hasClientAccessor: true,
   },
-  {
-    id: 'vault',
-    description: 'Vault KV storage, key operations, and client-side AES-GCM encrypt/decrypt.',
-    hasClientAccessor: true,
-  },
   {
     id: 'webhook_verification',
     description: 'Webhook signature verification and event deserialization (H01/H02).',

package/test/go/enums.test.ts

@@ -129,4 +129,28 @@ describe('go/enums', () => {
     const content = files[0].content;
     expect(content).toContain('type SSOConnectionType string');
   });
+
+  it('generates an events compatibility package from webhook event enum values', () => {
+    const enums: Enum[] = [
+      {
+        name: 'CreateWebhookEndpointEvents',
+        values: [
+          { name: 'USER_CREATED', value: 'user.created' },
+          { name: 'API_KEY_CREATED', value: 'api_key.created' },
+          { name: 'DSYNC_USER_CREATED', value: 'dsync.user.created' },
+        ],
+      },
+    ];
+
+    const files = generateEnums(enums, ctx);
+    const compat = files.find((file) => file.path === 'pkg/events/events.go');
+
+    expect(compat).toBeDefined();
+    expect(compat!.content).toContain('package events');
+    expect(compat!.content).toContain('type Event string');
+    expect(compat!.content).toContain('UserCreated = "user.created"');
+    expect(compat!.content).toContain('APIKeyCreated = "api_key.created"');
+    expect(compat!.content).toContain('DsyncUserCreated = "dsync.user.created"');
+    expect(compat!.content).not.toContain('CreateWebhookEndpointEventsUserCreated');
+  });
 });

package/test/node/resources.test.ts

@@ -101,7 +101,9 @@ describe('generateResources', () => {
     expect(resourceFile).toBeDefined();
     expect(resourceFile!.content).toContain('export class Organizations');
     expect(resourceFile!.content).toContain('constructor(private readonly workos: WorkOS)');
-    expect(resourceFile!.content).toContain('async getOrganization(id: string): Promise<Organization>');
+    expect(resourceFile!.content).toContain(
+      'async getOrganization(options: GetOrganizationOptions): Promise<Organization>',
+    );
     expect(resourceFile!.content).toContain('deserializeOrganization(data)');
   });
 
@@ -154,6 +156,14 @@ describe('generateResources', () => {
     const ctxWithResolved: EmitterContext = {
       ...ctx,
       spec,
+      emitterOptions: {
+        operationOverrides: {
+          'GET /user_management/organization_memberships/{omId}/groups': {
+            methodName: 'list_groups_for_organization_membership',
+            mountOn: 'UserManagement',
+          },
+        },
+      },
       resolvedOperations: [
         {
           operation,

package/test/node/tests.test.ts

@@ -86,7 +86,7 @@ describe('node test generation ownership', () => {
     }
   });
 
-  it('preserves existing hand-written tests and fixtures for owned services', () => {
+  it('regenerates over hand-written tests and fixtures for owned services', () => {
     const tmpRoot = createTrackedSdkRoot(true);
     try {
       const result = nodeEmitter.generateTests!(spec, {
@@ -95,8 +95,8 @@ describe('node test generation ownership', () => {
         emitterOptions: { ownedServices: ['Groups'], regenerateOwnedTests: true },
       } as EmitterContext);
 
-      expect(result.some((f) => f.path === 'src/groups/groups.spec.ts')).toBe(false);
-      expect(result.some((f) => f.path === 'src/groups/fixtures/group.json')).toBe(false);
+      expect(result.some((f) => f.path === 'src/groups/groups.spec.ts')).toBe(true);
+      expect(result.some((f) => f.path === 'src/groups/fixtures/group.json')).toBe(true);
     } finally {
       fs.rmSync(tmpRoot, { recursive: true, force: true });
     }

package/test/php/client.test.ts

@@ -86,7 +86,6 @@ describe('generateClient', () => {
     const result = generateClient(emptySpec, ctx);
 
     expect(result[0].content).toContain('public function passwordless(): Passwordless');
-    expect(result[0].content).toContain('public function vault(): Vault');
     expect(result[0].content).toContain('public function webhookVerification(): WebhookVerification');
     expect(result[0].content).toContain('public function actions(): Actions');
     expect(result[0].content).toContain('public function sessionManager(): SessionManager');

package/test/php/resources.test.ts

@@ -217,6 +217,56 @@ describe('generateResources', () => {
     expect(content).not.toMatch(/PaginationOrder::Desc/);
   });
 
+  it('does not materialize optional query defaults for URL builders', () => {
+    const screenHintEnum = {
+      name: 'UserManagementAuthenticationScreenHint',
+      values: [
+        { name: 'sign_in', value: 'sign-in' },
+        { name: 'sign_up', value: 'sign-up' },
+      ],
+    };
+    const op = {
+      name: 'getAuthorizationUrl',
+      httpMethod: 'get' as const,
+      path: '/user_management/authorize',
+      pathParams: [],
+      queryParams: [
+        { name: 'redirect_uri', type: { kind: 'primitive' as const, type: 'string' as const }, required: true },
+        {
+          name: 'screen_hint',
+          type: { kind: 'enum' as const, name: 'UserManagementAuthenticationScreenHint' },
+          required: false,
+          default: 'sign-in',
+        },
+      ],
+      headerParams: [],
+      response: { kind: 'primitive' as const, type: 'unknown' as const },
+      errors: [],
+      injectIdempotencyKey: false,
+    };
+    const service: Service = { name: 'UserManagement', operations: [op] };
+    const spec: ApiSpec = { ...emptySpec, enums: [screenHintEnum], services: [service] };
+    const content = generateResources([service], {
+      ...ctx,
+      spec,
+      resolvedOperations: [
+        {
+          operation: op,
+          service,
+          methodName: 'get_authorization_url',
+          mountOn: 'UserManagement',
+          defaults: { response_type: 'code' },
+          inferFromClient: ['client_id'],
+          urlBuilder: true,
+        },
+      ],
+    })[0].content;
+
+    expect(content).toContain('?\\WorkOS\\Resource\\UserManagementAuthenticationScreenHint $screenHint = null');
+    expect(content).toContain("'screen_hint' => $screenHint?->value");
+    expect(content).not.toContain('UserManagementAuthenticationScreenHint::SignIn');
+  });
+
   it('generates paginated list method', () => {
     const result = generateResources(services, ctx);
 

package/test/rust/resources.test.ts

@@ -319,6 +319,12 @@ describe('rust/resources', () => {
                 type: { kind: 'primitive', type: 'string' },
                 required: true,
               },
+              {
+                name: 'screen_hint',
+                type: { kind: 'enum', name: 'UserManagementAuthenticationScreenHint' },
+                required: false,
+                default: 'sign-in',
+              },
               {
                 name: 'state',
                 type: { kind: 'primitive', type: 'string' },
@@ -347,6 +353,9 @@ describe('rust/resources', () => {
     expect(f.content).toContain('pub fn get_authorization_url(');
     expect(f.content).toContain('-> Result<String, Error>');
     expect(f.content).toContain('let qs = crate::query::encode_query');
+    expect(f.content).toContain('pub screen_hint: Option<UserManagementAuthenticationScreenHint>,');
+    expect(f.content).toContain('screen_hint: Default::default(),');
+    expect(f.content).not.toContain('screen_hint: Some(UserManagementAuthenticationScreenHint::SignIn)');
     expect(f.content).not.toContain('get_authorization_url_with_options');
     expect(f.content).not.toContain('request_with_query_opts');
   });