typespec-rust-emitter 0.12.0 → 0.13.0

package/src/emitter.ts

@@ -3,1664 +3,26 @@ import {
   emitFile,
   resolvePath,
   navigateProgram,
-  getDoc,
-  isArrayModelType,
-  isRecordModelType,
-  getFormat,
-  getPattern,
-  Type,
   Model,
-  ModelProperty,
   Enum,
   Union,
   Scalar,
-  Program,
-  Namespace,
-  IntrinsicType,
-  StringLiteral,
-  DecoratorContext,
-  getNamespaceFullName,
-  Operation,
-  getTags,
 } from "@typespec/compiler";
-
-export interface RustEmitterOptions {
-  moduleName?: string;
-}
-
-interface RustDeriveInfo {
-  derives: string[];
-}
-
-interface RustAttrInfo {
-  attrs: string[];
-}
-
-const rustDeriveKey = Symbol("rustDerive");
-const rustAttrKey = Symbol("rustAttr");
-const rustImplKey = Symbol("rustImpl");
-const rustSelfReceiverKey = Symbol("rustSelfReceiver");
-
-type SelfReceiver = "&self" | "&mut self" | "self";
-
-interface RustImplInfo {
-  impl: string;
-}
-
-export function $rustDerive(
-  context: DecoratorContext,
-  target: Type,
-  derive: string,
-) {
-  if (target.kind !== "Model" && target.kind !== "Enum") {
-    context.program.reportDiagnostic({
-      code: "rust-derive-invalid-target",
-      message: `@rustDerive can only be applied to models and enums`,
-      severity: "error",
-      target: context.decoratorTarget,
-    });
-    return;
-  }
-
-  const ns =
-    target.kind === "Model"
-      ? target.namespace
-        ? getNamespaceFullName(target.namespace)
-        : ""
-      : target.namespace
-        ? getNamespaceFullName(target.namespace)
-        : "";
-
-  if (!ns.startsWith("TypeSpec")) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const info = (target as any)[rustDeriveKey] as RustDeriveInfo | undefined;
-    if (info) {
-      if (!info.derives.includes(derive)) {
-        info.derives.push(derive);
-      }
-    } else {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (target as any)[rustDeriveKey] = { derives: [derive] };
-    }
-  }
-}
-
-export function $rustDerives(
-  context: DecoratorContext,
-  target: Type,
-  ...derives: string[]
-) {
-  for (const derive of derives) {
-    $rustDerive(context, target, derive);
-  }
-}
-
-export function $rustAttr(
-  context: DecoratorContext,
-  target: Type,
-  attr: string,
-) {
-  if (
-    target.kind !== "Model" &&
-    target.kind !== "Enum" &&
-    target.kind !== "ModelProperty"
-  ) {
-    context.program.reportDiagnostic({
-      code: "rust-attr-invalid-target",
-      message: `@rustAttr can only be applied to models, enums, and model properties`,
-      severity: "error",
-      target: context.decoratorTarget,
-    });
-    return;
-  }
-
-  let ns: Namespace | undefined;
-  if (target.kind === "Model") {
-    ns = target.namespace;
-  } else if (target.kind === "Enum") {
-    ns = target.namespace;
-  } else if (target.kind === "ModelProperty") {
-    ns = target.model?.namespace;
-  }
-
-  const nsFullName = ns ? getNamespaceFullName(ns) : "";
-  if (!nsFullName.startsWith("TypeSpec")) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const info = (target as any)[rustAttrKey] as RustAttrInfo | undefined;
-    if (info) {
-      if (!info.attrs.includes(attr)) {
-        info.attrs.push(attr);
-      }
-    } else {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (target as any)[rustAttrKey] = { attrs: [attr] };
-    }
-  }
-}
-
-export function $rustAttrs(
-  context: DecoratorContext,
-  target: Type,
-  ...attrs: string[]
-) {
-  for (const attr of attrs) {
-    $rustAttr(context, target, attr);
-  }
-}
-
-export function $rustImpl(
-  context: DecoratorContext,
-  target: Type,
-  impl: string,
-) {
-  if (target.kind !== "Model") {
-    context.program.reportDiagnostic({
-      code: "rust-impl-invalid-target",
-      message: `@rustImpl can only be applied to models`,
-      severity: "error",
-      target: context.decoratorTarget,
-    });
-    return;
-  }
-
-  const ns = target.namespace ? getNamespaceFullName(target.namespace) : "";
-
-  if (!ns.startsWith("TypeSpec")) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (target as any)[rustImplKey] = { impl: impl };
-  }
-}
-
-export function $rustMut(context: DecoratorContext, target: Type) {
-  if (target.kind !== "Operation") {
-    context.program.reportDiagnostic({
-      code: "rust-mut-invalid-target",
-      message: `@rustMut can only be applied to operations`,
-      severity: "error",
-      target: context.decoratorTarget,
-    });
-    return;
-  }
-
-  const ns = target.namespace ? getNamespaceFullName(target.namespace) : "";
-  if (!ns.startsWith("TypeSpec")) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (target as any)[rustSelfReceiverKey] = "&mut self";
-  }
-}
-
-export function $rustOwn(context: DecoratorContext, target: Type) {
-  if (target.kind !== "Operation") {
-    context.program.reportDiagnostic({
-      code: "rust-own-invalid-target",
-      message: `@rustOwn can only be applied to operations`,
-      severity: "error",
-      target: context.decoratorTarget,
-    });
-    return;
-  }
-
-  const ns = target.namespace ? getNamespaceFullName(target.namespace) : "";
-  if (!ns.startsWith("TypeSpec")) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (target as any)[rustSelfReceiverKey] = "self";
-  }
-}
-
-type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
-
-interface OperationInfo {
-  name: string;
-  method: HttpMethod;
-  path: string;
-  tags: string[];
-  parameters: ParameterInfo[];
-  body: ModelProperty | undefined;
-  responses: ResponseInfo[];
-  doc: string | undefined;
-}
-
-interface ParameterInfo {
-  name: string;
-  rustName: string;
-  rustType: string;
-  location: "path" | "query" | "header" | "cookie";
-  required: boolean;
-  optional?: boolean;
-}
-
-interface ResponseInfo {
-  statusCode: number;
-  bodyType: string | undefined;
-  bodyDescription: string | undefined;
-  isSse?: boolean;
-}
-
-function getDecoratorName(decorator: {
-  node?: { target?: { sv?: string; kind?: string } };
-}): string {
-  if (!decorator) return "";
-  if (typeof decorator !== "object") return "";
-
-  if (decorator.node?.target?.sv) {
-    return decorator.node.target.sv;
-  }
-  if (
-    decorator.node?.target?.kind === "Identifier" &&
-    decorator.node?.target?.sv
-  ) {
-    return decorator.node.target.sv;
-  }
-
-  return "";
-}
-
-function getDecoratorArgValue(
-  decorator: {
-    args?: { jsValue?: unknown; value?: unknown }[];
-    arguments?: { jsValue?: unknown; value?: unknown }[];
-  },
-  index: number = 0,
-): string {
-  if (!decorator) return "";
-  const args = decorator.args || decorator.arguments;
-  if (!args) return "";
-  const arg = args[index];
-  if (arg?.jsValue !== undefined) return String(arg.jsValue);
-  if (arg?.value !== undefined) return String(arg.value);
-  return "";
-}
-
-function getHttpMethod(
-  _program: Program,
-  operation: Operation,
-): HttpMethod | undefined {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const decorators = (operation as any).decorators;
-  if (!decorators) return undefined;
-
-  for (const key of Object.keys(decorators)) {
-    const decorator = decorators[key];
-    const name = getDecoratorName(decorator);
-    if (name === "get") return "GET";
-    if (name === "post") return "POST";
-    if (name === "put") return "PUT";
-    if (name === "patch") return "PATCH";
-    if (name === "delete") return "DELETE";
-    if (name === "head") return "HEAD";
-  }
-  return undefined;
-}
-
-function getRoute(_program: Program, target: Namespace | Operation): string {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const decorators = (target as any).decorators;
-  if (!decorators) return "";
-
-  for (const key of Object.keys(decorators)) {
-    const decorator = decorators[key];
-    const name = getDecoratorName(decorator);
-    if (name === "route") {
-      return getDecoratorArgValue(decorator, 0);
-    }
-  }
-  return "";
-}
-
-function getFullRoute(program: Program, ns: Namespace): string {
-  const routes: string[] = [];
-  let current: Namespace | undefined = ns;
-
-  while (current) {
-    const route = getRoute(program, current);
-    if (route) {
-      routes.unshift(route);
-    }
-    current = current.namespace;
-  }
-
-  return routes.join("");
-}
-
-function hasAuthDecorator(operation: Operation): boolean {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const decorators = (operation as any).decorators;
-  if (!decorators) return false;
-
-  for (const key of Object.keys(decorators)) {
-    const decorator = decorators[key];
-    const name = getDecoratorName(decorator);
-    if (name === "useAuth") {
-      return true;
-    }
-  }
-  return false;
-}
-
-function getSelfReceiver(operation: Operation): SelfReceiver {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const receiver = (operation as any)[rustSelfReceiverKey] as
-    | SelfReceiver
-    | undefined;
-  return receiver ?? "&self";
-}
-
-function getOperationParameters(
-  program: Program,
-  operation: Operation,
-  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
-): ParameterInfo[] {
-  const params: ParameterInfo[] = [];
-  const model = operation.parameters;
-
-  for (const [propName, prop] of model.properties) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const decorators = (prop as any).decorators;
-
-    // Skip body parameters - they are handled separately
-    let isBody = false;
-    if (decorators) {
-      for (const key of Object.keys(decorators)) {
-        const decorator = decorators[key];
-        const name = getDecoratorName(decorator);
-        if (
-          name === "body" ||
-          name === "bodyRoot" ||
-          name === "multipartBody"
-        ) {
-          isBody = true;
-          break;
-        }
-      }
-    }
-    if (isBody) continue;
-
-    let location: "path" | "query" | "header" | "cookie" = "query";
-    let rustName = toRustIdent(propName);
-
-    if (decorators) {
-      for (const key of Object.keys(decorators)) {
-        const decorator = decorators[key];
-        const name = getDecoratorName(decorator);
-        if (name === "path") {
-          location = "path";
-          break;
-        } else if (name === "query") {
-          location = "query";
-          break;
-        } else if (name === "header") {
-          location = "header";
-          const headerVal = getDecoratorArgValue(decorator, 0);
-          if (headerVal) {
-            rustName = toRustIdent(headerVal);
-          }
-          break;
-        } else if (name === "cookie") {
-          location = "cookie";
-          break;
-        }
-      }
-    }
-
-    const { type: rustType } = getRustTypeForProperty(
-      prop.type,
-      program,
-      anonymousEnums,
-    );
-
-    params.push({
-      name: propName,
-      rustName,
-      rustType,
-      location,
-      required: !prop.optional,
-      optional: prop.optional,
-    });
-  }
-
-  return params;
-}
-
-function getOperationBody(operation: Operation): ModelProperty | undefined {
-  for (const [_propName, prop] of operation.parameters.properties) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const decorators = (prop as any).decorators;
-    if (!decorators) continue;
-
-    for (const key of Object.keys(decorators)) {
-      const decorator = decorators[key];
-      const name = getDecoratorName(decorator);
-      if (name === "body" || name === "bodyRoot" || name === "multipartBody") {
-        return prop;
-      }
-    }
-  }
-  return undefined;
-}
-
-function hasMultipartBody(operation: Operation): boolean {
-  for (const [_propName, prop] of operation.parameters.properties) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const decorators = (prop as any).decorators;
-    if (!decorators) continue;
-
-    for (const key of Object.keys(decorators)) {
-      const decorator = decorators[key];
-      const name = getDecoratorName(decorator);
-      if (name === "multipartBody") {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-function getOperationResponses(
-  program: Program,
-  operation: Operation,
-  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
-): ResponseInfo[] {
-  const responses: ResponseInfo[] = [];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const returnType = operation.returnType as any;
-
-  // Check for Array return type first (use runtime check since TS doesn't narrow Array)
-  if (
-    returnType.kind !== "Union" &&
-    returnType.kind !== "Model" &&
-    returnType.valueType
-  ) {
-    // This is an Array type
-    const { type: rustType } = getRustTypeForProperty(
-      returnType.valueType,
-      program,
-      anonymousEnums,
-    );
-    responses.push({
-      statusCode: 200,
-      bodyType: rustType,
-      bodyDescription: "",
-    });
-    return responses;
-  }
-
-  if (returnType.kind === "Union") {
-    const union = returnType as Union;
-    for (const variant of union.variants.values()) {
-      const statusCode = getStatusCode(variant);
-      const bodyInfo = getBodyFromResponse(variant, program, anonymousEnums);
-      responses.push({
-        statusCode,
-        bodyType: bodyInfo.type,
-        bodyDescription: bodyInfo.description,
-        isSse: bodyInfo.isSse,
-      });
-    }
-  } else if (returnType.kind === "Model") {
-    const model = returnType as Model;
-    if (model.name === "SSEStream") {
-      responses.push({
-        statusCode: 200,
-        bodyType: "axum::response::Response",
-        bodyDescription: "Server-Sent Events stream",
-        isSse: true,
-      });
-      return responses;
-    }
-    let foundStatusCode = false;
-    for (const [propName, prop] of model.properties) {
-      if (propName === "body") {
-        const { type: rustType } = getRustTypeForProperty(
-          prop.type,
-          program,
-          anonymousEnums,
-        );
-        responses.push({
-          statusCode: 200,
-          bodyType: rustType,
-          bodyDescription: getDoc(program, prop),
-        });
-      } else if (propName === "statusCode") {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const typeAny = prop.type as any;
-        if (typeAny.value !== undefined) {
-          const statusCode = typeAny.value as number;
-          responses.push({
-            statusCode,
-            bodyType: undefined,
-            bodyDescription: undefined,
-          });
-          foundStatusCode = true;
-        }
-      }
-    }
-    if (!foundStatusCode && responses.length === 0) {
-      responses.push({
-        statusCode: 200,
-        bodyType: undefined,
-        bodyDescription: undefined,
-      });
-    }
-  }
-
-  return responses;
-}
-
-function getStatusCode(variant: { type: Type }): number {
-  if (variant.type.kind === "Model") {
-    const model = variant.type as Model;
-    for (const [propName, prop] of model.properties) {
-      if (propName === "statusCode") {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const typeAny = prop.type as any;
-        if (typeAny.value !== undefined) {
-          return typeAny.value as number;
-        }
-      }
-    }
-  }
-  return 200;
-}
-
-function getBodyFromResponse(
-  variant: { type: Type },
-  program: Program,
-  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
-): {
-  type: string | undefined;
-  description: string | undefined;
-  isSse?: boolean;
-} {
-  if (variant.type.kind === "Model") {
-    const model = variant.type as Model;
-    if (model.name === "SSEStream") {
-      return {
-        type: "axum::response::Response",
-        description: "Server-Sent Events stream",
-        isSse: true,
-      };
-    }
-    for (const [_propName, prop] of model.properties) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const decorators = (prop as any).decorators;
-      let isBody = false;
-      if (decorators) {
-        for (const key of Object.keys(decorators)) {
-          const decorator = decorators[key];
-          const name = getDecoratorName(decorator);
-          if (name === "body" || name === "bodyRoot") {
-            isBody = true;
-            break;
-          }
-        }
-      }
-      if (isBody) {
-        const { type: rustType } = getRustTypeForProperty(
-          prop.type,
-          program,
-          anonymousEnums,
-        );
-        return { type: rustType, description: getDoc(program, prop) };
-      }
-    }
-  }
-  return { type: undefined, description: undefined };
-}
-
-function getAllOperations(
-  program: Program,
-): { namespace: Namespace; operations: Operation[] }[] {
-  const seenNamespaces = new Set<string>();
-  const namespaceOps = new Map<string, { ns: Namespace; ops: Operation[] }>();
-
-  navigateProgram(program, {
-    namespace(ns: Namespace) {
-      const route = getRoute(program, ns);
-      if (!route) return;
-      const fullName = getNamespaceFullName(ns);
-      if (!seenNamespaces.has(fullName)) {
-        seenNamespaces.add(fullName);
-        namespaceOps.set(fullName, { ns, ops: [] });
-      }
-    },
-    operation(op: Operation) {
-      const method = getHttpMethod(program, op);
-      if (!method) return;
-      const ns = op.namespace;
-      if (!ns) return;
-      const fullName = getNamespaceFullName(ns);
-      if (!seenNamespaces.has(fullName)) {
-        seenNamespaces.add(fullName);
-        namespaceOps.set(fullName, { ns, ops: [] });
-      }
-      const entry = namespaceOps.get(fullName);
-      if (entry) {
-        entry.ops.push(op);
-      }
-    },
-  });
-
-  const result: { namespace: Namespace; operations: Operation[] }[] = [];
-  for (const [, entry] of namespaceOps) {
-    if (entry.ops.length > 0) {
-      result.push({ namespace: entry.ns, operations: entry.ops });
-    }
-  }
-  return result;
-}
-
-function buildFullPath(namespaceRoute: string, operationRoute: string): string {
-  let fullPath = namespaceRoute + operationRoute;
-  fullPath = fullPath.replace(/\/+/g, "/");
-  if (fullPath.length > 1 && fullPath.endsWith("/")) {
-    fullPath = fullPath.slice(0, -1);
-  }
-  return fullPath;
-}
-
-function emitOperationInfo(
-  program: Program,
-  op: Operation,
-  nsRoute: string,
-  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
-): OperationInfo | undefined {
-  const method = getHttpMethod(program, op);
-  if (!method) return undefined;
-
-  const opRoute = getRoute(program, op);
-  const fullPath = buildFullPath(nsRoute, opRoute);
-  const tags = getTags(program, op) ?? [];
-  const params = getOperationParameters(program, op, anonymousEnums);
-  const body = getOperationBody(op);
-  const responses = getOperationResponses(program, op, anonymousEnums);
-  const doc = getDoc(program, op);
-
-  const opName = op.name.replace(/[^a-zA-Z0-9_]/g, "_");
-
-  return {
-    name: opName,
-    method,
-    path: fullPath,
-    tags,
-    parameters: params,
-    body: body,
-    responses,
-    doc,
-  };
-}
-
-function getStatusVariantName(statusCode: number): string {
-  const statusNames: Record<number, string> = {
-    200: "Ok",
-    201: "Created",
-    202: "Accepted",
-    204: "NoContent",
-    400: "BadRequest",
-    401: "Unauthorized",
-    403: "Forbidden",
-    404: "NotFound",
-    409: "Conflict",
-    500: "InternalServerError",
-  };
-  return statusNames[statusCode] || `Status${statusCode}`;
-}
-
-function getHttpStatusCode(statusCode: number): string {
-  const statusCodes: Record<number, string> = {
-    200: "StatusCode::OK",
-    201: "StatusCode::CREATED",
-    202: "StatusCode::ACCEPTED",
-    204: "StatusCode::NO_CONTENT",
-    400: "StatusCode::BAD_REQUEST",
-    401: "StatusCode::UNAUTHORIZED",
-    403: "StatusCode::FORBIDDEN",
-    404: "StatusCode::NOT_FOUND",
-    409: "StatusCode::CONFLICT",
-    500: "StatusCode::INTERNAL_SERVER_ERROR",
-  };
-  return statusCodes[statusCode] || `StatusCode::from_u16(${statusCode})`;
-}
-
-function generateServerTrait(
-  program: Program,
-  namespaceGroups: { namespace: Namespace; operations: Operation[] }[],
-  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
-): string {
-  const parts: string[] = [];
-
-  parts.push(`use super::types::*;
-use async_trait::async_trait;
-use axum::extract::Path;
-use axum::Extension;
-use axum::http::StatusCode;
-use axum::response::IntoResponse;
-use axum::Json;
-use eyre::Result;
-
-#[async_trait]
-pub trait Server: Send + Sync {
-    type Claims: Send + Sync + 'static;
-
-`);
-
-  for (const group of namespaceGroups) {
-    const nsName = toPascalCase(
-      group.namespace.name.replace(/[^a-zA-Z0-9_]/g, "_"),
-    );
-
-    for (const op of group.operations) {
-      const opInfo = emitOperationInfo(program, op, "", anonymousEnums);
-      if (!opInfo) continue;
-
-      if (opInfo.doc) {
-        parts.push(`    ${formatDoc(opInfo.doc)}`);
-      }
-
-      const responseName = `${nsName}${toPascalCase(opInfo.name)}Response`;
-      const fnName = toRustIdent(`${nsName}_${opInfo.name}`);
-      const isProtected = hasAuthDecorator(op);
-
-      // Build parameter list for the trait method
-      const paramParts: string[] = [];
-
-      // Add path parameters
-      for (const param of opInfo.parameters) {
-        if (param.location === "path") {
-          paramParts.push(`${param.rustName}: ${param.rustType}`);
-        }
-      }
-
-      // Add query parameters
-      for (const param of opInfo.parameters) {
-        if (param.location === "query") {
-          paramParts.push(`${param.rustName}: ${param.rustType}`);
-        }
-      }
-
-      // Add body parameter
-      if (opInfo.body) {
-        if (hasMultipartBody(op)) {
-          paramParts.push(`body: Multipart`);
-        } else {
-          const bodyType = getRustTypeForProperty(
-            opInfo.body.type,
-            program,
-            anonymousEnums,
-          );
-          paramParts.push(`body: ${bodyType.type}`);
-        }
-      }
-
-      const paramsStr = paramParts.join(", ");
-      const selfReceiver = getSelfReceiver(op);
-
-      if (isProtected) {
-        if (paramsStr) {
-          parts.push(
-            `    async fn ${fnName}(${selfReceiver}, claims: Self::Claims, ${paramsStr}) -> Result<${responseName}>;`,
-          );
-        } else {
-          parts.push(
-            `    async fn ${fnName}(${selfReceiver}, claims: Self::Claims) -> Result<${responseName}>;`,
-          );
-        }
-      } else {
-        if (paramsStr) {
-          parts.push(
-            `    async fn ${fnName}(${selfReceiver}, ${paramsStr}) -> Result<${responseName}>;`,
-          );
-        } else {
-          parts.push(
-            `    async fn ${fnName}(${selfReceiver}) -> Result<${responseName}>;`,
-          );
-        }
-      }
-    }
-  }
-
-  parts.push("}");
-
-  return parts.join("\n");
-}
-
-function generateResponseEnums(
-  program: Program,
-  namespaceGroups: { namespace: Namespace; operations: Operation[] }[],
-  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
-): string {
-  const parts: string[] = [];
-
-  for (const group of namespaceGroups) {
-    const nsName = toPascalCase(
-      group.namespace.name.replace(/[^a-zA-Z0-9_]/g, "_"),
-    );
-
-    for (const op of group.operations) {
-      const opInfo = emitOperationInfo(program, op, "", anonymousEnums);
-      if (!opInfo) continue;
-
-      if (opInfo.responses.length === 0) continue;
-
-      const responseName = `${nsName}${toPascalCase(opInfo.name)}Response`;
-
-      const variants: string[] = [];
-      for (const resp of opInfo.responses) {
-        const variantName = getStatusVariantName(resp.statusCode);
-        if (!resp.bodyType) {
-          variants.push(`    ${variantName},`);
-        } else if (resp.isSse) {
-          variants.push(`    ${variantName}(${resp.bodyType}),`);
-        } else {
-          variants.push(`    ${variantName}(Json<${resp.bodyType}>),`);
-        }
-      }
-      parts.push(`#[allow(clippy::type_complexity)]
-pub enum ${responseName} {
-${variants.join("\n")}
-}
-`);
-
-      parts.push(`impl IntoResponse for ${responseName} {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-`);
-      for (const resp of opInfo.responses) {
-        const variantName = getStatusVariantName(resp.statusCode);
-        const statusCodeStr = getHttpStatusCode(resp.statusCode);
-        if (!resp.bodyType) {
-          parts.push(
-            `            ${responseName}::${variantName} => ${statusCodeStr}.into_response(),`,
-          );
-        } else if (resp.isSse) {
-          parts.push(
-            `            ${responseName}::${variantName}(body) => body.into_response(),`,
-          );
-        } else {
-          parts.push(
-            `            ${responseName}::${variantName}(body) => (${statusCodeStr}, body).into_response(),`,
-          );
-        }
-      }
-      parts.push(`        }
-    }
-}
-`);
-    }
-  }
-
-  return parts.join("\n");
-}
-
-function generateRouter(
-  program: Program,
-  namespaceGroups: { namespace: Namespace; operations: Operation[] }[],
-  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
-): string {
-  const handlers: string[] = [];
-  const queryTypeStructs: string[] = [];
-  const publicRoutes: string[] = [];
-  const protectedRoutes: string[] = [];
-  const usedMethods = new Set<string>();
-
-  for (const group of namespaceGroups) {
-    const nsRoute = getFullRoute(program, group.namespace);
-    if (!nsRoute) continue;
-
-    const nsName = toPascalCase(
-      group.namespace.name.replace(/[^a-zA-Z0-9_]/g, "_"),
-    );
-
-    for (const op of group.operations) {
-      const opInfo = emitOperationInfo(program, op, nsRoute, anonymousEnums);
-      if (!opInfo) continue;
-
-      const method = opInfo.method.toLowerCase();
-      usedMethods.add(method);
-
-      const handlerFnName = toRustIdent(`${nsName}_${opInfo.name}`);
-      const traitFnName = handlerFnName;
-      const isProtected = hasAuthDecorator(op);
-      const selfReceiver = getSelfReceiver(op);
-
-      const pathParams = opInfo.parameters.filter((p) => p.location === "path");
-      const hasPathParams = pathParams.length > 0;
-      const queryParams = opInfo.parameters.filter(
-        (p) => p.location === "query",
-      );
-      const hasQueryParams = queryParams.length > 0;
-      const hasBody = !!opInfo.body;
-      const isMultipartBody = hasMultipartBody(op);
-
-      // Build extractor lines and server method call arguments
-      // IMPORTANT: axum requires specific extractor order:
-      // State -> Extension -> Path -> Query -> Json/Multipart -> Body
-      const extractorLines: string[] = [];
-      const serverArgs: string[] = [];
-
-      // State is always first (added in handler template)
-      const serviceBinding =
-        selfReceiver === "&mut self" ? "mut service" : "service";
-
-      // Extension (claims) comes after State
-      if (isProtected) {
-        extractorLines.push(`    Extension(claims): Extension<S::Claims>,`);
-        serverArgs.push(`claims`);
-      }
-
-      // Path params come after Extension
-      if (hasPathParams) {
-        const pathTypes = pathParams.map((p) => p.rustType).join(", ");
-        const pathFields = pathParams.map((p) => p.rustName).join(", ");
-        if (pathParams.length === 1) {
-          extractorLines.push(`    Path(${pathFields}): Path<${pathTypes}>,`);
-        } else {
-          extractorLines.push(
-            `    Path((${pathFields})): Path<(${pathTypes})>,`,
-          );
-        }
-        // Add path params to server method args
-        for (const param of pathParams) {
-          serverArgs.push(param.rustName);
-        }
-      }
-
-      // Query params come after Path
-      if (hasQueryParams && queryParams.length > 0) {
-        const queryTypeName = `${toPascalCase(handlerFnName)}Query`;
-        const queryFields = queryParams
-          .map(
-            (p) =>
-              `    #[serde(rename = "${p.name}")]\n    pub ${p.rustName}: ${p.rustType}`,
-          )
-          .join(",\n");
-        queryTypeStructs.push(
-          `#[derive(Debug, Clone, serde::Deserialize)]\npub struct ${queryTypeName} {\n${queryFields}\n}`,
-        );
-        extractorLines.push(`    Query(params): Query<${queryTypeName}>,`);
-        for (const param of queryParams) {
-          serverArgs.push(`params.${param.rustName}`);
-        }
-      }
-
-      // Body comes last (Json or Multipart based on decorator)
-      if (hasBody && opInfo.body) {
-        if (isMultipartBody) {
-          extractorLines.push(`    multipart: axum::extract::Multipart,`);
-          serverArgs.push(`multipart`);
-        } else {
-          const bodyType = getRustTypeForProperty(
-            opInfo.body.type,
-            program,
-            anonymousEnums,
-          );
-          extractorLines.push(`    Json(payload): Json<${bodyType.type}>,`);
-          serverArgs.push(`payload`);
-        }
-      }
-
-      // Build server method call
-      const serverArgsStr = serverArgs.join(", ");
-      const serverCall = `service.${traitFnName}(${serverArgsStr}).await`;
-
-      // All handlers use <S> generics, Claims is now an associated type
-      // For &mut self, we need Clone because service is extracted multiple times
-      // For self, we can't use Clone (would need Arc/Mutex or different pattern)
-      const needsClone = selfReceiver !== "self" ? "+ Clone" : "";
-      const handlerCode =
-        selfReceiver === "self"
-          ? `// NOTE: ${handlerFnName} takes self and cannot be used with the router pattern.
-// It consumes the service, so you need to implement your own handler pattern.
-pub async fn ${handlerFnName}_handler<S>(
-    axum::extract::State(service): axum::extract::State<S>,
-${extractorLines.join("\n")}
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.${traitFnName}(${serverArgsStr}).await;
-    match result {
-        Ok(response) => response.into_response(),
-        Err(e) => (
-            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Internal error: {e}"),
-        )
-            .into_response(),
-    }
-}`
-          : `pub async fn ${handlerFnName}_handler<S>(
-    axum::extract::State(${serviceBinding}): axum::extract::State<S>,
-${extractorLines.join("\n")}
-) -> impl axum::response::IntoResponse
-where
-    S: Server${needsClone} + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = ${serverCall};
-    match result {
-        Ok(response) => response.into_response(),
-        Err(e) => (
-            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Internal error: {e}"),
-        )
-            .into_response(),
-    }
-}`;
-
-      handlers.push(handlerCode);
-
-      // Don't add routes for self methods (they consume the service)
-      if (selfReceiver === "self") {
-        continue;
-      }
-
-      const routePath = `"${opInfo.path}"`;
-      let routeStmt = "";
-      if (isProtected) {
-        routeStmt = `.route(${routePath}, ${method}(${handlerFnName}_handler::<S>))`;
-        protectedRoutes.push(routeStmt);
-      } else {
-        routeStmt = `.route(${routePath}, ${method}(${handlerFnName}_handler::<S>))`;
-        publicRoutes.push(routeStmt);
-      }
-    }
-  }
-
-  const methodImports = Array.from(usedMethods).sort().join(", ");
-
-  const routerBody = buildRouterBody(publicRoutes, protectedRoutes);
-
-  const parts: string[] = [];
-  parts.push(`use axum::extract::{Query, Multipart};
-use axum::routing::{${methodImports}};
-use axum::Router;
-
-`);
-  if (queryTypeStructs.length > 0) {
-    parts.push(queryTypeStructs.join("\n\n"));
-    parts.push("\n\n");
-  }
-  parts.push(handlers.join("\n\n"));
-  parts.push(`
-pub fn create_router<S, M>(service: S, middleware: M) -> Router
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-    M: FnOnce(Router<S>) -> Router<S> + Clone + Send + Sync + 'static,
-{
-${routerBody}
-}`);
-
-  return parts.join("\n");
-}
-
-function buildRouterBody(
-  publicRoutes: string[],
-  protectedRoutes: string[],
-): string {
-  const lines: string[] = [];
-  lines.push("    let mut router = Router::new();");
-  if (publicRoutes.length > 0) {
-    lines.push("    let public = Router::new()");
-    for (const r of publicRoutes) {
-      lines.push(`        ${r.trim()}`);
-    }
-    lines.push("        ;");
-    lines.push("    router = router.merge(public);");
-  }
-  if (protectedRoutes.length > 0) {
-    lines.push("    let protected = Router::new()");
-    for (const r of protectedRoutes) {
-      lines.push(`        ${r.trim()}`);
-    }
-    lines.push("        ;");
-    lines.push("    router = router.merge(middleware(protected));");
-  }
-  lines.push("    router.with_state(service)");
-  return lines.join("\n");
-}
-
-const scalarToRust: Record<string, string> = {
-  string: "String",
-  int8: "i8",
-  int16: "i16",
-  int32: "i32",
-  int64: "i64",
-  uint8: "u8",
-  uint16: "u16",
-  uint32: "u32",
-  uint64: "u64",
-  float32: "f32",
-  float64: "f64",
-  boolean: "bool",
-  bytes: "Vec<u8>",
-  plainDate: "chrono::NaiveDate",
-  plainTime: "chrono::NaiveTime",
-  utcDateTime: "chrono::DateTime<chrono::Utc>",
-  offsetDateTime: "chrono::DateTime<chrono::FixedOffset>",
-  plainDateTime: "chrono::NaiveDateTime",
-  duration: "String",
-  numeric: "f64",
-  integer: "i64",
-  float: "f64",
-  safeint: "i64",
-  decimal: "f64",
-  decimal128: "f64",
-  url: "String",
-};
-
-const formatToRust: Record<string, string> = {
-  uuid: "uuid::Uuid",
-  date: "chrono::NaiveDate",
-  time: "chrono::NaiveTime",
-  dateTime: "chrono::DateTime<chrono::Utc>",
-  "date-time": "chrono::DateTime<chrono::Utc>",
-};
-
-const typeSpecNamespaces = new Set([
-  "TypeSpec",
-  "@typespec/http",
-  "@typespec/rest",
-  "@typespec/openapi",
-  "@typespec/openapi3",
-  "@typespec/json-schema",
-]);
-
-function isStdLibNamespace(ns: Namespace | undefined): boolean {
-  if (!ns) return false;
-  const fullName = ns.name;
-  if (typeSpecNamespaces.has(fullName)) return true;
-  if (ns.namespace) return isStdLibNamespace(ns.namespace);
-  return false;
-}
-
-function isStdLibType(type: Type): boolean {
-  if ("namespace" in type) {
-    const ns = (type as Model | Enum | Union | Scalar).namespace;
-    if (isStdLibNamespace(ns as Namespace)) return true;
-  }
-  return false;
-}
-
-interface AnonymousStringLiteralUnion {
-  enumName: string;
-  variants: StringLiteral[];
-}
-
-function getRustTypeForProperty(
-  type: Type,
-  program: Program,
-  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
-): { type: string; isStringLiteral: boolean; stringLiteralValue?: string } {
-  const kind = type.kind as string;
-
-  if (kind === "Model") {
-    const model = type as Model;
-    if (isArrayModelType(model) && model.indexer?.value) {
-      const element = getRustTypeForProperty(
-        model.indexer.value,
-        program,
-        anonymousEnums,
-      );
-      return { type: `Vec<${element.type}>`, isStringLiteral: false };
-    }
-    if (isRecordModelType(model) && model.indexer?.value) {
-      const value = getRustTypeForProperty(
-        model.indexer.value,
-        program,
-        anonymousEnums,
-      );
-      return {
-        type: `std::collections::HashMap<String, ${value.type}>`,
-        isStringLiteral: false,
-      };
-    }
-    return { type: toPascalCase(model.name), isStringLiteral: false };
-  }
-
-  if (kind === "ModelProperty") {
-    return getRustTypeForProperty(
-      (type as ModelProperty).type,
-      program,
-      anonymousEnums,
-    );
-  }
-
-  if (kind === "Enum") {
-    return { type: toPascalCase((type as Enum).name), isStringLiteral: false };
-  }
-
-  if (kind === "Union") {
-    const unionType = type as Union;
-    const variants = Array.from(unionType.variants.values());
-    const allStringLiterals = variants.every((v) => v.type.kind === "String");
-
-    if (allStringLiterals) {
-      if (unionType.name) {
-        return {
-          type: toPascalCase(unionType.name),
-          isStringLiteral: false,
-        };
-      }
-      const values = variants.map((v) => (v.type as StringLiteral).value);
-      const sanitized = values.map((v) => v.replace(/_/g, ""));
-      const firstTwo = sanitized.slice(0, 2).map(toPascalCase).join("");
-      const enumName = `Enum${firstTwo}${sanitized.length}`;
-      if (!anonymousEnums.has(enumName)) {
-        anonymousEnums.set(enumName, {
-          enumName,
-          variants: variants.map((v) => v.type as StringLiteral),
-        });
-      }
-      return { type: enumName, isStringLiteral: false };
-    }
-
-    const nonNullVariants = variants.filter((v) => {
-      const vt = v.type;
-      if ((vt.kind as string) === "Null") return false;
-      if (
-        (vt.kind as string) === "Intrinsic" &&
-        (vt as IntrinsicType).name === "null"
-      )
-        return false;
-      return true;
-    });
-
-    if (
-      nonNullVariants.length === 1 &&
-      (variants.length === 2 ||
-        variants.some((v) => {
-          const vt = v.type;
-          return (
-            (vt.kind as string) === "Null" ||
-            ((vt.kind as string) === "Intrinsic" &&
-              (vt as IntrinsicType).name === "null")
-          );
-        }))
-    ) {
-      const vt = getRustTypeForProperty(
-        nonNullVariants[0].type,
-        program,
-        anonymousEnums,
-      );
-      return { type: `Option<${vt.type}>`, isStringLiteral: false };
-    }
-
-    const variantStrings: string[] = [];
-    for (const v of variants) {
-      const vt = v.type;
-      if ((vt.kind as string) === "Null") continue;
-      if (
-        (vt.kind as string) === "Intrinsic" &&
-        (vt as IntrinsicType).name === "null"
-      )
-        continue;
-      const rustVt = getRustTypeForProperty(vt, program, anonymousEnums);
-      variantStrings.push(rustVt.type);
-    }
-    const uniqueTypes = [...new Set(variantStrings)];
-    const resultType =
-      uniqueTypes.length === 1
-        ? uniqueTypes[0]
-        : `(${uniqueTypes.join(" | ")})`;
-    return { type: resultType, isStringLiteral: false };
-  }
-
-  if (kind === "Scalar") {
-    const scalar = type as Scalar;
-    const format = getFormat(program, scalar);
-    const pattern = getPattern(program, scalar);
-
-    if (format && formatToRust[format] && !pattern) {
-      return { type: formatToRust[format], isStringLiteral: false };
-    }
-    if (pattern) {
-      return { type: toPascalCase(scalar.name), isStringLiteral: false };
-    }
-    return {
-      type: scalarToRust[scalar.name] ?? scalar.name,
-      isStringLiteral: false,
-    };
-  }
-
-  if (kind === "Intrinsic") {
-    const intrinsic = type as IntrinsicType;
-    const format = getFormat(program, type);
-    if (format && formatToRust[format]) {
-      return { type: formatToRust[format], isStringLiteral: false };
-    }
-    return {
-      type: scalarToRust[intrinsic.name] ?? "serde_json::Value",
-      isStringLiteral: false,
-    };
-  }
-
-  if (kind === "String") {
-    return { type: "String", isStringLiteral: false };
-  }
-
-  if (kind === "StringLiteral") {
-    return {
-      type: "String",
-      isStringLiteral: true,
-      stringLiteralValue: (type as StringLiteral).value,
-    };
-  }
-
-  if (kind === "Boolean" || kind === "BooleanLiteral") {
-    return { type: "bool", isStringLiteral: false };
-  }
-
-  if (kind === "Number" || kind === "NumericLiteral") {
-    return { type: "f64", isStringLiteral: false };
-  }
-
-  return { type: "serde_json::Value", isStringLiteral: false };
-}
-
-function toRustIdent(name: string): string {
-  const snakeCase = name.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
-  const result = snakeCase.replace(/[^a-z0-9_]/g, "_");
-  if (/^[0-9]/.test(result)) {
-    return "_" + result;
-  }
-  return result;
-}
-
-function toPascalCase(name: string): string {
-  if (/^[^a-z]+$/.test(name)) {
-    return name;
-  }
-  if (/[-_]/.test(name)) {
-    return name
-      .split(/[-_]/)
-      .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
-      .join("");
-  }
-  return name.charAt(0).toUpperCase() + name.slice(1);
-}
-
-function toRustVariantName(name: string): string {
-  return toPascalCase(name);
-}
-
-function formatDoc(doc: string | undefined): string {
-  if (!doc) return "";
-  return doc
-    .split("\n")
-    .map((line) => `/// ${line.trim()}`)
-    .join("\n");
-}
-
-function emitStringLiteralUnion(union: Union): string {
-  const parts: string[] = [];
-  const name = toPascalCase(union.name ?? "Value");
-  const variants = Array.from(union.variants.values());
-
-  parts.push(
-    `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\n#[allow(clippy::enum_variant_names)]\npub enum ${name} {`,
-  );
-
-  for (let i = 0; i < variants.length; i++) {
-    const literalType = variants[i].type as StringLiteral;
-    const variantName = toPascalCase(literalType.value);
-    const serdeValue = literalType.value;
-    if (i === 0) {
-      parts.push(`  #[default]`);
-    }
-    parts.push(`  #[serde(rename = "${serdeValue}")]`);
-    parts.push(`  ${variantName},`);
-  }
-
-  parts.push("}");
-  return parts.join("\n");
-}
-
-function emitModel(
-  model: Model,
-  program: Program,
-  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
-): string {
-  const parts: string[] = [];
-  const name = toPascalCase(model.name);
-  const allProps = getAllProperties(model, program);
-
-  const deriveAttrs = [
-    "Debug",
-    "Clone",
-    "serde::Serialize",
-    "serde::Deserialize",
-  ];
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const customDerives = (model as any)[rustDeriveKey] as
-    | RustDeriveInfo
-    | undefined;
-  if (customDerives) {
-    deriveAttrs.push(...customDerives.derives);
-  }
-
-  parts.push(`#[derive(${deriveAttrs.join(", ")})]`);
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const customAttrs = (model as any)[rustAttrKey] as RustAttrInfo | undefined;
-  if (customAttrs) {
-    for (const attr of customAttrs.attrs) {
-      parts.push(`#[${attr}]`);
-    }
-  }
-
-  if (allProps.size > 0) {
-    const fields: string[] = [];
-    for (const [propName, prop] of allProps) {
-      const doc = getDoc(program, prop);
-      const { type: rustType } = getRustTypeForProperty(
-        prop.type,
-        program,
-        anonymousEnums,
-      );
-      const optional = prop.optional ? true : false;
-      const fieldName = toRustIdent(propName);
-      const serdeRename =
-        propName !== fieldName ? `#[serde(rename = "${propName}")]` : "";
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const propAttrs = (prop as any)[rustAttrKey] as RustAttrInfo | undefined;
-
-      if (doc) {
-        fields.push(`  ${formatDoc(doc)}`);
-      }
-      if (propAttrs) {
-        for (const attr of propAttrs.attrs) {
-          fields.push(`  #[${attr}]`);
-        }
-      }
-      if (serdeRename) {
-        fields.push(`  ${serdeRename}`);
-      }
-      if (optional) {
-        fields.push(`  #[serde(skip_serializing_if = "Option::is_none")]`);
-      }
-      fields.push(
-        `  pub ${fieldName}: ${optional ? `Option<${rustType}>` : rustType},`,
-      );
-    }
-    parts.push(`pub struct ${name} {
-${fields.join("\n")}
-}`);
-  } else {
-    parts.push(`pub struct ${name}`);
-    parts.push("(());");
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const customImpl = (model as any)[rustImplKey] as RustImplInfo | undefined;
-  if (customImpl) {
-    parts.push(`
-${customImpl.impl}`);
-  }
-
-  return parts.join("\n");
-}
-
-function getAllProperties(
-  model: Model,
-  _program: Program,
-): Map<string, ModelProperty> {
-  const props = new Map<string, ModelProperty>();
-
-  if (model.baseModel) {
-    const baseProps = getAllProperties(model.baseModel, _program);
-    for (const [key, value] of baseProps) {
-      props.set(key, value);
-    }
-  }
-
-  for (const [key, value] of model.properties) {
-    props.set(key, value);
-  }
-
-  return props;
-}
-
-function emitEnum(enumType: Enum): string {
-  const parts: string[] = [];
-  const name = toPascalCase(enumType.name);
-  const members = Array.from(enumType.members.values());
-  const isString = members.every(
-    (m) => m.value === undefined || typeof m.value === "string",
-  );
-
-  const baseDerives = [
-    "Debug",
-    "Clone",
-    "Copy",
-    "PartialEq",
-    "Eq",
-    "Hash",
-    "Default",
-    "serde::Serialize",
-    "serde::Deserialize",
-  ];
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const customDerives = (enumType as any)[rustDeriveKey] as
-    | RustDeriveInfo
-    | undefined;
-  const allDerives = [...baseDerives];
-  if (customDerives) {
-    allDerives.push(...customDerives.derives);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const customAttrs = (enumType as any)[rustAttrKey] as
-    | RustAttrInfo
-    | undefined;
-  const attrLines: string[] = [];
-  if (customAttrs) {
-    for (const attr of customAttrs.attrs) {
-      attrLines.push(`#[${attr}]`);
-    }
-  }
-
-  if (isString) {
-    parts.push(`#[derive(${allDerives.join(", ")})]`);
-    if (attrLines.length > 0) {
-      parts.push(...attrLines);
-    }
-    parts.push(`pub enum ${name} {`);
-    for (let i = 0; i < members.length; i++) {
-      const variantName = toRustVariantName(members[i].name);
-      const serdeValue = members[i].value ?? members[i].name;
-      if (i === 0) {
-        parts.push(`  #[default]`);
-      }
-      parts.push(`  #[serde(rename = "${serdeValue}")]`);
-      parts.push(`  ${variantName},`);
-    }
-  } else {
-    parts.push(`#[derive(${allDerives.join(", ")})]`);
-    if (attrLines.length > 0) {
-      parts.push(...attrLines);
-    }
-    parts.push(`pub enum ${name} {`);
-    for (let i = 0; i < members.length; i++) {
-      const variantName = toRustVariantName(members[i].name);
-      const enumValue = members[i].value ?? 0;
-      if (i === 0) {
-        parts.push(`  #[default]`);
-      }
-      parts.push(`  ${variantName} = ${enumValue},`);
-    }
-  }
-  parts.push("}");
-  return parts.join("\n");
-}
-
-function emitUnion(union: Union, program: Program): string {
-  const parts: string[] = [];
-  const name = toPascalCase(union.name ?? "Union");
-
-  const variants = Array.from(union.variants.values());
-  if (variants.length === 0) {
-    parts.push(
-      `#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\npub enum ${name} {}\nimpl ${name} {\n  pub fn new() -> Self { unreachable!() }\n}`,
-    );
-    return parts.join("\n");
-  }
-
-  parts.push(
-    `#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\n#[serde(untagged)]\npub enum ${name} {`,
-  );
-  for (let i = 0; i < variants.length; i++) {
-    const variant = variants[i];
-    const variantName = `Variant${i + 1}`;
-    const { type: rustType } = getRustTypeForProperty(
-      variant.type,
-      program,
-      new Map(),
-    );
-    parts.push(`  ${variantName}(${rustType}),`);
-  }
-  parts.push("}");
-
-  return parts.join("\n");
-}
-
-function emitScalar(
-  scalar: Scalar,
-  program: Program,
-): { typeDef: string; impls: string[] } {
-  const format = getFormat(program, scalar);
-  const pattern = getPattern(program, scalar);
-  const structName = toPascalCase(scalar.name);
-  const impls: string[] = [];
-
-  if (format && formatToRust[format]) {
-    return {
-      typeDef: `pub type ${structName} = ${formatToRust[format]};`,
-      impls: [],
-    };
-  }
-
-  if (pattern) {
-    const rustType = scalarToRust[scalar.name] ?? "String";
-    impls.push(
-      `\nimpl TryFrom<String> for ${structName} {\n  type Error = String;\n\n  fn try_from(value: String) -> Result<Self, Self::Error> {\n    let re = regex::Regex::new(r"${pattern}").unwrap();\n    if re.is_match(&value) { Ok(Self(value)) } else { Err(format!("Invalid value: {}", value)) }\n  }\n}`,
-    );
-
-    return {
-      typeDef: `#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\npub struct ${structName}(pub ${rustType});`,
-      impls,
-    };
-  }
-
-  const rustType = scalarToRust[scalar.name] ?? "serde_json::Value";
-  return {
-    typeDef: `pub type ${structName} = ${rustType};`,
-    impls: [],
-  };
-}
+import {
+  RustEmitterOptions,
+  AnonymousStringLiteralUnion,
+} from "./models/types.js";
+import { isStdLibType, getAllOperations } from "./parser/index.js";
+import {
+  emitModel,
+  emitEnum,
+  emitUnion,
+  emitScalar,
+  emitStringLiteralUnion,
+} from "./generator/types_file.js";
+import { generateServerTrait } from "./generator/server_trait.js";
+import { generateResponseEnums } from "./generator/response_enums.js";
+import { generateRouter } from "./generator/router.js";
 
 export async function $onEmit(
   context: EmitContext<RustEmitterOptions>,
@@ -1738,7 +100,9 @@ export async function $onEmit(
     );
     for (let i = 0; i < anonEnum.variants.length; i++) {
       const literal = anonEnum.variants[i];
-      const variantName = toPascalCase(literal.value);
+      const variantName = (
+        literal.value.charAt(0).toUpperCase() + literal.value.slice(1)
+      ).replace(/[^a-zA-Z0-9]/g, "");
       if (i === 0) {
         parts.push(`  #[default]`);
       }