@bazo/openapi-client-generator 3.0.13 → 3.0.18

package/bin.js

@@ -18565,11 +18565,7 @@ function resolveServerUrl(url, variables) {
   });
 }
 function deriveServerName(server, index) {
-  const candidates = [
-    server["x-name"],
-    server.name,
-    server.description
-  ];
+  const candidates = [server["x-name"], server.name, server.description];
   for (const candidate of candidates) {
     if (typeof candidate !== "string") {
       continue;
@@ -18629,7 +18625,7 @@ function applyStringConstraints(schema) {
   if (schema.pattern) {
     try {
       new RegExp(schema.pattern);
-      const escaped = schema.pattern.replace(/\\/g, "\\\\").replace(/\//g, "\\/");
+      const escaped = schema.pattern.replace(/\//g, "\\/");
       parts.push(`.regex(/${escaped}/)`);
     } catch {
     }
@@ -18786,9 +18782,7 @@ function convertArray(schema, ctx) {
 // src/converter/composition.ts
 function convertAllOf(schema, ctx) {
   const schemas = schema.allOf;
-  const allObjects = schemas.every(
-    (s) => s.type === "object" || s.properties || s.refName && !s.allOf && !s.oneOf && !s.anyOf
-  );
+  const allObjects = schemas.every((s) => s.type === "object" || s.properties || s.refName && !s.allOf && !s.oneOf && !s.anyOf);
   if (allObjects) {
     return mergeAllOfObjects(schemas, schema, ctx);
   }
@@ -18905,10 +18899,10 @@ function schemaToZod(schema, ctx) {
   if (schema.refName && ctx.namedSchemas.has(schema.refName)) {
     return schema.refName;
   }
-  if (schema.allOf) return convertAllOf(schema, ctx);
-  if (schema.oneOf) return convertOneOf(schema, ctx);
-  if (schema.anyOf) return convertAnyOf(schema, ctx);
-  if (schema.enum) return convertEnum(schema);
+  if (schema.allOf) return maybeNullable(convertAllOf(schema, ctx), schema);
+  if (schema.oneOf) return maybeNullable(convertOneOf(schema, ctx), schema);
+  if (schema.anyOf) return maybeNullable(convertAnyOf(schema, ctx), schema);
+  if (schema.enum) return maybeNullable(convertEnum(schema), schema);
   switch (normalizeType(schema)) {
     case "string":
       return convertString(schema);
@@ -19180,6 +19174,12 @@ var fullMode = {
     lines.push(`    return (configure ? configure(http) : http) as Http;`);
     lines.push(`}`);
     lines.push("");
+    lines.push(`export interface ${clientName} {`);
+    for (const op of ops) {
+      lines.push(`    ${op.operationId}: ReturnType<typeof ${op.operationId}>;`);
+    }
+    lines.push(`}`);
+    lines.push("");
     lines.push(`export class ${clientName} {`);
     if (defaultServer) {
       lines.push(`    static readonly servers = ${clientName}Servers;`);
@@ -19190,10 +19190,6 @@ var fullMode = {
     lines.push(`    private operations: Map<string, Function>;`);
     lines.push(`    public http: Http;`);
     lines.push("");
-    for (const op of ops) {
-      lines.push(`    declare ${op.operationId}: ReturnType<typeof ${op.operationId}>;`);
-    }
-    lines.push("");
     if (defaultServer) {
       lines.push(`    constructor(baseUrl: string, queryClient: QueryClient, options?: RequestInit, onHttpConfigure?: (w: Http) => unknown);`);
       lines.push(`    constructor(queryClient: QueryClient, options?: RequestInit, onHttpConfigure?: (w: Http) => unknown);`);
@@ -19384,10 +19380,7 @@ var playwrightMode = {
   name: "playwright",
   operationsInline: true,
   generateImports(_ctx) {
-    const lines = [
-      'import { z } from "zod";',
-      'import { type APIRequestContext, type APIResponse } from "@playwright/test";'
-    ];
+    const lines = ['import { z } from "zod";', 'import { type APIRequestContext, type APIResponse } from "@playwright/test";'];
     return lines.join("\n");
   },
   generateHelperTypes(_ctx) {
@@ -20219,6 +20212,8 @@ function generateSwiftMutation(op, namedSchemas, schemaLookup) {
 // src/modes/swift/index.ts
 var swiftMode = {
   name: "swift",
+  nativeTarget: true,
+  fileExtension: ".swift",
   operationsInline: true,
   generateImports(_ctx) {
     return ["import Foundation", "#if canImport(FoundationNetworking)", "import FoundationNetworking", "#endif"].join("\n");
@@ -20397,11 +20392,15 @@ var swiftMode = {
     lines.push(`    }`);
     lines.push("");
     lines.push(`    private func documentedResponse<T: Sendable>(_ payload: T, from response: ApiResponse<Data>) -> APIError {`);
-    lines.push(`        APIError.documentedResponse(statusCode: response.status, payload: payload, headers: response.headers, url: response.url)`);
+    lines.push(
+      `        APIError.documentedResponse(statusCode: response.status, payload: payload, headers: response.headers, url: response.url)`
+    );
     lines.push(`    }`);
     lines.push("");
     lines.push(`    private func undocumentedResponse(from response: ApiResponse<Data>) -> APIError {`);
-    lines.push(`        APIError.undocumentedResponse(statusCode: response.status, data: response.data, headers: response.headers, url: response.url)`);
+    lines.push(
+      `        APIError.undocumentedResponse(statusCode: response.status, data: response.data, headers: response.headers, url: response.url)`
+    );
     lines.push(`    }`);
     lines.push("");
     lines.push(`    private func decodeJSON<T: Decodable>(_ type: T.Type, from response: ApiResponse<Data>) -> T? {`);
@@ -21024,6 +21023,8 @@ function generateKotlinMutation(op, namedSchemas, schemaLookup) {
 // src/modes/kotlin/index.ts
 var kotlinMode = {
   name: "kotlin",
+  nativeTarget: true,
+  fileExtension: ".kt",
   operationsInline: true,
   generateImports(_ctx) {
     const lines = [
@@ -21162,6 +21163,967 @@ function quoteKotlinString(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t")}"`;
 }
 
+// src/converter/schema-to-php.ts
+var PHP_RESERVED = /* @__PURE__ */ new Set([
+  "abstract",
+  "and",
+  "array",
+  "as",
+  "bool",
+  "break",
+  "callable",
+  "case",
+  "catch",
+  "class",
+  "clone",
+  "const",
+  "continue",
+  "declare",
+  "default",
+  "do",
+  "echo",
+  "else",
+  "elseif",
+  "empty",
+  "enddeclare",
+  "endfor",
+  "endforeach",
+  "endif",
+  "endswitch",
+  "endwhile",
+  "enum",
+  "eval",
+  "exit",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "float",
+  "fn",
+  "for",
+  "foreach",
+  "function",
+  "global",
+  "goto",
+  "if",
+  "implements",
+  "include",
+  "include_once",
+  "instanceof",
+  "insteadof",
+  "int",
+  "interface",
+  "isset",
+  "iterable",
+  "list",
+  "match",
+  "mixed",
+  "namespace",
+  "never",
+  "new",
+  "null",
+  "object",
+  "or",
+  "parent",
+  "print",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "require",
+  "require_once",
+  "return",
+  "self",
+  "static",
+  "string",
+  "switch",
+  "throw",
+  "trait",
+  "true",
+  "try",
+  "unset",
+  "use",
+  "var",
+  "void",
+  "while",
+  "xor",
+  "yield"
+]);
+function phpFeatures(version) {
+  const minor = Number.parseInt(version.split(".")[1], 10);
+  return {
+    enums: minor >= 1,
+    readonlyProps: minor >= 1,
+    readonlyClass: minor >= 2,
+    typedConstants: minor >= 3,
+    deprecatedAttribute: minor >= 4,
+    noDiscard: minor >= 5,
+    uriExtension: minor >= 5,
+    pipeOperator: minor >= 5
+  };
+}
+function phpClassName(name) {
+  const safe = name.replace(/[^a-zA-Z0-9]+/g, " ").split(" ").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  let result = safe || "Generated";
+  if (/^[0-9]/.test(result)) {
+    result = `_${result}`;
+  }
+  if (PHP_RESERVED.has(result.toLowerCase())) {
+    result = `${result}Model`;
+  }
+  return result;
+}
+function phpPropertyName(name) {
+  let result = name.replace(/[-_]([a-zA-Z])/g, (_, c) => c.toUpperCase());
+  if (result.startsWith("_")) {
+    result = result.slice(1);
+  }
+  result = result.charAt(0).toLowerCase() + result.slice(1);
+  if (!/^[a-zA-Z_]/.test(result)) {
+    result = `_${result}`;
+  }
+  return result;
+}
+function phpEnumCaseName(value) {
+  let result = value.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[^a-zA-Z0-9]+/g, " ").split(" ").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  if (result.length === 0) return "Unknown";
+  if (/^[0-9]/.test(result)) {
+    result = `_${result}`;
+  }
+  if (result.toLowerCase() === "class") {
+    result = `${result}_`;
+  }
+  return result;
+}
+function phpConstantName(value) {
+  let result = value.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").replace(/[^a-zA-Z0-9_]/g, "").toUpperCase();
+  if (result.length === 0) return "UNKNOWN";
+  if (/^[0-9]/.test(result)) {
+    result = `_${result}`;
+  }
+  if (result === "CLASS") {
+    result = "CLASS_";
+  }
+  return result;
+}
+function enumBacking(values2) {
+  if (values2.length === 0) return null;
+  if (values2.every((v) => typeof v === "string")) return "string";
+  if (values2.every((v) => typeof v === "number" && Number.isInteger(v))) return "int";
+  return null;
+}
+function classifyPhpSchemas(schemas, features) {
+  const kinds = /* @__PURE__ */ new Map();
+  for (const [name, schema] of schemas) {
+    kinds.set(name, classifySchema(schema, features, schemas));
+  }
+  return kinds;
+}
+function classifySchema(schema, features, lookup) {
+  if (schema.enum) {
+    const backing = enumBacking(schema.enum);
+    if (backing) {
+      return features.enums ? { kind: "enum", backing } : { kind: "constants", backing };
+    }
+    return { kind: "alias" };
+  }
+  if (schema.oneOf || schema.anyOf) {
+    return { kind: "alias" };
+  }
+  if (schema.allOf) {
+    return hasMergedProperties(schema, lookup) ? { kind: "class" } : { kind: "alias" };
+  }
+  if (schema.properties && schema.properties.size > 0) {
+    return { kind: "class" };
+  }
+  return { kind: "alias" };
+}
+function hasMergedProperties(schema, lookup, visitedRefs = /* @__PURE__ */ new Set()) {
+  if (schema.refName && lookup.has(schema.refName)) {
+    if (visitedRefs.has(schema.refName)) return false;
+    visitedRefs.add(schema.refName);
+    return hasMergedProperties(lookup.get(schema.refName), lookup, visitedRefs);
+  }
+  if (schema.properties && schema.properties.size > 0) return true;
+  if (schema.allOf) {
+    return schema.allOf.some((sub) => hasMergedProperties(sub, lookup, new Set(visitedRefs)));
+  }
+  return false;
+}
+var MIXED = { native: "mixed", doc: "mixed", deserialize: { kind: "json" } };
+function primitive(native) {
+  return { native, doc: native, deserialize: { kind: "json" } };
+}
+function maybeNullable3(t, schema) {
+  if (!schema.nullable) return t;
+  return nullablePhpType(t);
+}
+function nullablePhpType(t) {
+  return {
+    native: t.native === "mixed" || t.native.startsWith("?") ? t.native : `?${t.native}`,
+    doc: t.doc === "mixed" || t.doc.endsWith("|null") ? t.doc : `${t.doc}|null`,
+    deserialize: t.deserialize
+  };
+}
+function namedType(name, schema, pctx, visited) {
+  const kind = pctx.kinds.get(name) ?? { kind: "alias" };
+  switch (kind.kind) {
+    case "class": {
+      const className = pctx.classPrefix + phpClassName(name);
+      return maybeNullable3({ native: className, doc: className, deserialize: { kind: "class", name: className } }, schema);
+    }
+    case "enum": {
+      const className = pctx.classPrefix + phpClassName(name);
+      return maybeNullable3({ native: className, doc: className, deserialize: { kind: "enum", name: className } }, schema);
+    }
+    case "constants":
+      return maybeNullable3(primitive(kind.backing === "int" ? "int" : "string"), schema);
+    case "alias": {
+      if (visited.has(name)) return MIXED;
+      visited.add(name);
+      const target = pctx.conv.schemaLookup?.get(name);
+      if (!target) return maybeNullable3(MIXED, schema);
+      return maybeNullable3(resolvePhpType(target, pctx, visited), schema);
+    }
+  }
+}
+function schemaToPhpType(schema, pctx) {
+  return resolvePhpType(schema, pctx, /* @__PURE__ */ new Set());
+}
+function resolvePhpType(schema, pctx, visited) {
+  if (schema.isCircular && schema.refName) {
+    const kind = pctx.kinds.get(schema.refName);
+    if (kind && (kind.kind === "class" || kind.kind === "enum")) {
+      const className = pctx.classPrefix + phpClassName(schema.refName);
+      return nullablePhpType({
+        native: className,
+        doc: className,
+        deserialize: kind.kind === "class" ? { kind: "class", name: className } : { kind: "enum", name: className }
+      });
+    }
+    return MIXED;
+  }
+  if (schema.generatedName && pctx.conv.namedSchemas.has(schema.generatedName)) {
+    return namedType(schema.generatedName, schema, pctx, visited);
+  }
+  if (schema.refName && pctx.conv.namedSchemas.has(schema.refName)) {
+    return namedType(schema.refName, schema, pctx, visited);
+  }
+  if (schema.allOf) return resolveAllOfType3(schema, pctx, visited);
+  if (schema.oneOf) return resolveOneOfType3(schema, pctx, visited);
+  if (schema.anyOf) return resolveAnyOfType3(schema, pctx, visited);
+  if (schema.enum) return resolveEnumType3(schema);
+  switch (normalizeType(schema)) {
+    case "string":
+      return maybeNullable3(primitive("string"), schema);
+    case "number":
+      return maybeNullable3(primitive("float"), schema);
+    case "integer":
+      return maybeNullable3(primitive("int"), schema);
+    case "boolean":
+      return maybeNullable3(primitive("bool"), schema);
+    case "null":
+      return { native: "mixed", doc: "null", deserialize: { kind: "json" } };
+    case "array":
+      return resolveArrayType3(schema, pctx, visited);
+    case "object":
+      return resolveObjectType3(schema, pctx, visited);
+    default:
+      return maybeNullable3(MIXED, schema);
+  }
+}
+function resolveArrayType3(schema, pctx, visited) {
+  const itemType = schema.items ? resolvePhpType(schema.items, pctx, visited) : MIXED;
+  const itemDoc = itemType.doc.includes("|") || itemType.doc.includes("<") ? `array<${itemType.doc}>` : `${itemType.doc}[]`;
+  const deserialize = itemType.deserialize.kind === "class" ? { kind: "classArray", name: itemType.deserialize.name } : { kind: "json" };
+  return maybeNullable3({ native: "array", doc: itemDoc, deserialize }, schema);
+}
+function resolveObjectType3(schema, pctx, visited) {
+  if (!schema.properties || schema.properties.size === 0) {
+    if (typeof schema.additionalProperties === "object") {
+      const valueType = resolvePhpType(schema.additionalProperties, pctx, visited);
+      return maybeNullable3({ native: "array", doc: `array<string, ${valueType.doc}>`, deserialize: { kind: "json" } }, schema);
+    }
+    return maybeNullable3({ native: "array", doc: "array<string, mixed>", deserialize: { kind: "json" } }, schema);
+  }
+  if (schema.generatedName && pctx.conv.namedSchemas.has(schema.generatedName)) {
+    return namedType(schema.generatedName, schema, pctx, visited);
+  }
+  return maybeNullable3(MIXED, schema);
+}
+function resolveAllOfType3(schema, pctx, visited) {
+  const schemas = schema.allOf;
+  if (schemas.length === 1) return resolvePhpType(schemas[0], pctx, visited);
+  if (schemas[0].refName && pctx.conv.namedSchemas.has(schemas[0].refName)) {
+    return namedType(schemas[0].refName, schema, pctx, visited);
+  }
+  return maybeNullable3(MIXED, schema);
+}
+function resolveOneOfType3(schema, pctx, visited) {
+  const schemas = schema.oneOf;
+  if (schemas.length === 1) return resolvePhpType(schemas[0], pctx, visited);
+  return maybeNullable3(MIXED, schema);
+}
+function resolveAnyOfType3(schema, pctx, visited) {
+  const schemas = schema.anyOf;
+  const nonNull = schemas.filter((s) => s.type !== "null");
+  const hasNull = schemas.some((s) => s.type === "null");
+  if (hasNull && nonNull.length === 1) {
+    return nullablePhpType(resolvePhpType(nonNull[0], pctx, visited));
+  }
+  if (schemas.length === 1) return resolvePhpType(schemas[0], pctx, visited);
+  return maybeNullable3(MIXED, schema);
+}
+function resolveEnumType3(schema) {
+  const backing = enumBacking(schema.enum);
+  if (backing === "int") return primitive("int");
+  if (backing === "string") return primitive("string");
+  return MIXED;
+}
+function phpStringify(schema, expr, pctx) {
+  const type = schemaToPhpType(schema, pctx);
+  if (type.deserialize.kind === "enum") {
+    return `${expr}->value`;
+  }
+  if (type.native.replace("?", "") === "bool") {
+    return `${expr} ? 'true' : 'false'`;
+  }
+  return expr;
+}
+function generatePhpModel(name, schema, pctx) {
+  const kind = pctx.kinds.get(name);
+  if (!kind || kind.kind === "alias") return null;
+  if (kind.kind === "enum") {
+    return generatePhpEnum(name, schema, kind.backing);
+  }
+  if (kind.kind === "constants") {
+    return generatePhpConstantsClass(name, schema, kind.backing);
+  }
+  if (schema.allOf) {
+    return generatePhpAllOfClass(name, schema, pctx);
+  }
+  if (schema.properties && schema.properties.size > 0) {
+    return generatePhpObjectClass(name, schema, pctx);
+  }
+  return null;
+}
+function generatePhpEnum(name, schema, backing) {
+  const lines = [];
+  lines.push(`enum ${phpClassName(name)}: ${backing}`);
+  lines.push("{");
+  const seen = /* @__PURE__ */ new Set();
+  for (const v of schema.enum) {
+    let caseName = phpEnumCaseName(String(v));
+    while (seen.has(caseName)) caseName = `${caseName}_`;
+    seen.add(caseName);
+    const literal = backing === "string" ? quotePhpString(String(v)) : String(v);
+    lines.push(`    case ${caseName} = ${literal};`);
+  }
+  lines.push("}");
+  return { code: lines.join("\n"), uses: [] };
+}
+function generatePhpConstantsClass(name, schema, backing) {
+  const lines = [];
+  lines.push(`final class ${phpClassName(name)}`);
+  lines.push("{");
+  const seen = /* @__PURE__ */ new Set();
+  for (const v of schema.enum) {
+    let constName = phpConstantName(String(v));
+    while (seen.has(constName)) constName = `${constName}_`;
+    seen.add(constName);
+    const literal = backing === "string" ? quotePhpString(String(v)) : String(v);
+    lines.push(`    public const ${constName} = ${literal};`);
+  }
+  lines.push("}");
+  return { code: lines.join("\n"), uses: [] };
+}
+function generatePhpObjectClass(name, schema, pctx) {
+  const properties = schema.properties;
+  const requiredFields = new Set(schema.required ?? []);
+  const { features } = pctx;
+  const uses = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const [propName, propSchema] of properties) {
+    entries.push({
+      wireName: propName,
+      safeName: phpPropertyName(propName),
+      type: schemaToPhpType(propSchema, pctx),
+      required: requiredFields.has(propName)
+    });
+  }
+  const ordered = [...entries.filter((e) => e.required), ...entries.filter((e) => !e.required)];
+  const lines = [];
+  const classKeywords = features.readonlyClass ? "final readonly class" : "final class";
+  lines.push(`${classKeywords} ${phpClassName(name)}`);
+  lines.push("{");
+  const docParams = ordered.filter((e) => e.type.doc.includes("[]") || e.type.doc.includes("array<"));
+  if (docParams.length > 0) {
+    lines.push("    /**");
+    for (const e of docParams) {
+      const doc = e.required ? e.type.doc : appendNullDoc(e.type.doc);
+      lines.push(`     * @param ${doc} $${e.safeName}`);
+    }
+    lines.push("     */");
+  }
+  lines.push("    public function __construct(");
+  const propKeywords = features.readonlyClass ? "public" : features.readonlyProps ? "public readonly" : "public";
+  for (const e of ordered) {
+    let native = e.type.native;
+    let suffix = "";
+    if (!e.required) {
+      if (native !== "mixed" && !native.startsWith("?")) {
+        native = `?${native}`;
+      }
+      suffix = " = null";
+    }
+    if (e.safeName !== e.wireName) {
+      lines.push(`        #[SerializedName(${quotePhpString(e.wireName)})]`);
+      uses.add(serializedNameImport(features));
+    }
+    lines.push(`        ${propKeywords} ${native} $${e.safeName}${suffix},`);
+  }
+  lines.push("    ) {");
+  lines.push("    }");
+  lines.push("}");
+  return { code: lines.join("\n"), uses: [...uses] };
+}
+function appendNullDoc(doc) {
+  return doc.endsWith("|null") ? doc : `${doc}|null`;
+}
+function serializedNameImport(features) {
+  return features.enums ? "Symfony\\Component\\Serializer\\Attribute\\SerializedName" : "Symfony\\Component\\Serializer\\Annotation\\SerializedName";
+}
+function generatePhpAllOfClass(name, schema, pctx) {
+  const schemas = schema.allOf;
+  const allProps = /* @__PURE__ */ new Map();
+  for (const s of schemas) {
+    collectPhpProperties(s, pctx, allProps);
+  }
+  if (allProps.size === 0) {
+    return null;
+  }
+  const mergedSchema = {
+    type: "object",
+    properties: /* @__PURE__ */ new Map(),
+    required: []
+  };
+  for (const [propName, prop] of allProps) {
+    mergedSchema.properties.set(propName, prop.schema);
+    if (prop.required) {
+      mergedSchema.required.push(propName);
+    }
+  }
+  return generatePhpObjectClass(name, mergedSchema, pctx);
+}
+function collectPhpProperties(schema, pctx, allProps, visitedRefs = /* @__PURE__ */ new Set()) {
+  if (schema.refName && pctx.conv.schemaLookup?.has(schema.refName)) {
+    if (visitedRefs.has(schema.refName)) return;
+    visitedRefs.add(schema.refName);
+    collectPhpProperties(pctx.conv.schemaLookup.get(schema.refName), pctx, allProps, visitedRefs);
+    return;
+  }
+  if (schema.allOf) {
+    for (const subSchema of schema.allOf) {
+      collectPhpProperties(subSchema, pctx, allProps, new Set(visitedRefs));
+    }
+  }
+  if (!schema.properties) return;
+  const required = new Set(schema.required ?? []);
+  for (const [propName, propSchema] of schema.properties) {
+    allProps.set(propName, {
+      schema: propSchema,
+      required: required.has(propName) || (allProps.get(propName)?.required ?? false)
+    });
+  }
+}
+function quotePhpString(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+
+// src/modes/shared/response-cases-php.ts
+function getPhpResponseDocType(op, pctx) {
+  const shapes = collectPhpSuccessShapes(op, pctx);
+  if (shapes.length === 0) return "null";
+  const distinctDocs = new Set(shapes.map((shape) => shapeDocType(shape)));
+  return distinctDocs.size === 1 ? shapeDocType(shapes[0]) : "mixed";
+}
+function generatePhpResponseCases(op, pctx) {
+  const cases = [];
+  for (const [statusCode, response] of orderResponseEntries(op.responses)) {
+    const matcher = phpStatusMatcher(statusCode);
+    if (!matcher) continue;
+    if (!isSuccessStatus(statusCode)) {
+      cases.push(`${matcher} => throw new ApiException($statusCode, $content, $headers, $requestUrl),`);
+      continue;
+    }
+    const shape = getPhpResponseShape(response, pctx);
+    cases.push(`${matcher} => new ApiResponse(${phpDataExpr(shape)}, $statusCode, $headers, $requestUrl),`);
+  }
+  cases.push("default => throw new ApiException($statusCode, $content, $headers, $requestUrl),");
+  return cases;
+}
+function phpDataExpr(shape) {
+  if (shape.mode === "empty") return "null";
+  if (shape.mode === "text") return "$content";
+  const target = shape.type.deserialize;
+  switch (target.kind) {
+    case "class":
+    case "enum":
+      return `$this->serializer->deserialize($content, ${target.name}::class, 'json')`;
+    case "classArray":
+      return `$this->serializer->deserialize($content, ${target.name}::class . '[]', 'json')`;
+    case "json":
+      return "json_decode($content, true, 512, \\JSON_THROW_ON_ERROR)";
+  }
+}
+function shapeDocType(shape) {
+  if (shape.mode === "empty") return "null";
+  if (shape.mode === "text") return "string";
+  return shape.type.doc;
+}
+function collectPhpSuccessShapes(op, pctx) {
+  const shapes = [];
+  for (const [statusCode, response] of op.responses) {
+    if (!isSuccessStatus(statusCode)) continue;
+    shapes.push(getPhpResponseShape(response, pctx));
+  }
+  return shapes;
+}
+function getPhpResponseShape(response, pctx) {
+  if (!response.hasBody) {
+    return { type: null, mode: "empty" };
+  }
+  const jsonSchema = response.contentTypes.get("application/json");
+  if (jsonSchema) {
+    return { type: schemaToPhpType(jsonSchema, pctx), mode: "json" };
+  }
+  return { type: null, mode: "text" };
+}
+function phpStatusMatcher(statusCode) {
+  if (statusCode === "default") return null;
+  const wildcardMatch = statusCode.match(/^([1-5])XX$/i);
+  if (wildcardMatch) {
+    const prefix = Number.parseInt(wildcardMatch[1], 10);
+    const start = prefix * 100;
+    return `$statusCode >= ${start} && $statusCode < ${start + 100}`;
+  }
+  const code = Number.parseInt(statusCode, 10);
+  return Number.isNaN(code) ? null : `$statusCode === ${code}`;
+}
+
+// src/modes/php/helpers.ts
+var RESERVED_LOCALS = /* @__PURE__ */ new Set(["response", "statusCode", "content", "headers", "requestUrl", "query", "options", "body", "url"]);
+function phpParamName(name) {
+  const safe = phpPropertyName(name);
+  return RESERVED_LOCALS.has(safe) ? `${safe}Param` : safe;
+}
+function phpFile(namespace, uses, code) {
+  const lines = ["<?php", "", "declare(strict_types=1);", "", `namespace ${namespace};`, ""];
+  const sorted = [...new Set(uses)].sort();
+  for (const use of sorted) {
+    lines.push(`use ${use};`);
+  }
+  if (sorted.length > 0) {
+    lines.push("");
+  }
+  lines.push(code);
+  lines.push("");
+  return lines.join("\n");
+}
+function generatePhpOperation(op, pctx) {
+  const { features } = pctx;
+  const entry = (p) => ({ param: p, safeName: phpParamName(p.name), type: schemaToPhpType(p.schema, pctx) });
+  const pathParams = op.parameters.filter((p) => p.in === "path").map(entry);
+  const queryParams = op.parameters.filter((p) => p.in === "query").map(entry);
+  const headerParams = op.parameters.filter((p) => p.in === "header").map(entry);
+  const hasBody = op.type === "mutation" && op.requestBody !== null;
+  const bodySchema = hasBody ? op.requestBody.contentTypes.get(op.requestBody.primaryContentType) ?? null : null;
+  const bodyType = bodySchema ? schemaToPhpType(bodySchema, pctx) : null;
+  const bodyRequired = hasBody && op.requestBody.required;
+  const sig = [];
+  for (const e of pathParams) {
+    sig.push({ decl: `${e.type.native} $${e.safeName}`, docType: docTypeIfUseful(e.type), safeName: e.safeName, required: true });
+  }
+  if (bodyType) {
+    if (bodyRequired) {
+      sig.push({ decl: `${bodyType.native} $body`, docType: docTypeIfUseful(bodyType), safeName: "body", required: true });
+    } else {
+      sig.push({
+        decl: `${optionalNative(bodyType)} $body = null`,
+        docType: nullableDoc(docTypeIfUseful(bodyType)),
+        safeName: "body",
+        required: false
+      });
+    }
+  }
+  for (const e of [...queryParams, ...headerParams]) {
+    if (e.param.required) {
+      sig.push({ decl: `${e.type.native} $${e.safeName}`, docType: docTypeIfUseful(e.type), safeName: e.safeName, required: true });
+    } else {
+      sig.push({
+        decl: `${optionalNative(e.type)} $${e.safeName} = null`,
+        docType: nullableDoc(docTypeIfUseful(e.type)),
+        safeName: e.safeName,
+        required: false
+      });
+    }
+  }
+  const ordered = [...sig.filter((s) => s.required), ...sig.filter((s) => !s.required)];
+  const responseDocType = getPhpResponseDocType(op, pctx);
+  const lines = [];
+  lines.push("    /**");
+  if (op.description) {
+    lines.push(`     * ${op.description.replace(/\n/g, " ").trim()}`);
+    lines.push("     *");
+  }
+  for (const s of ordered) {
+    if (s.docType) {
+      lines.push(`     * @param ${s.docType} $${s.safeName}`);
+    }
+  }
+  lines.push(`     * @return ApiResponse<${responseDocType}>`);
+  lines.push("     * @throws ApiException");
+  if (op.deprecated && !features.deprecatedAttribute) {
+    lines.push("     * @deprecated Deprecated in the OpenAPI specification");
+  }
+  lines.push("     */");
+  if (op.deprecated && features.deprecatedAttribute) {
+    lines.push("    #[\\Deprecated(message: 'Deprecated in the OpenAPI specification')]");
+  }
+  if (features.noDiscard) {
+    lines.push("    #[\\NoDiscard]");
+  }
+  lines.push(`    public function ${op.operationId}(${ordered.map((s) => s.decl).join(", ")}): ApiResponse`);
+  lines.push("    {");
+  if (queryParams.length > 0) {
+    lines.push("        $query = [];");
+    for (const e of queryParams) {
+      const value = phpStringify(e.param.schema, `$${e.safeName}`, pctx);
+      if (e.param.required) {
+        lines.push(`        $query[${quotePhpString(e.param.name)}] = ${value};`);
+      } else {
+        lines.push(`        if ($${e.safeName} !== null) {`);
+        lines.push(`            $query[${quotePhpString(e.param.name)}] = ${value};`);
+        lines.push("        }");
+      }
+    }
+    lines.push("");
+  }
+  if (headerParams.length > 0) {
+    lines.push("        $headerValues = [];");
+    for (const e of headerParams) {
+      const value = phpStringify(e.param.schema, `$${e.safeName}`, pctx);
+      if (e.param.required) {
+        lines.push(`        $headerValues[${quotePhpString(e.param.name)}] = ${value};`);
+      } else {
+        lines.push(`        if ($${e.safeName} !== null) {`);
+        lines.push(`            $headerValues[${quotePhpString(e.param.name)}] = ${value};`);
+        lines.push("        }");
+      }
+    }
+    lines.push("");
+  }
+  const pathExpr = phpPathExpr(op.path, pathParams, pctx);
+  if (features.uriExtension) {
+    lines.push(`        $url = new \\Uri\\Rfc3986\\Uri($this->baseUrl . ${pathExpr})->toString();`);
+  } else {
+    lines.push(`        $url = $this->baseUrl . ${pathExpr};`);
+  }
+  const hasOptions = queryParams.length > 0 || headerParams.length > 0 || bodyType !== null;
+  if (hasOptions) {
+    lines.push("        $options = [];");
+    if (queryParams.length > 0) {
+      if (queryParams.some((e) => e.param.required)) {
+        lines.push("        $options['query'] = $query;");
+      } else {
+        lines.push("        if ($query !== []) {");
+        lines.push("            $options['query'] = $query;");
+        lines.push("        }");
+      }
+    }
+    if (headerParams.length > 0) {
+      if (headerParams.some((e) => e.param.required)) {
+        lines.push("        $options['headers'] = $headerValues;");
+      } else {
+        lines.push("        if ($headerValues !== []) {");
+        lines.push("            $options['headers'] = $headerValues;");
+        lines.push("        }");
+      }
+    }
+    if (bodyType) {
+      const body = phpBodyLines(bodyType);
+      if (bodyRequired) {
+        lines.push(...body.map((l) => `        ${l}`));
+      } else {
+        lines.push("        if ($body !== null) {");
+        lines.push(...body.map((l) => `            ${l}`));
+        lines.push("        }");
+      }
+    }
+    lines.push("");
+    lines.push(`        $response = $this->client->request(${quotePhpString(op.method.toUpperCase())}, $url, $options);`);
+  } else {
+    lines.push("");
+    lines.push(`        $response = $this->client->request(${quotePhpString(op.method.toUpperCase())}, $url);`);
+  }
+  lines.push("");
+  lines.push("        $statusCode = $response->getStatusCode();");
+  lines.push("        $content = $response->getContent(false);");
+  lines.push("        $headers = $response->getHeaders(false);");
+  lines.push("        $requestUrl = (string) $response->getInfo('url');");
+  lines.push("");
+  lines.push("        return match (true) {");
+  for (const c of generatePhpResponseCases(op, pctx)) {
+    lines.push(`            ${c}`);
+  }
+  lines.push("        };");
+  lines.push("    }");
+  return lines.join("\n");
+}
+function optionalNative(type) {
+  if (type.native === "mixed" || type.native.startsWith("?")) return type.native;
+  return `?${type.native}`;
+}
+function docTypeIfUseful(type) {
+  return type.doc.includes("[]") || type.doc.includes("array<") ? type.doc : null;
+}
+function nullableDoc(doc) {
+  if (doc === null) return null;
+  return doc.endsWith("|null") ? doc : `${doc}|null`;
+}
+function phpBodyLines(bodyType) {
+  const bare = bodyType.native.replace("?", "");
+  const isModelLike = bodyType.deserialize.kind !== "json" || bare === "array";
+  if (!isModelLike) {
+    return ["$options['json'] = $body;"];
+  }
+  return [
+    "$options['headers']['Content-Type'] = 'application/json';",
+    "$options['body'] = $this->serializer->serialize($body, 'json', [AbstractObjectNormalizer::SKIP_NULL_VALUES => true]);"
+  ];
+}
+function phpPathExpr(path, pathParams, pctx) {
+  const parts = [];
+  const regex = /\{([^}]+)\}/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(path)) !== null) {
+    const literal = path.slice(lastIndex, match.index);
+    if (literal) parts.push(quotePhpString(literal));
+    parts.push(pathParamExpr(match[1], pathParams, pctx));
+    lastIndex = regex.lastIndex;
+  }
+  const tail = path.slice(lastIndex);
+  if (tail) parts.push(quotePhpString(tail));
+  return parts.length > 0 ? parts.join(" . ") : quotePhpString(path);
+}
+function pathParamExpr(paramName, pathParams, pctx) {
+  const entry = pathParams.find((e) => e.param.name === paramName);
+  if (!entry) return quotePhpString(`{${paramName}}`);
+  const stringified = phpStringify(entry.param.schema, `$${entry.safeName}`, pctx);
+  const needsCast = stringified === `$${entry.safeName}` && entry.type.native.replace("?", "") !== "string";
+  return `rawurlencode(${needsCast ? `(string) $${entry.safeName}` : stringified})`;
+}
+
+// src/modes/php/query.ts
+function generatePhpQuery(op, pctx) {
+  return generatePhpOperation(op, pctx);
+}
+
+// src/modes/php/mutation.ts
+function generatePhpMutation(op, pctx) {
+  return generatePhpOperation(op, pctx);
+}
+
+// src/modes/php/runtime.ts
+function generatePhpRuntimeFiles(php, features) {
+  const files = /* @__PURE__ */ new Map();
+  files.set("ApiResponse.php", phpFile(php.namespace, [], apiResponseClass(features)));
+  files.set("ApiException.php", phpFile(php.namespace, [], apiExceptionClass(features)));
+  files.set("SerializerFactory.php", phpFile(php.namespace, serializerFactoryUses(features), serializerFactoryClass(features)));
+  return files;
+}
+function apiResponseClass(features) {
+  const classKeywords = features.readonlyClass ? "final readonly class" : "final class";
+  const prop = features.readonlyClass ? "public" : features.readonlyProps ? "public readonly" : "public";
+  return [
+    "/**",
+    " * @template T",
+    " */",
+    `${classKeywords} ApiResponse`,
+    "{",
+    "    /**",
+    "     * @param T $data",
+    "     * @param array<string, string[]> $headers Response headers (keys are lower-cased by Symfony HttpClient)",
+    "     */",
+    "    public function __construct(",
+    `        ${prop} mixed $data,`,
+    `        ${prop} int $status,`,
+    `        ${prop} array $headers,`,
+    `        ${prop} string $url,`,
+    "    ) {",
+    "    }",
+    "}"
+  ].join("\n");
+}
+function apiExceptionClass(features) {
+  const prop = features.readonlyProps ? "public readonly" : "public";
+  return [
+    "class ApiException extends \\RuntimeException",
+    "{",
+    "    /**",
+    "     * @param array<string, string[]> $responseHeaders",
+    "     */",
+    "    public function __construct(",
+    `        ${prop} int $statusCode,`,
+    `        ${prop} ?string $body,`,
+    `        ${prop} array $responseHeaders,`,
+    `        ${prop} string $url,`,
+    "    ) {",
+    "        parent::__construct(sprintf('API error %d (%s)', $statusCode, $url));",
+    "    }",
+    "}"
+  ].join("\n");
+}
+function serializerFactoryUses(features) {
+  const uses = [
+    "Symfony\\Component\\PropertyInfo\\Extractor\\PhpDocExtractor",
+    "Symfony\\Component\\PropertyInfo\\Extractor\\ReflectionExtractor",
+    "Symfony\\Component\\PropertyInfo\\PropertyInfoExtractor",
+    "Symfony\\Component\\Serializer\\Encoder\\JsonEncoder",
+    "Symfony\\Component\\Serializer\\Mapping\\Factory\\ClassMetadataFactory",
+    "Symfony\\Component\\Serializer\\NameConverter\\MetadataAwareNameConverter",
+    "Symfony\\Component\\Serializer\\Normalizer\\ArrayDenormalizer",
+    "Symfony\\Component\\Serializer\\Normalizer\\ObjectNormalizer",
+    "Symfony\\Component\\Serializer\\Serializer"
+  ];
+  if (features.enums) {
+    uses.push("Symfony\\Component\\Serializer\\Mapping\\Loader\\AttributeLoader");
+    uses.push("Symfony\\Component\\Serializer\\Normalizer\\BackedEnumNormalizer");
+  } else {
+    uses.push("Symfony\\Component\\Serializer\\Mapping\\Loader\\AnnotationLoader");
+  }
+  return uses;
+}
+function serializerFactoryClass(features) {
+  const loader = features.enums ? "AttributeLoader" : "AnnotationLoader";
+  const normalizers = features.enums ? [
+    "            new BackedEnumNormalizer(),",
+    "            new ArrayDenormalizer(),",
+    "            new ObjectNormalizer($classMetadataFactory, $nameConverter, null, $propertyInfo),"
+  ] : ["            new ArrayDenormalizer(),", "            new ObjectNormalizer($classMetadataFactory, $nameConverter, null, $propertyInfo),"];
+  return [
+    "final class SerializerFactory",
+    "{",
+    "    public static function create(): Serializer",
+    "    {",
+    `        $classMetadataFactory = new ClassMetadataFactory(new ${loader}());`,
+    "        $nameConverter = new MetadataAwareNameConverter($classMetadataFactory);",
+    "        $propertyInfo = new PropertyInfoExtractor(",
+    "            [],",
+    "            [new PhpDocExtractor(), new ReflectionExtractor()],",
+    "        );",
+    "",
+    "        return new Serializer(",
+    "            [",
+    ...normalizers,
+    "            ],",
+    "            [new JsonEncoder()],",
+    "        );",
+    "    }",
+    "}"
+  ].join("\n");
+}
+
+// src/modes/php/index.ts
+var phpMode = {
+  name: "php",
+  nativeTarget: true,
+  generateFiles(ctx) {
+    const php = ctx.php ?? { namespace: ctx.clientName, phpVersion: "8.1" };
+    const features = phpFeatures(php.phpVersion);
+    const conv = createConversionContext(new Set(ctx.document.schemas.keys()), void 0, ctx.document.schemas);
+    const kinds = classifyPhpSchemas(ctx.document.schemas, features);
+    const modelCtx = { conv, php, features, kinds, classPrefix: "" };
+    const clientCtx = { ...modelCtx, classPrefix: "Model\\" };
+    const files = /* @__PURE__ */ new Map();
+    for (const [name, schema] of ctx.document.schemas) {
+      const chunk = generatePhpModel(name, schema, modelCtx);
+      if (!chunk) continue;
+      files.set(`Model/${phpClassName(name)}.php`, phpFile(`${php.namespace}\\Model`, chunk.uses, chunk.code));
+    }
+    for (const [relPath, content] of generatePhpRuntimeFiles(php, features)) {
+      files.set(relPath, content);
+    }
+    files.set(`${ctx.clientName}.php`, generatePhpClientFile(ctx, clientCtx));
+    return files;
+  }
+};
+function generatePhpClientFile(ctx, pctx) {
+  const { clientName } = ctx;
+  const { features, php } = pctx;
+  const servers = ctx.document.servers;
+  const defaultServer = servers[0];
+  const lines = [];
+  lines.push(`final class ${clientName}`);
+  lines.push("{");
+  if (defaultServer) {
+    if (features.typedConstants) {
+      lines.push(`    public const string DEFAULT_BASE_URL = ${quotePhpString(defaultServer.url)};`);
+    } else {
+      lines.push(`    public const DEFAULT_BASE_URL = ${quotePhpString(defaultServer.url)};`);
+    }
+    lines.push("");
+    lines.push("    /** @var array<string, string> */");
+    const constKeyword = features.typedConstants ? "public const array" : "public const";
+    lines.push(`    ${constKeyword} SERVERS = [`);
+    for (const server of servers) {
+      lines.push(`        ${quotePhpString(server.name)} => ${quotePhpString(server.url)},`);
+    }
+    lines.push("    ];");
+    lines.push("");
+  }
+  const propKeyword = features.readonlyProps ? "private readonly" : "private";
+  lines.push(`    ${propKeyword} SerializerInterface $serializer;`);
+  lines.push("");
+  lines.push("    public function __construct(");
+  lines.push(`        ${propKeyword} HttpClientInterface $client,`);
+  if (defaultServer) {
+    lines.push(`        ${propKeyword} string $baseUrl = self::DEFAULT_BASE_URL,`);
+  } else {
+    lines.push(`        ${propKeyword} string $baseUrl,`);
+  }
+  lines.push("        ?SerializerInterface $serializer = null,");
+  lines.push("    ) {");
+  lines.push("        $this->serializer = $serializer ?? SerializerFactory::create();");
+  lines.push("    }");
+  const queries = ctx.document.operations.filter((op) => op.type === "query");
+  const mutations = ctx.document.operations.filter((op) => op.type === "mutation");
+  if (queries.length > 0) {
+    lines.push("");
+    lines.push("    // \u2500\u2500 Queries \u2500\u2500");
+    for (const op of queries) {
+      lines.push("");
+      lines.push(generatePhpQuery(op, pctx));
+    }
+  }
+  if (mutations.length > 0) {
+    lines.push("");
+    lines.push("    // \u2500\u2500 Mutations \u2500\u2500");
+    for (const op of mutations) {
+      lines.push("");
+      lines.push(generatePhpMutation(op, pctx));
+    }
+  }
+  lines.push("}");
+  const code = lines.join("\n");
+  const uses = ["Symfony\\Component\\Serializer\\SerializerInterface", "Symfony\\Contracts\\HttpClient\\HttpClientInterface"];
+  if (code.includes("AbstractObjectNormalizer::")) {
+    uses.push("Symfony\\Component\\Serializer\\Normalizer\\AbstractObjectNormalizer");
+  }
+  return phpFile(php.namespace, uses, code);
+}
+
 // src/modes/mode.ts
 function getMode(name) {
   switch (name) {
@@ -21173,8 +22135,10 @@ function getMode(name) {
       return swiftMode;
     case "kotlin":
       return kotlinMode;
+    case "php":
+      return phpMode;
     default:
-      throw new Error(`Unknown mode: ${name}. Expected "full", "playwright", "swift", or "kotlin".`);
+      throw new Error(`Unknown mode: ${name}. Expected "full", "playwright", "swift", "kotlin", or "php".`);
   }
 }
 
@@ -21289,25 +22253,40 @@ function filterUsedImports(names, source, importStatement) {
 // src/pipeline.ts
 async function generate(options) {
   const { input: input2, outputDir: outputDir2, name, mode: modeName } = options;
+  const mode2 = getMode(modeName);
   const document = await parseOpenApiDocument((0, import_node_path.resolve)(input2));
-  if (modeName === "swift" || modeName === "kotlin") {
+  if (mode2.nativeTarget) {
     hoistAnonymousSchemas(document);
   }
   document.schemas = topologicalSortSchemas(document.schemas);
-  const mode2 = getMode(modeName);
   const ctx = {
     document,
     zodSchemas: /* @__PURE__ */ new Map(),
     clientName: name,
     mode: modeName
   };
+  if (modeName === "php") {
+    ctx.php = {
+      namespace: options.namespace ?? name,
+      phpVersion: options.phpVersion ?? "8.1"
+    };
+  }
   const namedSchemas = new Set(document.schemas.keys());
   const convCtx = createConversionContext(namedSchemas, void 0, document.schemas);
-  if (modeName !== "swift" && modeName !== "kotlin") {
+  if (!mode2.nativeTarget) {
     for (const [schemaName, schema] of document.schemas) {
       ctx.zodSchemas.set(schemaName, schemaToZod(schema, convCtx));
     }
   }
+  if ("generateFiles" in mode2) {
+    const rootDir = (0, import_node_path.resolve)(outputDir2, name);
+    for (const [relPath, content] of mode2.generateFiles(ctx)) {
+      const absPath = (0, import_node_path.join)(rootDir, relPath);
+      (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(absPath), { recursive: true });
+      (0, import_node_fs.writeFileSync)(absPath, content, "utf-8");
+    }
+    return rootDir;
+  }
   const parts = [];
   parts.push(mode2.generateImports(ctx));
   parts.push(mode2.generateHelperTypes(ctx));
@@ -21325,10 +22304,9 @@ async function generate(options) {
     }
   }
   parts.push(mode2.generateClient(document.operations, ctx));
-  const output = modeName === "swift" || modeName === "kotlin" ? parts.join("\n") : removeDeadCode(parts.join("\n"));
+  const output = mode2.nativeTarget ? parts.join("\n") : removeDeadCode(parts.join("\n"));
   (0, import_node_fs.mkdirSync)((0, import_node_path.resolve)(outputDir2), { recursive: true });
-  const extMap = { swift: ".swift", kotlin: ".kt" };
-  const ext = extMap[modeName] ?? ".ts";
+  const ext = mode2.fileExtension ?? ".ts";
   const outputPath = (0, import_node_path.resolve)(outputDir2, `${name}${ext}`);
   (0, import_node_fs.writeFileSync)(outputPath, output, "utf-8");
   return outputPath;
@@ -21545,21 +22523,28 @@ function generateSchemaSection(ctx, namedSchemas, convCtx) {
   return lines.join("\n");
 }
 
+// src/types.ts
+var PHP_VERSIONS = ["8.0", "8.1", "8.2", "8.3", "8.4", "8.5"];
+
 // src/bin.ts
 var HELP = `
-Usage: openapi-client <spec.json> <output-dir> -n <ClassName> [-m full|playwright|swift|kotlin]
+Usage: openapi-client <spec.json> <output-dir> -n <ClassName> [-m full|playwright|swift|kotlin|php]
 
 Options:
-  -n, --name <name>    Client class name (required)
-  -m, --mode <mode>    Generation mode: "full", "playwright", "swift", or "kotlin" (default: "full")
-  -v, --version        Show version
-  -h, --help           Show help
+  -n, --name <name>       Client class name (required)
+  -m, --mode <mode>       Generation mode: "full", "playwright", "swift", "kotlin", or "php" (default: "full")
+      --namespace <ns>    Root PHP namespace, php mode only (default: --name)
+      --php-version <v>   Target PHP version, php mode only: ${PHP_VERSIONS.join("|")} (default: "8.1")
+  -v, --version           Show version
+  -h, --help              Show help
 `;
 var { values, positionals } = (0, import_node_util.parseArgs)({
   args: process.argv.slice(2),
   options: {
     name: { type: "string", short: "n" },
     mode: { type: "string", short: "m", default: "full" },
+    namespace: { type: "string" },
+    "php-version": { type: "string", default: "8.1" },
     version: { type: "boolean", short: "v" },
     help: { type: "boolean", short: "h" }
   },
@@ -21590,12 +22575,36 @@ if (!TS_IDENTIFIER_RE.test(values.name)) {
   process.exit(1);
 }
 var mode = values.mode;
-if (mode !== "full" && mode !== "playwright" && mode !== "swift" && mode !== "kotlin") {
-  console.error(`Error: --mode must be "full", "playwright", "swift", or "kotlin", got "${mode}".`);
+if (mode !== "full" && mode !== "playwright" && mode !== "swift" && mode !== "kotlin" && mode !== "php") {
+  console.error(`Error: --mode must be "full", "playwright", "swift", "kotlin", or "php", got "${mode}".`);
   process.exit(1);
 }
+var phpVersion = values["php-version"];
+if (mode === "php") {
+  const PHP_IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+  const PHP_NAMESPACE_RE = /^[a-zA-Z_][a-zA-Z0-9_]*(\\[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+  if (!PHP_IDENTIFIER_RE.test(values.name)) {
+    console.error(`Error: --name "${values.name}" is not a valid PHP class name.`);
+    process.exit(1);
+  }
+  if (values.namespace !== void 0 && !PHP_NAMESPACE_RE.test(values.namespace)) {
+    console.error(`Error: --namespace "${values.namespace}" is not a valid PHP namespace (expected e.g. "App\\Api\\Petstore").`);
+    process.exit(1);
+  }
+  if (!PHP_VERSIONS.includes(phpVersion)) {
+    console.error(`Error: --php-version must be one of ${PHP_VERSIONS.join(", ")}, got "${phpVersion}".`);
+    process.exit(1);
+  }
+} else {
+  if (values.namespace !== void 0) {
+    console.warn(`Warning: --namespace is only used in php mode, ignoring.`);
+  }
+  if (values["php-version"] !== "8.1") {
+    console.warn(`Warning: --php-version is only used in php mode, ignoring.`);
+  }
+}
 console.log(`Generating ${values.name} in ${mode} mode from ${input}...`);
-generate({ input, outputDir, name: values.name, mode }).then((outputPath) => {
+generate({ input, outputDir, name: values.name, mode, namespace: values.namespace, phpVersion }).then((outputPath) => {
   console.log(`Generated: ${outputPath}`);
 }).catch((error) => {
   console.error("Generation failed:", error.message || error);