@workos/oagen-emitters 0.2.1 → 0.3.0

package/src/python/type-map.ts

@@ -0,0 +1,93 @@
+import type { TypeRef, PrimitiveType, UnionType } from '@workos/oagen';
+import { mapTypeRef as irMapTypeRef } from '@workos/oagen';
+import { className } from './naming.js';
+
+/**
+ * Map an IR TypeRef to a Python type hint string.
+ * Uses standard library types: str, int, float, bool, List, Dict, Optional, Union.
+ */
+export function mapTypeRef(ref: TypeRef): string {
+  return irMapTypeRef<string>(ref, {
+    primitive: mapPrimitive,
+    array: (ref, items) => {
+      void ref;
+      return `List[${items}]`;
+    },
+    model: (r) => `"${className(r.name)}"`,
+    enum: (r) => `"${className(r.name)}"`,
+    union: (r, variants) => joinUnionVariants(r, variants),
+    nullable: (ref, inner) => {
+      void ref;
+      return `Optional[${inner}]`;
+    },
+    literal: (r) =>
+      typeof r.value === 'string' ? `Literal["${r.value}"]` : r.value === null ? 'None' : `Literal[${String(r.value)}]`,
+    map: (ref, value) => {
+      void ref;
+      return `Dict[str, ${value}]`;
+    },
+  });
+}
+
+/**
+ * Map an IR TypeRef to a plain Python type string (no quotes around model/enum refs).
+ * Used for import collection and direct type references.
+ */
+export function mapTypeRefUnquoted(ref: TypeRef, knownEnums?: Set<string>, allowRawEnumStrings = false): string {
+  return irMapTypeRef<string>(ref, {
+    primitive: mapPrimitive,
+    array: (ref, items) => {
+      void ref;
+      return `List[${items}]`;
+    },
+    model: (r) => className(r.name),
+    enum: (r) => {
+      if (knownEnums && !knownEnums.has(r.name)) return 'str';
+      const enumType = className(r.name);
+      return allowRawEnumStrings ? `Union[${enumType}, str]` : enumType;
+    },
+    union: (r, variants) => joinUnionVariants(r, variants),
+    nullable: (ref, inner) => {
+      void ref;
+      return `Optional[${inner}]`;
+    },
+    literal: (r) =>
+      typeof r.value === 'string' ? `Literal["${r.value}"]` : r.value === null ? 'None' : `Literal[${String(r.value)}]`,
+    map: (ref, value) => {
+      void ref;
+      return `Dict[str, ${value}]`;
+    },
+  });
+}
+
+function mapPrimitive(ref: PrimitiveType): string {
+  if (ref.format) {
+    switch (ref.format) {
+      case 'binary':
+        return 'bytes';
+    }
+  }
+  switch (ref.type) {
+    case 'string':
+      return 'str';
+    case 'integer':
+      return 'int';
+    case 'number':
+      return 'float';
+    case 'boolean':
+      return 'bool';
+    case 'unknown':
+      return 'Any';
+  }
+}
+
+function joinUnionVariants(ref: UnionType, variants: string[]): string {
+  if (ref.compositionKind === 'allOf') {
+    // Python doesn't have intersection types; use the first variant
+    return variants[0] ?? 'Any';
+  }
+  // Deduplicate identical variants (e.g., Union[Foo, Foo] -> Foo)
+  const unique = [...new Set(variants)];
+  if (unique.length === 1) return unique[0];
+  return `Union[${unique.join(', ')}]`;
+}

package/src/python/wrappers.ts

@@ -0,0 +1,191 @@
+import type { EmitterContext, ResolvedOperation, ResolvedWrapper } from '@workos/oagen';
+import { toSnakeCase } from '@workos/oagen';
+import { className, fieldName } from './naming.js';
+import { resolveWrapperParams, formatWrapperDescription } from '../shared/wrapper-utils.js';
+
+/**
+ * Generate Python wrapper method lines for split operations.
+ *
+ * Each wrapper is a typed convenience method that:
+ * - Accepts only the exposed params (not the full union body)
+ * - Injects constant defaults (e.g., grant_type)
+ * - Reads inferred fields from client config (e.g., client_id)
+ * - Delegates to the HTTP client with the constructed body
+ *
+ * Generates both sync and async versions.
+ */
+export function generateSyncWrapperMethods(resolvedOp: ResolvedOperation, ctx: EmitterContext): string[] {
+  return generateWrapperMethodsInner(resolvedOp, ctx, false);
+}
+
+export function generateAsyncWrapperMethods(resolvedOp: ResolvedOperation, ctx: EmitterContext): string[] {
+  return generateWrapperMethodsInner(resolvedOp, ctx, true);
+}
+
+function generateWrapperMethodsInner(resolvedOp: ResolvedOperation, ctx: EmitterContext, isAsync: boolean): string[] {
+  if (!resolvedOp.wrappers || resolvedOp.wrappers.length === 0) return [];
+
+  const lines: string[] = [];
+
+  for (const wrapper of resolvedOp.wrappers) {
+    lines.push('');
+    emitWrapperMethod(lines, resolvedOp, wrapper, ctx, isAsync);
+  }
+
+  return lines;
+}
+
+function emitWrapperMethod(
+  lines: string[],
+  resolvedOp: ResolvedOperation,
+  wrapper: ResolvedWrapper,
+  ctx: EmitterContext,
+  isAsync: boolean,
+): void {
+  const op = resolvedOp.operation;
+  const method = wrapper.name; // already snake_case
+  const wrapperParams = resolveWrapperParams(wrapper, ctx);
+
+  // Build signature
+  const defKeyword = isAsync ? 'async def' : 'def';
+  lines.push(`    ${defKeyword} ${method}(`);
+  lines.push('        self,');
+
+  // Path params as positional args
+  for (const param of op.pathParams) {
+    const paramName = fieldName(param.name);
+    const paramType = resolveSimpleType(param.type);
+    lines.push(`        ${paramName}: ${paramType},`);
+  }
+
+  lines.push('        *,');
+
+  // Exposed params as keyword args
+  for (const { paramName, field, isOptional } of wrapperParams) {
+    const pyName = fieldName(paramName);
+    const pyType = field ? resolveSimpleType(field.type) : 'str';
+
+    if (isOptional) {
+      lines.push(`        ${pyName}: Optional[${pyType}] = None,`);
+    } else {
+      lines.push(`        ${pyName}: ${pyType},`);
+    }
+  }
+
+  lines.push('        request_options: Optional[RequestOptions] = None,');
+
+  // Return type
+  const responseType = wrapper.responseModelName ? className(wrapper.responseModelName) : 'None';
+
+  lines.push(`    ) -> ${responseType}:`);
+
+  // Docstring
+  lines.push(`        """${formatWrapperDescription(wrapper.name)}."""`);
+
+  // Build body dict
+  lines.push('        body: Dict[str, Any] = {');
+
+  // Constant defaults
+  for (const [key, value] of Object.entries(wrapper.defaults)) {
+    lines.push(`            "${key}": ${pythonLiteral(value)},`);
+  }
+
+  // Exposed params (required ones go directly)
+  for (const { paramName, isOptional } of wrapperParams) {
+    if (isOptional) continue;
+    const pyName = fieldName(paramName);
+    lines.push(`            "${paramName}": ${pyName},`);
+  }
+
+  lines.push('        }');
+
+  // Inferred fields from client config
+  for (const field of wrapper.inferFromClient) {
+    const expr = clientFieldExpression(field);
+    lines.push(`        if ${expr} is not None:`);
+    lines.push(`            body["${field}"] = ${expr}`);
+  }
+
+  // Optional exposed params
+  for (const { paramName, isOptional } of wrapperParams) {
+    if (!isOptional) continue;
+    const pyName = fieldName(paramName);
+    lines.push(`        if ${pyName} is not None:`);
+    lines.push(`            body["${paramName}"] = ${pyName}`);
+  }
+
+  // Build path expression
+  let pathExpr: string;
+  if (op.pathParams.length > 0) {
+    let path = op.path.replace(/^\//, '');
+    for (const p of op.pathParams) {
+      path = path.replace(`{${p.name}}`, `{${fieldName(p.name)}}`);
+    }
+    pathExpr = `f"${path}"`;
+  } else {
+    pathExpr = `"${op.path.replace(/^\//, '')}"`;
+  }
+
+  // Make the request
+  const awaitPrefix = isAsync ? 'await ' : '';
+  lines.push('');
+
+  if (wrapper.responseModelName) {
+    lines.push(`        return ${awaitPrefix}self._client.request(`);
+    lines.push(`            method="${op.httpMethod.toUpperCase()}",`);
+    lines.push(`            path=${pathExpr},`);
+    lines.push('            body=body,');
+    lines.push(`            model=${className(wrapper.responseModelName)},`);
+    lines.push('            request_options=request_options,');
+    lines.push('        )');
+  } else {
+    lines.push(`        ${awaitPrefix}self._client.request(`);
+    lines.push(`            method="${op.httpMethod.toUpperCase()}",`);
+    lines.push(`            path=${pathExpr},`);
+    lines.push('            body=body,');
+    lines.push('            request_options=request_options,');
+    lines.push('        )');
+  }
+}
+
+/** Convert a value to a Python literal. */
+export function pythonLiteral(value: string | number | boolean): string {
+  if (typeof value === 'string') return `"${value.replace(/"/g, '\\"')}"`;
+  if (typeof value === 'boolean') return value ? 'True' : 'False';
+  return String(value);
+}
+
+/** Get the Python expression for reading a client config field. */
+export function clientFieldExpression(field: string): string {
+  switch (field) {
+    case 'client_id':
+      return 'self._client.client_id';
+    case 'client_secret':
+      return 'self._client._api_key';
+    default:
+      return `self._client.${toSnakeCase(field)}`;
+  }
+}
+
+/** Resolve a TypeRef to a simple Python type string. */
+function resolveSimpleType(ref: any): string {
+  if (ref.kind === 'primitive') {
+    switch (ref.type) {
+      case 'string':
+        return 'str';
+      case 'integer':
+        return 'int';
+      case 'number':
+        return 'float';
+      case 'boolean':
+        return 'bool';
+      default:
+        return 'Any';
+    }
+  }
+  if (ref.kind === 'nullable') return resolveSimpleType(ref.inner);
+  if (ref.kind === 'array') return `List[${resolveSimpleType(ref.items)}]`;
+  if (ref.kind === 'model') return className(ref.name);
+  if (ref.kind === 'enum') return className(ref.name);
+  return 'Any';
+}

package/src/shared/model-utils.ts

@@ -0,0 +1,255 @@
+import type { Model, Field, TypeRef } from '@workos/oagen';
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+// @ts-ignore -- js-yaml has no type declarations in this project
+import { load as yamlLoad } from 'js-yaml';
+
+/**
+ * Detect whether a model is a list wrapper -- the standard paginated
+ * list envelope with `data` (array), `list_metadata`, and optionally `object: 'list'`.
+ *
+ * These models are redundant because each language SDK already has its own
+ * pagination wrapper, and the runtime handles deserialization.
+ */
+export function isListWrapperModel(model: Model): boolean {
+  const fieldsByName = new Map(model.fields.map((f) => [f.name, f]));
+
+  // Must have a `data` field that is an array type
+  const dataField = fieldsByName.get('data');
+  if (!dataField) return false;
+  if (dataField.type.kind !== 'array') return false;
+
+  // Must have a `list_metadata` field (IR may use snake_case or camelCase)
+  const listMetadataField = fieldsByName.get('list_metadata') ?? fieldsByName.get('listMetadata');
+  if (!listMetadataField) return false;
+
+  // Optionally has an `object` field with literal value 'list'
+  const objectField = fieldsByName.get('object');
+  if (objectField) {
+    if (objectField.type.kind !== 'literal' || objectField.type.value !== 'list') {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Detect whether a model is a list metadata model (e.g., ListMetadata).
+ * These models typically have exactly `before` and `after` nullable string fields.
+ */
+export function isListMetadataModel(model: Model): boolean {
+  if (model.fields.length !== 2) return false;
+
+  const fieldsByName = new Map(model.fields.map((f) => [f.name, f]));
+  const before = fieldsByName.get('before');
+  const after = fieldsByName.get('after');
+
+  if (!before || !after) return false;
+
+  return isNullableString(before) && isNullableString(after);
+}
+
+/** Check if a field type is nullable string (nullable<string> or just string). */
+function isNullableString(field: Field): boolean {
+  if (field.type.kind === 'primitive' && field.type.type === 'string') return true;
+  if (field.type.kind === 'nullable' && field.type.inner.kind === 'primitive' && field.type.inner.type === 'string')
+    return true;
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// oneOf / allOf+oneOf flattening
+// ---------------------------------------------------------------------------
+
+/**
+ * Discover the OpenAPI spec path from CLI args or environment.
+ * Returns null if not found.
+ */
+function discoverSpecPath(): string | null {
+  // Check --spec CLI arg
+  const args = process.argv;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--spec' && args[i + 1]) return resolve(args[i + 1]);
+    if (args[i]?.startsWith('--spec=')) return resolve(args[i].slice('--spec='.length));
+  }
+  // Check OPENAPI_SPEC_PATH env
+  if (process.env.OPENAPI_SPEC_PATH) return resolve(process.env.OPENAPI_SPEC_PATH);
+  return null;
+}
+
+/** Cached raw spec to avoid re-reading on multiple calls. */
+let _rawSpecCache: Record<string, any> | null = null;
+let _rawSpecLoaded = false;
+
+function loadRawSpec(): Record<string, any> | null {
+  if (_rawSpecLoaded) return _rawSpecCache;
+  _rawSpecLoaded = true;
+  const specPath = discoverSpecPath();
+  if (!specPath || !existsSync(specPath)) return null;
+  try {
+    const content = readFileSync(specPath, 'utf-8');
+    _rawSpecCache = yamlLoad(content) as Record<string, any>;
+    return _rawSpecCache;
+  } catch {
+    return null;
+  }
+}
+
+/** Look up a schema by name in the raw spec's components/schemas. */
+function lookupRawSchema(name: string): Record<string, any> | null {
+  const spec = loadRawSpec();
+  if (!spec) return null;
+  return spec?.components?.schemas?.[name] ?? null;
+}
+
+/** Convert a raw OpenAPI type+format to an IR TypeRef. */
+function rawSchemaToTypeRef(schema: Record<string, any>): TypeRef {
+  if (schema.const !== undefined) {
+    return { kind: 'literal', value: schema.const };
+  }
+  if (schema.enum) {
+    // Simple string enum -- represent as primitive string
+    return { kind: 'primitive', type: 'string' } as TypeRef;
+  }
+  if (schema.$ref) {
+    const refName = schema.$ref.split('/').pop()!;
+    return { kind: 'model', name: refName } as TypeRef;
+  }
+
+  // Handle nullable type arrays like [string, null]
+  let baseType = schema.type;
+  let isNullable = false;
+  if (Array.isArray(baseType)) {
+    const nonNull = baseType.filter((t: string) => t !== 'null');
+    isNullable = baseType.includes('null');
+    baseType = nonNull[0] ?? 'string';
+  }
+
+  let ref: TypeRef;
+  if (baseType === 'object' && schema.properties) {
+    // Inline object -- treat as unknown
+    ref = { kind: 'primitive', type: 'unknown' } as TypeRef;
+  } else if (baseType === 'array' && schema.items) {
+    ref = { kind: 'array', items: rawSchemaToTypeRef(schema.items) } as TypeRef;
+  } else if (baseType === 'boolean') {
+    ref = { kind: 'primitive', type: 'boolean' } as TypeRef;
+  } else if (baseType === 'integer' || baseType === 'number') {
+    ref = { kind: 'primitive', type: baseType } as TypeRef;
+  } else {
+    ref = { kind: 'primitive', type: 'string' } as TypeRef;
+  }
+
+  if (isNullable) {
+    return { kind: 'nullable', inner: ref } as TypeRef;
+  }
+  return ref;
+}
+
+/**
+ * Extract fields from a raw OpenAPI object schema.
+ * All fields are returned as optional (not required) since they come from
+ * oneOf variants where only one variant is active at a time.
+ */
+function extractFieldsFromRawSchema(schema: Record<string, any>): Field[] {
+  const fields: Field[] = [];
+  const props = schema.properties ?? {};
+  for (const [name, propSchema] of Object.entries(props) as [string, Record<string, any>][]) {
+    fields.push({
+      name,
+      type: rawSchemaToTypeRef(propSchema),
+      required: false, // All oneOf variant fields are optional
+      description: propSchema.description,
+      deprecated: propSchema.deprecated,
+    });
+  }
+  return fields;
+}
+
+/**
+ * Recursively collect all fields from a oneOf schema, flattening nested
+ * allOf+oneOf compositions. All fields are marked optional.
+ */
+function collectOneOfFields(schema: Record<string, any>): Field[] {
+  const allFields: Field[] = [];
+  const seenFieldNames = new Set<string>();
+
+  function walkSchema(s: Record<string, any>): void {
+    // Direct properties
+    if (s.properties) {
+      for (const f of extractFieldsFromRawSchema(s)) {
+        if (!seenFieldNames.has(f.name)) {
+          seenFieldNames.add(f.name);
+          allFields.push(f);
+        }
+      }
+    }
+    // allOf composition
+    if (s.allOf) {
+      for (const sub of s.allOf) {
+        walkSchema(sub);
+      }
+    }
+    // oneOf composition (flatten all variants)
+    if (s.oneOf) {
+      for (const variant of s.oneOf) {
+        walkSchema(variant);
+      }
+    }
+    // anyOf composition
+    if (s.anyOf) {
+      for (const variant of s.anyOf) {
+        walkSchema(variant);
+      }
+    }
+  }
+
+  walkSchema(schema);
+  return allFields;
+}
+
+/**
+ * Enrich IR models by flattening oneOf/allOf+oneOf variant fields from the raw spec.
+ *
+ * For models with 0 fields whose raw spec schema is a pure oneOf:
+ *   - Collect all variant fields and add them as optional fields.
+ *
+ * For models whose raw spec schema has allOf containing a oneOf:
+ *   - Collect the missing variant fields and add them as optional.
+ *
+ * Returns a new array of enriched models (original models are not mutated).
+ */
+export function enrichModelsFromSpec(models: Model[]): Model[] {
+  const spec = loadRawSpec();
+  if (!spec) return models;
+
+  return models.map((model) => {
+    const rawSchema = lookupRawSchema(model.name);
+    if (!rawSchema) return model;
+
+    const hasOneOf = rawSchema.oneOf || rawSchema.allOf?.some((s: any) => s.oneOf);
+    if (!hasOneOf) return model;
+
+    // Skip schemas with discriminator -- those are intentional unions
+    const hasDiscriminator =
+      rawSchema.discriminator ||
+      rawSchema.oneOf?.some((v: any) => v.discriminator) ||
+      rawSchema.allOf?.some((s: any) => s.discriminator || s.oneOf?.some((v: any) => v.discriminator));
+    if (hasDiscriminator) return model;
+
+    // Collect all variant fields from the raw schema
+    const variantFields = collectOneOfFields(rawSchema);
+    if (variantFields.length === 0) return model;
+
+    // Merge variant fields into the existing model, skipping duplicates
+    const existingNames = new Set(model.fields.map((f) => f.name));
+    const newFields = variantFields.filter((f) => !existingNames.has(f.name));
+
+    if (newFields.length === 0) return model;
+
+    return {
+      ...model,
+      fields: [...model.fields, ...newFields],
+    };
+  });
+}

package/src/shared/naming-utils.ts

@@ -0,0 +1,107 @@
+/** Strip URN OAuth grant-type prefixes from discriminator-derived schema names. */
+export function stripUrnPrefix(name: string): string {
+  // Handles both OAuth and Oauth casing from different PascalCase implementations
+  return name.replace(/^Urn(?:IetfParams|Workos)O[Aa]uthGrantType/, '');
+}
+
+/**
+ * Build the GoDoc prefix for a field comment.
+ * If the description already starts with a verb (e.g., "Distinguishes...", "Indicates..."),
+ * returns just the lowered description. Otherwise prepends "is ".
+ *
+ *   fieldDocComment("ID", "the unique identifier")   → "ID is the unique identifier"
+ *   fieldDocComment("Object", "Distinguishes the X")  → "Object distinguishes the X"
+ */
+export function fieldDocComment(fieldName: string, description: string): string {
+  const lowered = lowerFirstForDoc(description);
+  if (startsWithVerb(lowered)) {
+    return `${fieldName} ${lowered}`;
+  }
+  return `${fieldName} is ${lowered}`;
+}
+
+/** Known English 3rd-person-singular verbs that appear as OpenAPI description starters. */
+const VERB_STARTERS = new Set([
+  'distinguishes',
+  'indicates',
+  'represents',
+  'contains',
+  'specifies',
+  'determines',
+  'controls',
+  'defines',
+  'identifies',
+  'describes',
+  'returns',
+  'creates',
+  'deletes',
+  'updates',
+  'lists',
+  'provides',
+  'enables',
+  'disables',
+  'allows',
+  'prevents',
+  'triggers',
+  'marks',
+  'tracks',
+  'stores',
+  'holds',
+  'maps',
+  'links',
+  'connects',
+  'wraps',
+  'denotes',
+  'shows',
+  'tells',
+  'gives',
+  'takes',
+  'sets',
+  'gets',
+  'configures',
+  'manages',
+  'validates',
+  'authenticates',
+  'authorizes',
+  'verifies',
+  'limits',
+  'restricts',
+  'overrides',
+  'applies',
+]);
+
+function startsWithVerb(desc: string): boolean {
+  const firstWord = desc
+    .split(/\s/)[0]
+    .toLowerCase()
+    .replace(/[^a-z]/g, '');
+  return VERB_STARTERS.has(firstWord);
+}
+
+/**
+ * Select the correct indefinite article ("a" or "an") for a word.
+ */
+export function articleFor(word: string): string {
+  return /^[aeiou]/i.test(word) ? 'an' : 'a';
+}
+
+/**
+ * Lowercase the first character of a string for doc comments/descriptions.
+ * Handles acronyms: "SSO-specific" becomes "sso-specific" not "sSO-specific".
+ * "JSONSchema" becomes "jsonSchema", "IP Address" becomes "ip Address".
+ */
+export function lowerFirstForDoc(s: string): string {
+  if (!s) return s;
+  const acronymMatch = s.match(/^[A-Z]{2,}/);
+  if (acronymMatch) {
+    const acronym = acronymMatch[0];
+    const nextChar = s[acronym.length];
+    // If followed by a lowercase letter (e.g. "SSOAuth"), keep the last
+    // uppercase char as the start of the next camelCase word.
+    if (nextChar && /[a-z]/.test(nextChar)) {
+      return acronym.slice(0, -1).toLowerCase() + acronym.slice(-1) + s.slice(acronym.length);
+    }
+    return acronym.toLowerCase() + s.slice(acronym.length);
+  }
+  return s.charAt(0).toLowerCase() + s.slice(1);
+}

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

@@ -0,0 +1,54 @@
+/**
+ * Non-spec services: hand-maintained modules that are wired into the
+ * generated client class alongside the spec-driven service accessors.
+ *
+ * Each entry describes one hand-maintained module. Emitters translate these
+ * to language-idiomatic class names, property names, and import paths.
+ *
+ * Adding a new non-spec service here is the *only* change needed in the
+ * emitter repo — each language emitter reads this list and generates the
+ * appropriate client accessor.
+ */
+export interface NonSpecService {
+  /** Logical identifier (snake_case). Used as the canonical key. */
+  id: string;
+
+  /**
+   * Human-readable description.  Not emitted anywhere — exists so that
+   * someone reading this file understands what the service does.
+   */
+  description: string;
+}
+
+/**
+ * The canonical list of non-spec services that every SDK must expose.
+ *
+ * Order here determines emission order in the generated client.
+ */
+export const NON_SPEC_SERVICES: readonly NonSpecService[] = [
+  {
+    id: 'passwordless',
+    description: 'Passwordless (magic-link) session endpoints, not yet in the OpenAPI spec.',
+  },
+  {
+    id: 'vault',
+    description: 'Vault KV storage, key operations, and client-side AES-GCM encrypt/decrypt.',
+  },
+  {
+    id: 'webhook_verification',
+    description: 'Webhook signature verification and event deserialization (H01/H02).',
+  },
+  {
+    id: 'actions',
+    description: 'AuthKit Actions request verification and response signing (H03).',
+  },
+  {
+    id: 'session_manager',
+    description: 'Sealed session cookies, JWT validation, JWKS helpers (H04-H07, H13).',
+  },
+  {
+    id: 'pkce',
+    description:
+      'PKCE utilities, AuthKit/SSO PKCE URL builders, code exchange, public client factory (H08-H11, H15, H16, H19).',
+  },
+] as const;