@sdk-it/dart 0.20.0 → 0.22.0

package/dist/index.js

@@ -1,501 +1,299 @@
 // packages/dart/src/lib/generate.ts
 import { parse as partContentType } from "fast-content-type-parse";
-import { merge as merge2 } from "lodash-es";
-import assert2 from "node:assert";
-import { writeFile } from "node:fs/promises";
+import { readdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { camelcase as camelcase3 } from "stringcase";
+import { camelcase as camelcase2 } from "stringcase";
 import yaml from "yaml";
 import {
-  followRef as followRef3,
   isEmpty as isEmpty2,
-  isRef as isRef3,
-  notRef as notRef2,
+  isRef as isRef2,
   pascalcase as pascalcase2,
+  resolveRef as resolveRef2,
   snakecase as snakecase2
 } from "@sdk-it/core";
-import { getFolderExportsV2, writeFiles } from "@sdk-it/core/file-system.js";
-
-// packages/spec/dist/lib/loaders/local-loader.js
-import { parse } from "yaml";
-
-// packages/spec/dist/lib/loaders/remote-loader.js
-import { parse as parse2 } from "yaml";
-
-// packages/spec/dist/lib/operation.js
-import { camelcase } from "stringcase";
-import { followRef, isRef } from "@sdk-it/core";
-var defaults = {
-  operationId: (operation, path, method) => {
-    if (operation.operationId) {
-      return camelcase(operation.operationId);
-    }
-    const metadata = operation["x-oaiMeta"];
-    if (metadata && metadata.name) {
-      return camelcase(metadata.name);
-    }
-    return camelcase(
-      [method, ...path.replace(/[\\/\\{\\}]/g, " ").split(" ")].filter(Boolean).join(" ").trim()
-    );
-  },
-  tag: (operation, path) => {
-    return operation.tags?.[0] ? sanitizeTag(operation.tags?.[0]) : determineGenericTag(path, operation);
-  }
-};
-function resolveResponses(spec, operation) {
-  const responses = operation.responses ?? {};
-  const resolved = {};
-  for (const status in responses) {
-    const response = isRef(responses[status]) ? followRef(spec, responses[status].$ref) : responses[status];
-    resolved[status] = response;
-  }
-  return resolved;
-}
-function forEachOperation(config, callback) {
-  const result = [];
-  for (const [path, pathItem] of Object.entries(config.spec.paths ?? {})) {
-    const { parameters = [], ...methods } = pathItem;
-    const fixedPath = path.replace(/:([^/]+)/g, "{$1}");
-    for (const [method, operation] of Object.entries(methods)) {
-      const formatOperationId = config.operationId ?? defaults.operationId;
-      const formatTag = config.tag ?? defaults.tag;
-      const operationName = formatOperationId(operation, fixedPath, method);
-      const operationTag = formatTag(operation, fixedPath);
-      const metadata = operation["x-oaiMeta"] ?? {};
-      result.push(
-        callback(
-          {
-            name: metadata.name,
-            method,
-            path: fixedPath,
-            groupName: operationTag,
-            tag: operationTag
-          },
-          {
-            ...operation,
-            parameters: [...parameters, ...operation.parameters ?? []],
-            operationId: operationName,
-            responses: resolveResponses(config.spec, operation)
-          }
-        )
-      );
-    }
-  }
-  return result;
-}
-var reservedKeywords = /* @__PURE__ */ new Set([
-  "await",
-  // Reserved in async functions
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "enum",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "implements",
-  // Strict mode
-  "import",
-  "in",
-  "instanceof",
-  "interface",
-  // Strict mode
-  "let",
-  // Strict mode
-  "new",
-  "null",
-  "package",
-  // Strict mode
-  "private",
-  // Strict mode
-  "protected",
-  // Strict mode
-  "public",
-  // Strict mode
-  "return",
-  "static",
-  // Strict mode
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "yield",
-  // Strict mode / Generator functions
-  // 'arguments' is not technically a reserved word, but it's a special identifier within functions
-  // and assigning to it or declaring it can cause issues or unexpected behavior.
-  "arguments"
-]);
-function sanitizeTag(camelCasedTag) {
-  if (/^\d/.test(camelCasedTag)) {
-    return `_${camelCasedTag}`;
-  }
-  return reservedKeywords.has(camelcase(camelCasedTag)) ? `${camelCasedTag}_` : camelCasedTag;
-}
-function determineGenericTag(pathString, operation) {
-  const operationId = operation.operationId || "";
-  const VERSION_REGEX = /^[vV]\d+$/;
-  const commonVerbs = /* @__PURE__ */ new Set([
-    // Verbs to potentially strip from operationId prefix
-    "get",
-    "list",
-    "create",
-    "update",
-    "delete",
-    "post",
-    "put",
-    "patch",
-    "do",
-    "send",
-    "add",
-    "remove",
-    "set",
-    "find",
-    "search",
-    "check",
-    "make"
-  ]);
-  const segments = pathString.split("/").filter(Boolean);
-  const potentialCandidates = segments.filter(
-    (segment) => segment && !segment.startsWith("{") && !segment.endsWith("}") && !VERSION_REGEX.test(segment)
-  );
-  for (let i = potentialCandidates.length - 1; i >= 0; i--) {
-    const segment = potentialCandidates[i];
-    if (!segment.startsWith("@")) {
-      return sanitizeTag(camelcase(segment));
-    }
-  }
-  const canFallbackToPathSegment = potentialCandidates.length > 0;
-  if (operationId) {
-    const lowerOpId = operationId.toLowerCase();
-    const parts = operationId.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").replace(/([a-zA-Z])(\d)/g, "$1_$2").replace(/(\d)([a-zA-Z])/g, "$1_$2").toLowerCase().split(/[_-\s]+/);
-    const validParts = parts.filter(Boolean);
-    if (commonVerbs.has(lowerOpId) && validParts.length === 1 && canFallbackToPathSegment) {
-    } else if (validParts.length > 0) {
-      const firstPart = validParts[0];
-      const isFirstPartVerb = commonVerbs.has(firstPart);
-      if (isFirstPartVerb && validParts.length > 1) {
-        const verbPrefixLength = firstPart.length;
-        let nextPartStartIndex = -1;
-        if (operationId.length > verbPrefixLength) {
-          const charAfterPrefix = operationId[verbPrefixLength];
-          if (charAfterPrefix >= "A" && charAfterPrefix <= "Z") {
-            nextPartStartIndex = verbPrefixLength;
-          } else if (charAfterPrefix >= "0" && charAfterPrefix <= "9") {
-            nextPartStartIndex = verbPrefixLength;
-          } else if (["_", "-"].includes(charAfterPrefix)) {
-            nextPartStartIndex = verbPrefixLength + 1;
-          } else {
-            const match = operationId.substring(verbPrefixLength).match(/[A-Z0-9]/);
-            if (match && match.index !== void 0) {
-              nextPartStartIndex = verbPrefixLength + match.index;
-            }
-            if (nextPartStartIndex === -1 && operationId.length > verbPrefixLength) {
-              nextPartStartIndex = verbPrefixLength;
-            }
-          }
-        }
-        if (nextPartStartIndex !== -1 && nextPartStartIndex < operationId.length) {
-          const remainingOriginalSubstring = operationId.substring(nextPartStartIndex);
-          const potentialTag = camelcase(remainingOriginalSubstring);
-          if (potentialTag) {
-            return sanitizeTag(potentialTag);
-          }
-        }
-        const potentialTagJoined = camelcase(validParts.slice(1).join("_"));
-        if (potentialTagJoined) {
-          return sanitizeTag(potentialTagJoined);
-        }
-      }
-      const potentialTagFull = camelcase(operationId);
-      if (potentialTagFull) {
-        const isResultSingleVerb = validParts.length === 1 && isFirstPartVerb;
-        if (!(isResultSingleVerb && canFallbackToPathSegment)) {
-          if (potentialTagFull.length > 0) {
-            return sanitizeTag(potentialTagFull);
-          }
-        }
-      }
-      const firstPartCamel = camelcase(firstPart);
-      if (firstPartCamel) {
-        const isFirstPartCamelVerb = commonVerbs.has(firstPartCamel);
-        if (!isFirstPartCamelVerb || validParts.length === 1 || !canFallbackToPathSegment) {
-          return sanitizeTag(firstPartCamel);
-        }
-      }
-      if (isFirstPartVerb && validParts.length > 1 && validParts[1] && canFallbackToPathSegment) {
-        const secondPartCamel = camelcase(validParts[1]);
-        if (secondPartCamel) {
-          return sanitizeTag(secondPartCamel);
-        }
-      }
-    }
-  }
-  if (potentialCandidates.length > 0) {
-    let firstCandidate = potentialCandidates[0];
-    if (firstCandidate.startsWith("@")) {
-      firstCandidate = firstCandidate.substring(1);
-    }
-    if (firstCandidate) {
-      return sanitizeTag(camelcase(firstCandidate));
-    }
-  }
-  console.warn(
-    `Could not determine a suitable tag for path: ${pathString}, operationId: ${operationId}. Using 'unknown'.`
-  );
-  return "unknown";
-}
-function parseJsonContentType(contentType) {
-  if (!contentType) {
-    return null;
-  }
-  let mainType = contentType.trim();
-  const semicolonIndex = mainType.indexOf(";");
-  if (semicolonIndex !== -1) {
-    mainType = mainType.substring(0, semicolonIndex).trim();
-  }
-  mainType = mainType.toLowerCase();
-  if (mainType.endsWith("/json")) {
-    return mainType.split("/")[1];
-  } else if (mainType.endsWith("+json")) {
-    return mainType.split("+")[1];
-  }
-  return null;
-}
-function isStreamingContentType(contentType) {
-  return contentType === "application/octet-stream";
-}
-function isSuccessStatusCode(statusCode) {
-  statusCode = Number(statusCode);
-  return statusCode >= 200 && statusCode < 300;
-}
+import {
+  createWriterProxy,
+  getFolderExportsV2,
+  writeFiles
+} from "@sdk-it/core/file-system.js";
+import {
+  augmentSpec,
+  cleanFiles,
+  forEachOperation,
+  isSseContentType,
+  isStreamingContentType,
+  isSuccessStatusCode,
+  parseJsonContentType,
+  readWriteMetadata
+} from "@sdk-it/spec";
 
 // packages/dart/src/lib/dart-emitter.ts
 import { merge } from "lodash-es";
 import assert from "node:assert";
-import { camelcase as camelcase2, snakecase } from "stringcase";
+import { camelcase, snakecase } from "stringcase";
 import {
-  cleanRef,
-  followRef as followRef2,
+  followRef,
   isEmpty,
-  isRef as isRef2,
+  isRef,
+  joinSkipDigits,
   notRef,
   parseRef,
-  pascalcase
+  pascalcase,
+  resolveRef
 } from "@sdk-it/core";
-var formatName = (it) => {
-  const startsWithDigitPattern = /^-?\d/;
-  if (typeof it === "number") {
-    if (Math.sign(it) === -1) {
-      return `$_${Math.abs(it)}`;
-    }
-    return `$${it}`;
-  }
-  if (it === "default") {
-    return "$default";
+import {
+  coerceTypes,
+  formatName,
+  getRefUsage,
+  isPrimitiveSchema,
+  sanitizeTag
+} from "@sdk-it/spec";
+function coearceObject(schema) {
+  schema = structuredClone(schema);
+  if (schema["x-properties"]) {
+    schema.properties = {
+      ...schema.properties ?? {},
+      ...schema["x-properties"] ?? {}
+    };
   }
-  if (typeof it === "string") {
-    if (startsWithDigitPattern.test(it)) {
-      if (typeof it === "number") {
-        if (Math.sign(it) === -1) {
-          return `$_${Math.abs(it)}`;
-        }
-        return `$${it}`;
-      }
-    }
-    let nameToFormat = it;
-    if (nameToFormat.startsWith("[")) {
-      nameToFormat = nameToFormat.slice(1);
-    }
-    if (nameToFormat.endsWith("]")) {
-      nameToFormat = nameToFormat.slice(0, -1);
-    }
-    return snakecase(nameToFormat);
+  if (schema["x-required"]) {
+    schema.required = Array.from(
+      /* @__PURE__ */ new Set([
+        ...Array.isArray(schema.required) ? schema.required : [],
+        ...schema["x-required"] || []
+      ])
+    );
   }
-  return snakecase(String(it));
-};
+  return schema;
+}
 var DartSerializer = class {
   #spec;
-  #emit;
-  constructor(spec, emit) {
+  #emitHandler;
+  #emitHistory = /* @__PURE__ */ new Set();
+  #emit(name, content, schema) {
+    if (this.#emitHistory.has(content)) {
+      return;
+    }
+    this.#emitHistory.add(content);
+    this.#emitHandler?.(name, content, schema);
+  }
+  constructor(spec) {
     this.#spec = spec;
-    this.#emit = emit;
   }
-  #getRefUsage(schemaName, list = []) {
-    this.#spec.components ??= {};
-    this.#spec.components.schemas ??= {};
-    this.#spec.components.responses ??= {};
-    const checkSchema = (schema) => {
-      if (isRef2(schema)) {
-        const { model } = parseRef(schema.$ref);
-        return model === schemaName;
-      }
-      if (schema.oneOf && Array.isArray(schema.oneOf)) {
-        return schema.oneOf.some(
-          (subSchema) => checkSchema(subSchema)
-        );
-      }
-      if (schema.type === "array" && schema.items && notRef(schema.items) && schema.items.oneOf) {
-        return checkSchema(schema.items);
-      }
-      return false;
-    };
-    for (const [key, value] of Object.entries(this.#spec.components.schemas)) {
-      if (checkSchema(value)) {
-        list.push(key);
-      }
+  onEmit(emit) {
+    this.#emitHandler = emit;
+  }
+  #formatKeyName(name) {
+    if (name.startsWith("$")) {
+      return `\\${name}`;
     }
-    return list;
+    return name;
   }
   #object(className, schema, context) {
-    if (schema.additionalProperties) {
-      this.#emit(className, `typedef ${className} = Map<String, dynamic>;`);
-      return {
-        content: "",
-        use: "Map<String, dynamic>",
-        encode: "input",
-        toJson: `this.${camelcase2(context.name)}`,
-        fromJson: `json['${camelcase2(context.name)}']`,
-        matches: `json['${camelcase2(context.name)}'] is Map<String, dynamic>`
-      };
-    }
-    if (isEmpty(schema.properties)) {
-      if (context.noEmit !== true) {
-        this.#emit(
+    const { properties = {}, required = [] } = coearceObject(schema);
+    if (schema.additionalProperties || isEmpty(properties)) {
+      if (context.requestize) {
+        return this.#object(
           className,
-          `class ${className} {
-  const ${className}(); // Add const constructor
-
-  factory ${className}.fromJson(Map<String, dynamic> json) {
-    return const ${className}();
-  }
-
-  Map<String, dynamic> toJson() => {};
-
-  /// Determines if a given map can be parsed into an instance of this class.
-  /// Returns true for any map since this class has no properties.
-  static bool matches(Map<String, dynamic> json) {
-    return true; // Any map is fine for an empty object
-  }
-}`
+          {
+            type: "object",
+            properties: {
+              $body: { "x-special": true }
+            }
+          },
+          context
+        );
+      }
+      if (context.noEmit !== true && !context.propName) {
+        this.#emit(
+          pascalcase(formatName(className)),
+          `typedef ${pascalcase(className)} = Map<String, dynamic>;`,
+          schema
         );
       }
       return {
         content: "",
-        encode: "input.toJson()",
-        use: className,
-        toJson: `${this.#safe(context.name, context.required)}`,
-        fromJson: `${className}.fromJson(json['${context.name}'])`,
-        matches: `${className}.matches(json['${context.name}'])`
+        use: `Map<String, dynamic>`,
+        encode: "input",
+        encodeV2: "",
+        fromJson: context.parsable,
+        matches: `${context.parsable} is Map<String, dynamic>`
       };
     }
+    let requestContent = "";
     const props = [];
     const toJsonProperties = [];
     const constructorParams = [];
     const fromJsonParams = [];
     const matches = [];
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
+    const headers = [];
+    const params = [];
+    const queryParams = [];
+    const bodyParams = [];
+    for (const [key, propSchema] of Object.entries(properties)) {
       const propName = key.replace("[]", "");
-      const required = (schema.required ?? []).includes(key);
-      const typeStr = this.handle(className, propSchema, required, {
+      const safePropName = camelcase(formatName(propName));
+      const requiredProp = required.includes(key);
+      const jsonKey = this.#formatKeyName(propName);
+      const serializedType = this.handle(className, propSchema, requiredProp, {
         name: propName,
-        required,
-        propName: [className, propName].filter(Boolean).join("_")
+        safeName: safePropName,
+        required: requiredProp,
+        propName: isRef(propSchema) ? pascalcase(propName) : joinSkipDigits([className, propName], "_"),
+        parsable: `json['${jsonKey}']`
       });
-      const nullable2 = typeStr.nullable || !required;
-      const nullableSuffix = nullable2 ? "?" : "";
+      const nullable2 = serializedType.nullable || !requiredProp;
+      const nullableSuffix = serializedType.use === "dynamic" ? "" : nullable2 ? "?" : "";
+      const withValue = serializedType.literal !== void 0 ? ` = ${serializedType.literal}` : "";
       props.push(
-        `final ${typeStr.use}${nullableSuffix} ${camelcase2(propName)};`
+        `final ${serializedType.use}${nullableSuffix} ${safePropName} ${withValue};`
       );
-      fromJsonParams.push(`${camelcase2(propName)}: ${typeStr.fromJson}`);
-      toJsonProperties.push(`'${propName}': ${typeStr.toJson}`);
-      constructorParams.push(
-        `${required ? "required " : ""}this.${camelcase2(propName)},`
+      toJsonProperties.push(
+        `'${jsonKey}': ${safePropName}${serializedType.encodeV2}`
       );
-      if (required) {
+      if (!withValue) {
+        fromJsonParams.push(`${safePropName}: ${serializedType.fromJson}`);
+        constructorParams.push(
+          `${requiredProp ? "required " : ""}this.${safePropName},`
+        );
+      }
+      if (requiredProp) {
         matches.push(`(
-  json.containsKey('${camelcase2(propName)}')
-  ? ${nullable2 ? `json['${propName}'] == null` : `json['${propName}'] != null`} ${typeStr.matches ? `&& ${typeStr.matches}` : ""}
+  json.containsKey('${jsonKey}')
+  ? ${nullable2 ? `json['${jsonKey}'] == null` : `json['${jsonKey}'] != null`} ${serializedType.matches ? `&& ${serializedType.matches}` : ""}
   : false)`);
       } else {
         matches.push(`(
-  json.containsKey('${camelcase2(propName)}')
-  ? ${nullable2 ? `json['${propName}'] == null` : `json['${propName}'] != null`} ${typeStr.matches ? `|| ${typeStr.matches}` : ""}
+  json.containsKey('${jsonKey}')
+  ? ${nullable2 ? `json['${jsonKey}'] == null` : `json['${jsonKey}'] != null`} ${serializedType.matches ? `|| ${serializedType.matches}` : ""}
   : true)`);
       }
+      const { "x-in": source, "x-special": special } = propSchema;
+      if (source) {
+        switch (source) {
+          case "header":
+            headers.push(`'${jsonKey}': ${safePropName}`);
+            break;
+          case "path":
+            params.push(`'${jsonKey}': ${safePropName}`);
+            break;
+          case "query":
+            queryParams.push(`'${jsonKey}': ${safePropName}`);
+            break;
+          default:
+            bodyParams.push(`'${jsonKey}': ${safePropName}`);
+        }
+      } else {
+        if (special) {
+          bodyParams.push(`$body${serializedType.encodeV2}`);
+        } else {
+          bodyParams.push(
+            `'${jsonKey}': ${safePropName}${serializedType.encodeV2}`
+          );
+        }
+      }
     }
-    const { mixins, withMixins } = this.#mixinise(className, context);
-    const content = `class ${className} ${withMixins} {
+    if (context.requestize) {
+      const body = bodyParams.length === 1 && bodyParams[0].startsWith("$body") ? bodyParams[0] : `${bodyParams.length ? `{${bodyParams.join(", ")}}` : "{}"}`;
+      requestContent = `
+        RequestInput toRequest() =>
+           RequestInput(
+          headers: ${headers.length ? `{${headers.join(", ")}}` : "{}"},
+          query: ${queryParams.length ? `{${queryParams.join(", ")}}` : "{}"},
+          params: ${params.length ? `{${params.join(", ")}}` : "{}"},
+          body: ${body}
+    );`;
+    }
+    const constructorP = constructorParams.length ? `{${constructorParams.join("\n")}}` : "";
+    const fixedClassName = pascalcase(sanitizeTag(className));
+    const content = `class ${fixedClassName} {
       ${props.join("\n")}
-      ${!mixins.length ? "const" : ""} ${className}({
-      ${constructorParams.join("\n")}})${mixins.length > 1 ? "" : `:super()`};
-       factory ${className}.fromJson(Map<String, dynamic> json) {
-return ${className}(
+      const ${fixedClassName}(${constructorP}): super();
+       factory ${fixedClassName}.fromJson(Map<String, dynamic> json) {
+return ${fixedClassName}(
 ${fromJsonParams.join(",\n")});
       }
       Map<String, dynamic> toJson() => {
 ${toJsonProperties.join(",\n")}
       };
-      static bool matches(Map<String, dynamic> json) {
-return ${matches.join(" && ")};
-      }
+      static bool matches(Map<String, dynamic> json) {return ${matches.join(" && ")};}
+
+      ${requestContent}
+
     }`;
-    if (context.noEmit !== true) {
-      this.#emit(className, content);
+    if (context.noEmit !== true && !context.propName) {
+      this.#emit(fixedClassName, content, schema);
     }
     const nullable = !context.required || context.nullable === true;
+    const generatedClassName = context.forJson || className;
     return {
-      use: className,
+      use: fixedClassName,
       content,
       encode: "input.toJson()",
-      toJson: `${this.#safe(context.name, context.required)}`,
-      fromJson: context.name ? `${context.forJson || className}.fromJson(json['${context.name}'])` : `${context.forJson || className}.fromJson(json)`,
-      matches: `${className}.matches(json['${context.name}'])`
+      encodeV2: `${context.required ? "" : "?"}.toJson()`,
+      fromJson: `${generatedClassName}.fromJson(${context.parsable})`,
+      matches: `${generatedClassName}.matches(${context.parsable})`
     };
   }
-  #safe(accces, required) {
-    return required ? `this.${camelcase2(accces)}.toJson()` : `this.${camelcase2(accces)} != null ? this.${camelcase2(accces)}!.toJson() : null`;
+  #oneOfObject(className, varientName, schemaOrRef, context) {
+    const schema = resolveRef(this.#spec, schemaOrRef);
+    const entries = Object.entries(schema.properties || {});
+    if (entries.length === 1) {
+      const [key, prop] = entries[0];
+      const serializedType2 = this.handle(
+        pascalcase(`${className} ${varientName}`),
+        prop,
+        true,
+        {
+          ...context,
+          propName: joinSkipDigits([varientName, key], "_"),
+          safeName: varientName,
+          parsable: `json['${varientName}']`
+        }
+      );
+      return {
+        typeStr: `${serializedType2.use}${serializedType2.nullable ? "?" : ""} ${key}`,
+        returnValue: `_Value({'${key}': ${key}${serializedType2.encodeV2}});`,
+        fromJson: serializedType2.fromJson
+      };
+    }
+    const serializedType = this.handle(className, schemaOrRef, true, {
+      ...context,
+      propName: joinSkipDigits([className, varientName], "_"),
+      safeName: varientName,
+      parsable: `json['${varientName}']`
+    });
+    return {
+      typeStr: `${serializedType.use} value`,
+      returnValue: `_Value(value.toJson());`,
+      fromJson: serializedType.fromJson
+    };
   }
   #array(className, schema, required = false, context) {
     if (!schema.items) {
       return {
         content: "",
         use: "List<dynamic>",
-        toJson: "",
-        fromJson: `List<dynamic>.from(${context.name ? `json['${context.name}']` : `json`})})`,
+        encodeV2: "",
+        fromJson: `List<dynamic>.from(${context.parsable})`,
         matches: ""
       };
     }
-    const itemsType = this.handle(className, schema.items, true, context);
-    const fromJson = required ? context.name ? `(json['${context.name}'] as List<${itemsType.simple ? itemsType.use : "dynamic"}>)
-            .map((it) => ${itemsType.simple ? "it" : `${itemsType.use}.fromJson(it)`})
-            .toList()` : `(json as List<${itemsType.simple ? itemsType.use : "dynamic"}>)
-            .map((it) => ${itemsType.simple ? "it" : `${itemsType.use}.fromJson(it)`})
-            .toList()` : context.name ? `json['${context.name}'] != null
-            ? (json['${context.name}'] as List<${itemsType.simple ? itemsType.use : "dynamic"}>)
-                .map((it) => ${itemsType.simple ? "it" : `${itemsType.use}.fromJson(it)`})
+    const itemsType = this.handle(className, schema.items, true, {
+      ...context,
+      parsable: "it"
+    });
+    const fromJson = required ? context.name ? `(${context.parsable} as List)
+            .map((it) => ${itemsType.simple ? `it as ${itemsType.use}` : `${itemsType.fromJson}`})
+            .toList()` : `(json as List)
+            .map((it) => ${itemsType.simple ? `it as ${itemsType.use}` : `${itemsType.fromJson}`})
+            .toList()` : context.name ? `${context.parsable} != null
+            ? (${context.parsable} as List)
+                .map((it) => ${itemsType.simple ? `it as ${itemsType.use}` : `${itemsType.fromJson}`})
                 .toList()
             : null` : `json != null
-            ? (json as List<${itemsType.simple ? itemsType.use : "dynamic"}>)
-                .map((it) => ${itemsType.simple ? "it" : `${itemsType.use}.fromJson(it)`})
+            ? (json as List)
+                .map((it) => ${itemsType.simple ? `it as ${itemsType.use}` : `${itemsType.fromJson}`})
                 .toList()
             : null`;
     return {
@@ -503,8 +301,9 @@ return ${matches.join(" && ")};
       content: "",
       use: `List<${itemsType.use}>`,
       fromJson,
-      toJson: `${context.required ? `this.${camelcase2(context.name)}${itemsType.simple ? "" : ".map((it) => it.toJson()).toList()"}` : `this.${camelcase2(context.name)}!= null? this.${camelcase2(context.name)}${itemsType.simple ? "" : "!.map((it) => it.toJson()).toList()"} : null`}`,
-      matches: `json['${camelcase2(context.name)}'].every((it) => ${itemsType.matches})`
+      simple: true,
+      encodeV2: `${itemsType.simple ? "" : `${context.required ? "" : "?"}.map((it) => ${itemsType.simple ? "it" : `it.toJson()`}).toList()`}`,
+      matches: context.parsable ? `(${context.parsable} as List).every((it) => ${itemsType.matches})` : `${context.parsable} is List && ${context.parsable}.every((it) => ${itemsType.matches})`
     };
   }
   /**
@@ -516,14 +315,15 @@ return ${matches.join(" && ")};
         return this.#string(schema, context);
       case "number":
       case "integer":
-        return this.number(schema, context);
+        return this.#number(schema, context);
       case "boolean":
         return {
           content: "",
           use: "bool",
-          toJson: `${camelcase2(context.name)}`,
-          fromJson: `json['${context.name}']`,
-          matches: `json['${context.name}'] is bool`
+          encodeV2: "",
+          simple: true,
+          fromJson: context.parsable,
+          matches: `${context.parsable} is bool`
         };
       case "object":
         return this.#object(className, schema, context);
@@ -532,38 +332,51 @@ return ${matches.join(" && ")};
       case "null":
         return {
           content: "",
+          encodeV2: "",
+          simple: true,
           use: "Null",
-          toJson: `${camelcase2(context.name)}`,
-          fromJson: `json['${context.name}']`
+          fromJson: context.parsable
         };
       default:
         return {
           content: "",
           use: "dynamic",
-          nullable: false,
-          toJson: `${camelcase2(context.name)}`,
-          fromJson: `json['${context.name}']`
+          encodeV2: "",
+          simple: true,
+          fromJson: context.parsable,
+          matches: "",
+          nullable: false
         };
     }
   }
   #ref(className, $ref, required, context) {
-    const schemaName = cleanRef($ref).split("/").pop();
-    const serialized = this.handle(
-      schemaName,
-      followRef2(this.#spec, $ref),
-      required,
-      {
+    const schemaName = pascalcase(sanitizeTag(parseRef($ref).model));
+    const schema = followRef(this.#spec, $ref);
+    if (isPrimitiveSchema(schema)) {
+      return this.handle(schemaName, schema, required, {
         ...context,
         propName: schemaName,
-        noEmit: !!context.alias || !!className || !context.forceEmit
-      }
-    );
-    return serialized;
+        noEmit: true,
+        // default to json in case this method is root level
+        parsable: context.parsable || "json"
+      });
+    }
+    const generatedClassName = context.forJson || schemaName;
+    const isDynamicObject = schema.type === "object" ? !!schema.additionalProperties || isEmpty(schema.properties) : schema.anyOf ? false : !schema.oneOf;
+    return {
+      use: pascalcase(schemaName),
+      content: "",
+      encode: "input.toJson()",
+      encodeV2: isDynamicObject ? "" : `${context.required ? "" : "?"}.toJson()`,
+      fromJson: isDynamicObject ? `${generatedClassName}.from(json)` : `${generatedClassName}.fromJson(${context.parsable || "json"})`,
+      matches: isDynamicObject ? `${context.parsable} is ${generatedClassName}` : `${generatedClassName}.matches(${context.parsable})`,
+      simple: isDynamicObject
+    };
   }
   // fixme: this method should no longer be needed because the logic in it is being preprocessed before emitting begins
   #allOf(className, schemas, context) {
     const name = pascalcase(context.propName || className);
-    const refs = schemas.filter(isRef2);
+    const refs = schemas.filter(isRef);
     const nonRefs = schemas.filter(notRef);
     if (nonRefs.some((it) => it.type && it.type !== "object")) {
       assert(false, `allOf ${name} must be an object`);
@@ -571,174 +384,169 @@ return ${matches.join(" && ")};
     const objectSchema = merge(
       {},
       ...nonRefs,
-      ...refs.map((ref) => followRef2(this.#spec, ref.$ref))
+      ...refs.map((ref) => followRef(this.#spec, ref.$ref))
     );
     delete objectSchema.allOf;
     return this.handle(name, objectSchema, true, context);
   }
-  #anyOf(className, schemas, context) {
-    if (schemas.length === 0) {
-      return {
-        content: "",
-        nullable: false,
-        use: "dynamic",
-        toJson: `${camelcase2(context.name)}`,
-        fromJson: `json['${context.name}']`
-      };
-    }
-    const nullSchemaIndex = schemas.findIndex((schema) => {
-      if (isRef2(schema)) {
-        const refSchema = followRef2(this.#spec, schema.$ref);
-        return refSchema.type === "null";
-      }
-      return schema.type === "null";
-    });
-    const anyOfSchemas = schemas.slice(0);
-    if (nullSchemaIndex >= 0) {
-      anyOfSchemas.splice(nullSchemaIndex, 1);
-    }
-    return this.handle(className, anyOfSchemas[0], true, {
-      ...context,
-      nullable: nullSchemaIndex >= 0
-    });
-  }
   #mixinise(name, context) {
-    const mixins = this.#getRefUsage(name);
+    const mixins = getRefUsage(this.#spec, name);
     if (context.mixin) {
       mixins.unshift(context.mixin);
     }
-    const withMixins = mixins.length > 1 ? ` with ${mixins.join(", ")}` : mixins.length === 1 ? `extends ${mixins[0]}` : "";
+    const withMixins = mixins.length > 1 ? ` implements ${mixins.join(", ")}` : mixins.length === 1 ? `extends ${mixins[0]}` : "";
     return {
       withMixins,
       mixins
     };
   }
-  #oneOf(className, schemas, context) {
-    const name = pascalcase(context.propName || className);
+  #buildClass(options) {
+    return [
+      options.abstract ? "abstract" : "",
+      options.mixins?.length ? "" : "mixin",
+      `class ${options.name} ${options.withMixins} ${options.implements?.length ? `implements ${options.implements.join(", ")}` : ""}`,
+      "{",
+      options.content.join("\n"),
+      "}"
+    ].filter(Boolean).join("\n");
+  }
+  #oneOf(className, schema, context) {
+    const varients = schema["x-varients"];
+    const schemas = schema.oneOf || schema.anyOf || [];
+    const name = pascalcase(sanitizeTag(context.propName || className));
     if (schemas.length === 0) {
       return {
         content: "",
         nullable: false,
         use: "dynamic",
-        toJson: `${camelcase2(context.name)}`,
-        fromJson: `json['${context.name}']`
+        encodeV2: "",
+        fromJson: context.parsable
       };
     }
     const content = [];
     const patterns = [];
-    const objects = schemas.filter(notRef).filter((it) => it.type === "object");
-    for (const schema of schemas) {
-      if (isRef2(schema)) {
-        const refType = this.#ref(className, schema.$ref, true, context);
-        patterns.push({
-          pattern: `case ${refType.type || "Map<String, dynamic>"} map when ${refType.use}.matches(map): return ${refType.use}.fromJson(map);`,
-          name: refType.use
-        });
-      } else if (schema.type === "string") {
-        content.push(`class ${name}Text with ${name} {
-          final String value;
-          ${name}Text(this.value);
-          @override
-          dynamic toJson() => value;
-          static bool matches(dynamic value) {
-    return value is String;
-        }}
-          `);
-        patterns.push({
-          pattern: `case String(): return ${name}Text(json);`,
-          name: `${name}Text`
-        });
-      } else if (schema.type === "array") {
-        const itemsType = this.handle(name, schema.items, true, {
-          ...context,
-          noEmit: true
-        });
-        content.push(`class ${name}List with ${name} {
-            final List<${itemsType.use}> value;
-            ${name}List(this.value);
-            @override
-            dynamic toJson() => value;
-  static bool matches(dynamic value) {
-    return value is List;
-        }}`);
-        patterns.push({
-          pattern: `case List(): return ${name}List(List<${itemsType.use}>.from(json));`,
-          name: `${name}List`
-        });
-      }
-    }
-    if (objects.length) {
-      const candidates = {};
-      for (const schema of objects) {
-        if (schema.additionalProperties === true) {
+    content.push(`class _Value implements ${name} {
+  final dynamic value;
+  const _Value(this.value);
+  @override
+  toJson() => value;
+}`);
+    for (const { name: varientName, ...varient } of varients) {
+      switch (varientName) {
+        case "empty":
+          patterns.push({
+            name: `static ${name} ${formatName(varientName)}() => _Value("");`,
+            pattern: `case '': return ${name}.${formatName(varientName)}();`
+          });
+          continue;
+        case "uri":
+          patterns.push({
+            name: `static ${name} ${formatName(varientName)}(Uri value) => _Value(value);`,
+            pattern: `case String: return ${name}.${formatName(varientName)}(Uri.parse(json));`
+          });
+          continue;
+        case "number":
+          patterns.push({
+            name: `static ${name} ${formatName(varientName)}(num value) => _Value(value);`,
+            pattern: `case num: return ${name}.${formatName(varientName)}(json);`
+          });
+          continue;
+        case "object": {
+          const result = this.handle(className, schemas[varient.position]);
+          patterns.push({
+            name: `static ${name} ${formatName(varientName)}(${result.use} value) => _Value(value);`,
+            pattern: `case Map<String, dynamic> map: return ${name}.${formatName(varientName)}(${pascalcase(
+              `${name} ${formatName(varientName)}`
+            )}.fromJson(map));`
+          });
           continue;
-        }
-        assert(
-          schema.properties,
-          `Schema ${name} has no properties which are required in oneOf in order to determine the discriminator.`
-        );
-        for (const [propName, propSchema] of Object.entries(
-          schema.properties
-        )) {
-          if (notRef(propSchema) && propSchema.enum && // fixme: the enum can have more than one value as long as it is not duplicated else where on the other schemas
-          propSchema.enum.length === 1) {
-            candidates[propName] ??= /* @__PURE__ */ new Set();
-            candidates[propName].add(String(propSchema.enum[0]));
-          }
         }
       }
-      let discriminatorProp;
-      for (const [name2, values] of Object.entries(candidates)) {
-        if (
-          // make sure we pick the prop that exists on all objects
-          values.size === objects.filter((it) => it.properties?.[name2]).length
-        ) {
-          discriminatorProp = name2;
+      switch (varient.type) {
+        case "string":
+          patterns.push({
+            name: `static ${name} ${formatName(varientName)}(String value) => _Value(value);`,
+            pattern: `case String: return ${name}.${formatName(varientName)}(json);`
+          });
           break;
-        }
-      }
-      if (discriminatorProp) {
-        for (const schema of objects) {
-          const discriminatorValue = schema.properties[discriminatorProp].enum?.[0];
-          const varientName = `${name}${pascalcase(discriminatorValue)}`;
+        case "object": {
+          const { typeStr, returnValue, fromJson } = this.#oneOfObject(
+            name,
+            formatName(varientName),
+            schemas[varient.position],
+            context
+          );
+          const staticStr = varient.static ? `&& json['${varient.source}'] == '${formatName(varientName)}'` : "";
+          const caseStr = `case Map<String, dynamic> json when json.containsKey('${varient.source}') ${staticStr}`;
+          const returnStr = `return ${name}.${formatName(varientName)}(${fromJson})`;
           patterns.push({
-            pattern: `case Map<String, dynamic> map when ${varientName}.matches(json): return ${varientName}.fromJson(map);`,
-            name: varientName
+            name: `static ${name} ${formatName(varientName)}(${typeStr}) => ${returnValue}`,
+            pattern: `${caseStr}: ${returnStr};`
           });
-          const objResult = this.#object(varientName, schema, {
-            ...context,
-            noEmit: true,
-            mixin: name
+          break;
+        }
+        case "array": {
+          const serializedType = this.handle(
+            className,
+            schemas[varient.position],
+            true,
+            {
+              ...context,
+              noEmit: true,
+              parsable: "json"
+            }
+          );
+          patterns.push({
+            name: `static ${name} ${formatName(varientName)}(${serializedType.use} value) => _Value(value);`,
+            pattern: `case ${serializedType.use} json: return ${name}.${formatName(varientName)}(${serializedType.fromJson});`
           });
-          content.push(objResult.content);
+          break;
+        }
+        default: {
         }
       }
     }
     const { mixins, withMixins } = this.#mixinise(name, context);
-    content.unshift(`abstract ${mixins.length ? "" : "mixin"} class ${name} ${withMixins} {
-      dynamic toJson();
-      ${patterns.length ? `static ${name} fromJson(dynamic json) {
-      switch (json){
-        ${patterns.map((it) => it.pattern).join("\n")}
-        default:
-          throw ArgumentError("Invalid type for query property: \${json}");
-        }
-      }
-
-
-     ${patterns.length ? ` static bool matches(dynamic value) {
-        return ${patterns.map((it) => `value is ${it.name}`).join(" || ")};
-      }` : ""}
-
-      ` : ""}
-    }`);
-    this.#emit(name, content.join("\n"));
+    content.push(
+      this.#buildClass({
+        name,
+        abstract: true,
+        mixins,
+        withMixins,
+        content: [
+          // 'dynamic get value;',
+          "dynamic toJson();",
+          ...patterns.map((it) => it.name),
+          `${name}();`,
+          `factory ${name}.fromJson(dynamic json)`,
+          `{`,
+          `switch (json) {`,
+          ...patterns.map((it) => it.pattern),
+          `default: throw ArgumentError("Invalid type: \${json}");`,
+          `}`,
+          `}`,
+          `static bool matches(dynamic value) {
+    try {
+      ${name}.fromJson(value);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }`
+        ]
+      })
+    );
+    if (context.noEmit !== true) {
+      this.#emit(name, content.join("\n"), {
+        oneOf: schemas
+      });
+    }
     return {
       content: content.join("\n"),
       use: name,
-      toJson: `${this.#safe(context.name, context.required)}`,
-      fromJson: `${name}.fromJson(json['${context.name}'])`,
-      matches: `${name}.matches(json['${context.name}'])`
+      encodeV2: `${context.required ? "" : "?"}.toJson()`,
+      fromJson: `${name}.fromJson(${context.parsable})`,
+      matches: `${name}.matches(${context.parsable})`
     };
   }
   #simple(type) {
@@ -751,6 +559,12 @@ return ${matches.join(" && ")};
         return "int";
       case "boolean":
         return "bool";
+      case "object":
+        return "Map<String, dynamic>";
+      case "array":
+        return "List<dynamic>";
+      case "null":
+        return "Null";
       default:
         return "dynamic";
     }
@@ -758,17 +572,17 @@ return ${matches.join(" && ")};
   #enum(className, schema, context) {
     const name = context.propName || className;
     const values = schema.enum;
-    const valType = this.#simple(schema.type || "string");
-    const { mixins, withMixins } = this.#mixinise(className, context);
+    const valType = this.#simple(coerceTypes(schema)[0]);
+    const { mixins, withMixins } = this.#mixinise(name, context);
     const content = `
-  class _EnumValue implements ${pascalcase(name)} {
+  class _EnumValue implements ${pascalcase(formatName(name))} {
   final ${valType} value;
   const _EnumValue(this.value);
   @override
-  toJson() {return this.value;}
+  toJson() => value;
 }
-    abstract ${mixins.length ? "" : "mixin"} class ${pascalcase(name)} ${withMixins} {
-      ${values.map((it) => `static const _EnumValue ${formatName(it)} = _EnumValue(${typeof it === "number" ? it : `'${it}'`});`).join("\n")}
+    abstract ${mixins.length ? "" : "mixin"} class ${pascalcase(formatName(name))} ${withMixins} {
+      ${values.map((it) => `static const _EnumValue ${formatName(snakecase(formatName(it)))} = _EnumValue(${typeof it === "number" ? it : `'${it}'`});`).join("\n")}
       dynamic toJson();
 
       ${valType} get value;
@@ -776,7 +590,7 @@ return ${matches.join(" && ")};
       static _EnumValue fromJson(${valType} value) {
       switch (value) {
 ${values.map(
-      (it) => `case ${typeof it === "number" ? it : `'${it}'`}: return ${formatName(it)};`
+      (it) => `case ${typeof it === "number" ? it : `'${it}'`}: return ${formatName(snakecase(formatName(it)))};`
     ).join("\n")}
 default:
   throw ArgumentError.value(value, "value", "No enum value with that name");
@@ -794,15 +608,28 @@ return false;
 
     }`;
     if (context.noEmit !== true) {
-      this.#emit(name, content);
+      this.#emit(pascalcase(formatName(name)), content, schema);
     }
     return {
-      type: Array.isArray(schema.type) ? this.#simple(schema.type[0]) : schema.type ? this.#simple(schema.type) : void 0,
+      use: pascalcase(formatName(name)),
+      type: this.#simple(coerceTypes(schema)[0]),
       content,
-      use: pascalcase(name),
-      toJson: `${context.required ? `this.${camelcase2(context.name)}.toJson()` : `this.${camelcase2(context.name)} != null ? this.${camelcase2(context.name)}!.toJson() : null`}`,
-      fromJson: `${pascalcase(name)}.fromJson(json['${context.name}'])`,
-      matches: `${pascalcase(name)}.matches(json['${context.name}'])`
+      encodeV2: `${context.required ? "" : "?"}.toJson()`,
+      fromJson: `${pascalcase(name)}.fromJson(${context.parsable})`,
+      matches: `${pascalcase(name)}.matches(${context.parsable})`
+    };
+  }
+  #const(className, schema, context) {
+    const valType = this.#simple(coerceTypes(schema)[0]);
+    return {
+      content: "",
+      literal: valType === "String" ? `'${schema.const}'` : schema.const,
+      use: valType,
+      encode: "input",
+      encodeV2: "",
+      fromJson: context.parsable,
+      matches: context.parsable,
+      simple: true
     };
   }
   /**
@@ -817,46 +644,44 @@ return false;
           content: "",
           use: "DateTime",
           simple: true,
-          toJson: context.required ? `this.${camelcase2(context.name)}.toIso8601String()` : `this.${camelcase2(context.name)} != null ? this.${camelcase2(
-            context.name
-          )}!.toIso8601String() : null`,
-          fromJson: context.name ? `json['${context.name}'] != null ? DateTime.parse(json['${context.name}']) : null` : "json",
-          matches: `json['${context.name}'] is String`
+          encodeV2: `${context.required ? "" : "?"}.toIso8601String()`,
+          fromJson: context.parsable ? context.required ? `DateTime.parse(${context.parsable})` : `${context.parsable} != null ? DateTime.parse(${context.parsable}) : null` : "json",
+          matches: `${context.parsable} is String`
         };
       case "binary":
       case "byte":
         return {
           content: "",
           use: "File",
-          toJson: `this.${camelcase2(context.name)}`,
+          encodeV2: "",
           simple: true,
-          fromJson: context.name ? `json['${context.name}']` : "json",
-          matches: `json['${context.name}'] is Uint8List`
+          fromJson: context.parsable,
+          matches: `${context.parsable} is Uint8List`
         };
       default:
         return {
           encode: "input",
           use: `String`,
           content: "",
+          encodeV2: "",
           simple: true,
-          toJson: `this.${camelcase2(context.name)}`,
-          fromJson: context.name ? `json['${context.name}'] as String` : "json",
-          matches: `json['${context.name}'] is String`
+          fromJson: `${context.parsable} as String`,
+          matches: `${context.parsable} is String`
         };
     }
   }
   /**
    * Handle number/integer types with formats
    */
-  number(schema, context) {
+  #number(schema, context) {
     if (schema.type === "integer") {
       return {
         content: "",
         use: "int",
         simple: true,
-        toJson: `this.${camelcase2(context.name)}`,
-        fromJson: `json['${context.name}']`,
-        matches: `json['${context.name}'] is int`
+        encodeV2: "",
+        fromJson: context.parsable,
+        matches: `${context.parsable} is int`
       };
     }
     if (["float", "double"].includes(schema.format)) {
@@ -864,37 +689,40 @@ return false;
         content: "",
         use: "double",
         simple: true,
-        toJson: `this.${camelcase2(context.name)}`,
-        fromJson: `json['${context.name}']`,
-        matches: `json['${context.name}'] is double`
+        encodeV2: "",
+        fromJson: context.parsable,
+        matches: `${context.parsable} is double`
       };
     }
     return {
       content: "",
       use: "num",
       simple: true,
-      toJson: `this.${camelcase2(context.name)}`,
-      fromJson: `json['${context.name}']`,
-      matches: `json['${context.name}'] is double`
+      encodeV2: "",
+      fromJson: context.parsable,
+      matches: `${context.parsable} is double`
     };
   }
   #serialize(className, schema, required = true, context = {}) {
-    if (isRef2(schema)) {
+    if (isRef(schema)) {
       return this.#ref(className, schema.$ref, required, context);
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
       return this.#allOf(className, schema.allOf, context);
     }
     if (schema.oneOf && Array.isArray(schema.oneOf)) {
-      return this.#oneOf(className, schema.oneOf, context);
+      return this.#oneOf(className, schema, context);
     }
     if (schema.anyOf && Array.isArray(schema.anyOf)) {
-      return this.#anyOf(className, schema.anyOf, context);
+      return this.#oneOf(className, schema, context);
+    }
+    if (schema.const !== void 0) {
+      return this.#const(className, schema, context);
     }
     if (schema.enum && Array.isArray(schema.enum)) {
       return this.#enum(className, schema, context);
     }
-    const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+    const types = coerceTypes(schema, false);
     let nullable = false;
     if ("nullable" in schema && schema.nullable) {
       nullable = true;
@@ -911,10 +739,12 @@ return false;
         return this.#array(className, schema, true, context);
       }
       return {
+        // Unknown type -> fallback
         content: "",
         use: "dynamic",
-        toJson: `${camelcase2(context.name)}`,
-        fromJson: `json['${context.name}']`,
+        encodeV2: "",
+        simple: true,
+        fromJson: context.parsable,
         nullable: false,
         matches: ""
         // keep it empty as 'type is dynamic' is always true
@@ -936,165 +766,70 @@ return false;
       forJson: alias
     });
     if (alias) {
-      this.#emit(className, `typedef ${alias} = ${serialized.use};`);
+      this.#emit(
+        pascalcase(formatName(className)),
+        `typedef ${pascalcase(alias)} = ${serialized.use};`,
+        resolveRef(this.#spec, schema)
+      );
       return serialized;
     }
     return serialized;
   }
 };
 function isObjectSchema(schema) {
-  return !isRef2(schema) && (schema.type === "object" || !!schema.properties);
+  return !isRef(schema) && (schema.type === "object" || !!coearceObject(schema).properties);
 }
 
 // packages/dart/src/lib/http/dispatcher.txt
-var dispatcher_default = "import 'dart:convert';\nimport 'dart:io';\n\nimport 'package:http/http.dart' as http;\nimport 'package:http_parser/http_parser.dart';\nimport 'package:mime/mime.dart' as mime;\n\nimport './interceptors.dart';\nimport './responses.dart';\n\nclass Dispatcher {\n  final List<Interceptor> interceptors;\n\n  Dispatcher(this.interceptors);\n\n  Future<http.StreamedResponse> multipart(\n    RequestConfig config,\n    Map<String, dynamic> body,\n  ) async {\n    final modifiedConfig = interceptors.fold(\n      config,\n      (acc, interceptor) => interceptor.before(acc),\n    );\n    final request = http.MultipartRequest(\n      modifiedConfig.method,\n      modifiedConfig.url,\n    );\n    request.headers.addAll(modifiedConfig.headers);\n    for (var entry in body.entries) {\n      final key = entry.key;\n      final value = entry.value;\n      if (value is File) {\n        final mimeType = mime.lookupMimeType(value.path);\n        request.files.add(\n          http.MultipartFile(\n            key,\n            value.openRead(),\n            await value.length(),\n            filename: value.uri.pathSegments.last,\n            contentType: mimeType != null ? MediaType.parse(mimeType) : null,\n          ),\n        );\n      } else {\n        request.fields[key] = value.toString();\n      }\n    }\n\n    return request.send();\n  }\n\n  Future<http.StreamedResponse> empty(RequestConfig config) {\n    final modifiedConfig = interceptors.fold(\n      config,\n      (acc, interceptor) => interceptor.before(acc),\n    );\n    final request = http.Request(modifiedConfig.method, modifiedConfig.url);\n    request.headers.addAll(modifiedConfig.headers);\n    return request.send();\n  }\n\n  Future<http.StreamedResponse> json(RequestConfig config, dynamic body) {\n    final modifiedConfig = interceptors.fold(\n      config,\n      (acc, interceptor) => interceptor.before(acc),\n    );\n    final request = http.Request(modifiedConfig.method, modifiedConfig.url);\n    request.headers.addAll(modifiedConfig.headers);\n\n    request.headers['Content-Type'] = 'application/json';\n    if ((body is Map || body is List)) {\n      request.body = jsonEncode(body);\n    } else if (body is String) {\n      request.body = body;\n    } else {\n      throw ArgumentError('Unsupported body type: ${body.runtimeType}');\n    }\n\n    return request.send();\n  }\n}\n\nclass Receiver {\n  final List<Interceptor> interceptors;\n  Receiver(this.interceptors);\n\n  dynamic _parse(http.Response response) {\n    final contentTypeHeader = response.headers['content-type'];\n    final parsed = parseContentType(contentTypeHeader);\n    if (parsed.type == 'application/json') {\n      return jsonDecode(response.body);\n    } else if (parsed.type == 'text/plain') {\n      return response.body;\n    } else if (parsed.type == 'application/octet-stream') {\n      return response.bodyBytes;\n    } else {\n      throw UnsupportedError('Unsupported content type: ${parsed.type}');\n    }\n  }\n\n  dynamic json(http.StreamedResponse stream) async {\n    if (stream.statusCode >= 200 && stream.statusCode < 300) {\n      final response = await http.Response.fromStream(stream);\n      return _parse(response);\n    }\n    switch (stream.statusCode) {\n      case 400:\n        throw BadRequestError('');\n      case 401:\n        throw UnauthorizedError('');\n      case 403:\n        throw ForbiddenError('');\n      case 404:\n        throw NotFoundError('');\n      case 500:\n        throw InternalServerError('');\n      case 402:\n        throw PaymentRequiredError('');\n      case 405:\n        throw MethodNotAllowedError('');\n      case 406:\n        throw NotAcceptableError('');\n      case 409:\n        throw ConflictError('');\n      case 410:\n        throw GoneError('');\n      case 422:\n        throw UnprocessableEntityError('');\n      case 429:\n        throw TooManyRequestsError('');\n      case 413:\n        throw PayloadTooLargeError('');\n      case 415:\n        throw UnsupportedMediaTypeError('');\n      case 501:\n        throw NotImplementedError('');\n      case 502:\n        throw BadGatewayError('');\n      case 503:\n        throw ServiceUnavailableError('');\n      case 504:\n        throw GatewayTimeoutError('');\n      default:\n        throw UnknownApiError('', stream.statusCode);\n    }\n  }\n}\n\n({String type, Map<String, String> parameters}) parseContentType(\n  String? contentTypeHeader,\n) {\n  if (contentTypeHeader == null || contentTypeHeader.isEmpty) {\n    return (type: '', parameters: {});\n  }\n  final parts = contentTypeHeader.split(';');\n  final type = parts[0].trim();\n  final parameters = <String, String>{};\n  for (var i = 1; i < parts.length; i++) {\n    final param = parts[i].split('=');\n    if (param.length == 2) {\n      parameters[param[0].trim()] = param[1].trim();\n    }\n  }\n\n  return (type: type, parameters: parameters);\n}\n";
+var dispatcher_default = "import 'dart:convert';\nimport 'dart:io';\n\nimport 'package:http/http.dart' as http;\nimport 'package:http_parser/http_parser.dart';\nimport 'package:mime/mime.dart' as mime;\n\nimport './interceptors.dart';\nimport './responses.dart';\n\nclass Dispatcher {\n  final List<Interceptor> interceptors;\n\n  Dispatcher(this.interceptors);\n\n  void _setHeaders(\n    http.BaseRequest request,\n    RequestConfig config, [\n    String? contentType,\n  ]) {\n    request.headers.addAll(config.headers);\n    for (var entry in config.input.headers.entries) {\n      final value = entry.value;\n      if (value != null) {\n        request.headers[entry.key] = value;\n      }\n    }\n    if (contentType != null) {\n      request.headers['Content-Type'] = contentType;\n    }\n  }\n\n  void _setParams(RequestConfig config) {\n    final params = config.input.params;\n    if (params.isEmpty) return;\n\n    String path = config.url.toString();\n    for (var entry in params.entries) {\n      path = path.replaceAll('{${entry.key}}', entry.value.toString());\n    }\n    config.url = Uri.parse(path);\n  }\n\n  void _setQuery(RequestConfig config) {\n    final query = config.input.query;\n    if (query.isEmpty) return;\n\n    final uri = config.url;\n    final queryParameters = Map<String, String>.from(uri.queryParameters);\n\n    for (var entry in query.entries) {\n      if (entry.value != null) {\n        queryParameters[entry.key] = entry.value.toString();\n      }\n    }\n\n    config.url = uri.replace(queryParameters: queryParameters);\n  }\n\n  Future<http.StreamedResponse> formdata(RequestConfig config) async {\n    final modifiedConfig = interceptors.fold(\n      config,\n      (acc, interceptor) => interceptor.before(acc),\n    );\n    _setParams(modifiedConfig);\n    _setQuery(modifiedConfig);\n    final request = http.MultipartRequest(\n      modifiedConfig.method,\n      modifiedConfig.url,\n    );\n    _setHeaders(request, modifiedConfig);\n\n    for (var entry in config.input.body.entries) {\n      final key = entry.key;\n      final value = entry.value;\n      if (value is File) {\n        final mimeType = mime.lookupMimeType(value.path);\n        request.files.add(\n          http.MultipartFile(\n            key,\n            value.openRead(),\n            await value.length(),\n            filename: value.uri.pathSegments.last,\n            contentType: mimeType != null ? MediaType.parse(mimeType) : null,\n          ),\n        );\n      } else {\n        request.fields[key] = value.toString();\n      }\n    }\n\n    return request.send();\n  }\n\n  Future<http.StreamedResponse> empty(RequestConfig config) {\n    final modifiedConfig = interceptors.fold(\n      config,\n      (acc, interceptor) => interceptor.before(acc),\n    );\n    _setParams(modifiedConfig);\n    _setQuery(modifiedConfig);\n    final request = http.Request(modifiedConfig.method, modifiedConfig.url);\n    _setHeaders(request, modifiedConfig);\n    return request.send();\n  }\n\n  Future<http.StreamedResponse> json(RequestConfig config) {\n    final modifiedConfig = interceptors.fold(\n      config,\n      (acc, interceptor) => interceptor.before(acc),\n    );\n    _setParams(modifiedConfig);\n    _setQuery(modifiedConfig);\n    final request = http.Request(modifiedConfig.method, modifiedConfig.url);\n    _setHeaders(request, modifiedConfig, 'application/json');\n\n    if ((config.input.body is Map || config.input.body is List)) {\n      request.body = jsonEncode(config.input.body);\n    } else if (config.input.body is String) {\n      request.body = config.input.body;\n    } else {\n      throw ArgumentError(\n        'Unsupported body type: ${config.input.body.runtimeType}',\n      );\n    }\n\n    return request.send();\n  }\n\n  Future<http.StreamedResponse> binary(RequestConfig config) async {\n    final modifiedConfig = interceptors.fold(\n      config,\n      (acc, interceptor) => interceptor.before(acc),\n    );\n    _setParams(modifiedConfig);\n    _setQuery(modifiedConfig);\n    final request = http.Request(modifiedConfig.method, modifiedConfig.url);\n    _setHeaders(request, modifiedConfig, 'application/octet-stream');\n\n    switch (config.input.body) {\n      case List<int> bytes:\n        request.bodyBytes = bytes;\n      case Stream<List<int>> stream:\n        request.bodyBytes = await stream.expand((x) => x).toList();\n      case String body:\n        request.body = body;\n      case File file:\n        request.bodyBytes = await file.readAsBytes();\n      default:\n        throw ArgumentError(\n          'Unsupported body type for binary request: ${config.input.body.runtimeType}',\n        );\n    }\n\n    return request.send();\n  }\n\n  Future<http.StreamedResponse> urlencoded(RequestConfig config) async {\n    final modifiedConfig = interceptors.fold(\n      config,\n      (acc, interceptor) => interceptor.before(acc),\n    );\n    _setParams(modifiedConfig);\n    _setQuery(modifiedConfig);\n    final request = http.Request(modifiedConfig.method, modifiedConfig.url);\n    _setHeaders(request, modifiedConfig, 'application/x-www-form-urlencoded');\n\n    // Convert body to URL-encoded string\n    final bodyMap = config.input.body;\n    request.body = bodyMap.entries\n        .map(\n          (entry) =>\n              '${Uri.encodeComponent(entry.key)}=${Uri.encodeComponent(entry.value.toString())}',\n        )\n        .join('&');\n\n    return request.send();\n  }\n}\n\nclass Receiver {\n  final List<Interceptor> interceptors;\n  Receiver(this.interceptors);\n\n  dynamic _parse(http.Response response) {\n    final contentTypeHeader = response.headers['content-type'];\n    final parsed = parseContentType(contentTypeHeader);\n    if (parsed.type.startsWith('application/json')) {\n      return jsonDecode(response.body);\n    } else if (parsed.type.startsWith('text/')) {\n      return response.body;\n    } else if (parsed.type == 'application/octet-stream') {\n      return response.bodyBytes;\n    } else {\n      throw UnsupportedError('Unsupported content type: ${parsed.type}');\n    }\n  }\n\n  Future<dynamic> json(http.StreamedResponse stream) async {\n    if (stream.statusCode >= 200 && stream.statusCode < 300) {\n      final response = await http.Response.fromStream(stream);\n      return _parse(response);\n    }\n    throw _handleError(stream);\n  }\n\n  Future<String> text(http.StreamedResponse stream) async {\n    if (stream.statusCode >= 200 && stream.statusCode < 300) {\n      final response = await http.Response.fromStream(stream);\n      return _parse(response);\n    }\n    throw _handleError(stream);\n  }\n\n  _handleError(http.StreamedResponse stream) {\n    switch (stream.statusCode) {\n      case 400:\n        throw BadRequestError('');\n      case 401:\n        throw UnauthorizedError('');\n      case 403:\n        throw ForbiddenError('');\n      case 404:\n        throw NotFoundError('');\n      case 500:\n        throw InternalServerError('');\n      case 402:\n        throw PaymentRequiredError('');\n      case 405:\n        throw MethodNotAllowedError('');\n      case 406:\n        throw NotAcceptableError('');\n      case 409:\n        throw ConflictError('');\n      case 410:\n        throw GoneError('');\n      case 422:\n        throw UnprocessableEntityError('');\n      case 429:\n        throw TooManyRequestsError('');\n      case 413:\n        throw PayloadTooLargeError('');\n      case 415:\n        throw UnsupportedMediaTypeError('');\n      case 501:\n        throw NotImplementedError('');\n      case 502:\n        throw BadGatewayError('');\n      case 503:\n        throw ServiceUnavailableError('');\n      case 504:\n        throw GatewayTimeoutError('');\n      default:\n        throw UnknownApiError('', stream.statusCode);\n    }\n  }\n}\n\n({String type, Map<String, String> parameters}) parseContentType(\n  String? contentTypeHeader,\n) {\n  if (contentTypeHeader == null || contentTypeHeader.isEmpty) {\n    return (type: '', parameters: {});\n  }\n  final parts = contentTypeHeader.split(';');\n  final type = parts[0].trim();\n  final parameters = <String, String>{};\n\n  for (var i = 1; i < parts.length; i++) {\n    final param = parts[i].split('=');\n    if (param.length == 2) {\n      parameters[param[0].trim()] = param[1].trim();\n    }\n  }\n\n  return (type: type, parameters: parameters);\n}\n";
 
 // packages/dart/src/lib/http/interceptors.txt
-var interceptors_default = "abstract class Interceptor {\n  RequestConfig before(RequestConfig config);\n  void after();\n}\n\nclass BaseUrlInterceptor extends Interceptor {\n  final String Function() getBaseUrl;\n  BaseUrlInterceptor(this.getBaseUrl);\n\n  @override\n  RequestConfig before(RequestConfig config) {\n    final baseUrl = getBaseUrl();\n    if (config.url.scheme.isEmpty) {\n      config.url = Uri.parse(baseUrl + config.url.toString());\n    }\n    return config;\n  }\n\n  @override\n  void after() {\n    //\n  }\n}\n\nclass RequestConfig {\n  final String method;\n  Uri url;\n  final Map<String, String> headers;\n  RequestConfig({required this.method, required this.url, required this.headers});\n}\n";
+var interceptors_default = "abstract class Interceptor {\n  RequestConfig before(RequestConfig config);\n  void after();\n}\n\nclass BaseUrlInterceptor extends Interceptor {\n  final String Function() getBaseUrl;\n  BaseUrlInterceptor(this.getBaseUrl);\n\n  @override\n  RequestConfig before(RequestConfig config) {\n    final baseUrl = getBaseUrl();\n    if (config.url.scheme.isEmpty) {\n      config.url = Uri.parse(baseUrl + config.url.toString());\n    }\n    return config;\n  }\n\n  @override\n  void after() {\n    //\n  }\n}\n\nclass LoggingInterceptor extends Interceptor {\n  // ANSI color codes\n  static const String _reset = '\\x1B[0m';\n  static const String _green = '\\x1B[32m';\n  static const String _yellow = '\\x1B[33m';\n  static const String _blue = '\\x1B[34m';\n  static const String _magenta = '\\x1B[35m';\n  static const String _cyan = '\\x1B[36m';\n\n  @override\n  RequestConfig before(RequestConfig config) {\n    print('${_cyan}[LOG] --- HTTP REQUEST ---$_reset');\n    print('${_yellow}[LOG] Method:    ${config.method.toUpperCase()}$_reset');\n    print('${_green}[LOG] URL:       ${config.url}$_reset');\n    print('${_magenta}[ContentType] ${config.headers['content-type']}$_reset');\n    if (config.headers.isNotEmpty) {\n      print('${_blue}[LOG] Headers:   ${config.headers}$_reset');\n    } else {\n      print('${_blue}[LOG] Headers:   <none>$_reset');\n    }\n    print('${_cyan}[LOG] --------------$_reset');\n    return config;\n  }\n\n  @override\n  void after() {\n    // Optionally log after the request\n  }\n}\n\nclass RequestConfig {\n  final String method;\n  Uri url;\n  final Map<String, String> headers;\n  final RequestInput input;\n\n  RequestConfig({\n    required this.method,\n    required this.url,\n    required this.headers,\n    this.input = const RequestInput.empty(),\n  });\n}\n\nclass RequestInput {\n  final Map<String, String?> headers;\n  final Map<String, dynamic> query;\n  final Map<String, dynamic> params;\n  final dynamic body;\n  RequestInput({\n    this.headers = const {},\n    this.query = const {},\n    this.params = const {},\n    required this.body,\n  });\n\n  const RequestInput.empty()\n    : headers = const {},\n      query = const {},\n      params = const {},\n      body = null;\n}\n";
 
 // packages/dart/src/lib/http/responses.txt
 var responses_default = "sealed class ApiError {\n  final String message;\n  final int? statusCode;\n  final String status;\n  const ApiError(this.message, {this.statusCode, this.status = ''});\n\n  @override\n  String toString() =>\n      'ApiError(status: $status, statusCode: $statusCode, message: $message)';\n}\n\nbase class BadRequestError extends ApiError {\n  const BadRequestError(String message)\n    : super(message, statusCode: 400, status: 'BadRequest');\n}\n\nbase class UnauthorizedError extends ApiError {\n  const UnauthorizedError(String message)\n    : super(message, statusCode: 401, status: 'Unauthorized');\n}\n\nbase class ForbiddenError extends ApiError {\n  const ForbiddenError(String message)\n    : super(message, statusCode: 403, status: 'Forbidden');\n}\n\nbase class NotFoundError extends ApiError {\n  const NotFoundError(String message)\n    : super(message, statusCode: 404, status: 'NotFound');\n}\n\nbase class InternalServerError extends ApiError {\n  const InternalServerError(String message)\n    : super(message, statusCode: 500, status: 'InternalServerError');\n}\n\nbase class UnknownApiError extends ApiError {\n  const UnknownApiError(String message, int statusCode)\n    : super(message, statusCode: statusCode, status: 'UnknownApiError');\n}\n\nbase class PaymentRequiredError extends ApiError {\n  const PaymentRequiredError(String message)\n    : super(message, statusCode: 402, status: 'PaymentRequired');\n}\n\nbase class MethodNotAllowedError extends ApiError {\n  const MethodNotAllowedError(String message)\n    : super(message, statusCode: 405, status: 'MethodNotAllowed');\n}\n\nbase class NotAcceptableError extends ApiError {\n  const NotAcceptableError(String message)\n    : super(message, statusCode: 406, status: 'NotAcceptable');\n}\n\nbase class ConflictError extends ApiError {\n  const ConflictError(String message)\n    : super(message, statusCode: 409, status: 'Conflict');\n}\n\nbase class GoneError extends ApiError {\n  const GoneError(String message)\n    : super(message, statusCode: 410, status: 'Gone');\n}\n\nbase class UnprocessableEntityError extends ApiError {\n  const UnprocessableEntityError(String message)\n    : super(message, statusCode: 422, status: 'UnprocessableEntity');\n}\n\nbase class TooManyRequestsError extends ApiError {\n  const TooManyRequestsError(String message)\n    : super(message, statusCode: 429, status: 'TooManyRequests');\n}\n\nbase class PayloadTooLargeError extends ApiError {\n  const PayloadTooLargeError(String message)\n    : super(message, statusCode: 413, status: 'PayloadTooLarge');\n}\n\nbase class UnsupportedMediaTypeError extends ApiError {\n  const UnsupportedMediaTypeError(String message)\n    : super(message, statusCode: 415, status: 'UnsupportedMediaType');\n}\n\nbase class NotImplementedError extends ApiError {\n  const NotImplementedError(String message)\n    : super(message, statusCode: 501, status: 'NotImplemented');\n}\n\nbase class BadGatewayError extends ApiError {\n  const BadGatewayError(String message)\n    : super(message, statusCode: 502, status: 'BadGateway');\n}\n\nbase class ServiceUnavailableError extends ApiError {\n  const ServiceUnavailableError(String message)\n    : super(message, statusCode: 503, status: 'ServiceUnavailable');\n}\n\nbase class GatewayTimeoutError extends ApiError {\n  const GatewayTimeoutError(String message)\n    : super(message, statusCode: 504, status: 'GatewayTimeout');\n}\n";
 
 // packages/dart/src/lib/generate.ts
-function tuneSpec(spec, schemas, refs) {
-  for (const [name, schema] of Object.entries(schemas)) {
-    if (isRef3(schema))
-      continue;
-    if (!isEmpty2(schema.anyOf) && !isEmpty2(schema.oneOf)) {
-      delete schema.anyOf;
-    }
-    if (!isEmpty2(schema.allOf)) {
-      const schemas2 = schema.allOf;
-      const refs2 = schemas2.filter(isRef3);
-      const nonRefs = schemas2.filter(notRef2);
-      if (nonRefs.some((it) => it.type && it.type !== "object")) {
-        assert2(false, `allOf ${name} must be an object`);
-      }
-      const objectSchema = merge2(
-        {},
-        ...nonRefs,
-        ...refs2.map((ref) => followRef3(spec, ref.$ref))
-      );
-      delete objectSchema.allOf;
-      delete schema.allOf;
-      Object.assign(schema, objectSchema);
-    }
-    if (schema.type === "object") {
-      if (!isEmpty2(schema.oneOf)) {
-        for (const oneOfIdx in schema.oneOf) {
-          const oneOf = schema.oneOf[oneOfIdx];
-          if (isRef3(oneOf))
-            continue;
-          if (!isEmpty2(oneOf.required) && schema.properties) {
-            schema.oneOf[oneOfIdx] = schema.properties[oneOf.required[0]];
-          }
-        }
-        delete schema.type;
-        tuneSpec(spec, schemas, refs);
-        continue;
-      }
-      schema.properties ??= {};
-      for (const [propName, value] of Object.entries(schema.properties)) {
-        if (isRef3(value))
-          continue;
-        const refName = pascalcase2(`${name} ${propName.replace("[]", "")}`);
-        refs.push({ name: refName, value });
-        schema.properties[propName] = {
-          $ref: `#/components/schemas/${refName}`
-        };
-        const props = Object.fromEntries(
-          Object.entries(value.properties ?? {}).map(([key, value2]) => {
-            return [pascalcase2(`${refName} ${key}`), value2];
-          })
-        );
-        tuneSpec(spec, props, refs);
-      }
-    } else if (schema.type === "array") {
-      if (isRef3(schema.items))
-        continue;
-      const refName = name;
-      refs.push({ name: refName, value: schema.items ?? {} });
-      schema.items = {
-        $ref: `#/components/schemas/${refName}`
-      };
-    }
-  }
-}
-async function generate(spec, settings) {
+async function generate(openapi, settings) {
+  const spec = augmentSpec({ spec: openapi }, true);
   const clientName = settings.name || "Client";
   const output = join(settings.output, "lib");
+  const { writer, files: writtenFiles } = createWriterProxy(
+    settings.writer ?? writeFiles,
+    settings.output
+  );
+  settings.writer = writer;
+  settings.readFolder ??= async (folder) => {
+    const files = await readdir(folder, { withFileTypes: true });
+    return files.map((file) => ({
+      fileName: file.name,
+      filePath: join(file.parentPath, file.name),
+      isFolder: file.isDirectory()
+    }));
+  };
   const groups = {};
-  spec.components ??= {};
-  spec.components.schemas ??= {};
-  const inputs = {};
-  const outputs = {};
-  forEachOperation({ spec }, (entry, operation) => {
-    operation.responses ??= {};
-    spec.components ??= {};
-    spec.components.schemas ??= {};
-    for (const status in operation.responses) {
-      if (!isSuccessStatusCode(status))
-        continue;
-      const response2 = operation.responses[status];
-      if (!isEmpty2(response2.content)) {
-        for (const [contentType, mediaType] of Object.entries(
-          response2.content
-        )) {
-          if (parseJsonContentType(contentType)) {
-            if (mediaType.schema && !isRef3(mediaType.schema)) {
-              const outputName = pascalcase2(`${operation.operationId} output`);
-              spec.components.schemas[outputName] = mediaType.schema;
-              operation.responses[status].content ??= {};
-              operation.responses[status].content[contentType].schema = {
-                $ref: `#/components/schemas/${outputName}`
-              };
-            }
-          }
-        }
-      }
-    }
+  forEachOperation(spec, (entry, operation) => {
     console.log(`Processing ${entry.method} ${entry.path}`);
-    const group = groups[entry.groupName] ?? (groups[entry.groupName] = {
+    const group = groups[entry.groupName] ??= {
       methods: [],
       use: `final ${entry.groupName} = new ${pascalcase2(entry.groupName)}();`
-    });
+    };
     const input = toInputs(spec, { entry, operation });
-    Object.assign(inputs, input.inputs);
     const response = toOutput(spec, operation);
-    if (response) {
-      Object.assign(outputs, response.outputs);
-    }
     group.methods.push(`
-        Future<${response ? response.returnType : "http.StreamedResponse"}> ${camelcase3(operation.operationId)}(
-       ${isEmpty2(operation.requestBody) ? "" : `${input.inputName} input`}
+        Future<${response ? response.returnType : "http.StreamedResponse"}> ${camelcase2(operation.operationId)}(
+       ${input.haveInput ? `${input.inputName} input` : ""}
         ) async {
           final stream = await this.dispatcher.${input.contentType}(RequestConfig(
             method: '${entry.method}',
             url: Uri.parse('${entry.path}'),
             headers: {},
-          ), ${["json", "multipart"].includes(input.contentType) ? input.encode : ``});
-          ${response ? `${response.decode};` : "return stream;"}
-      }
-    `);
+           ${input.haveInput ? "input: input.toRequest()" : ""}));
+            ${response ? `${response.decode};` : "return stream;"}
+            }
+            `);
   });
-  const newRefs = [];
-  tuneSpec(spec, spec.components.schemas, newRefs);
-  for (const ref of newRefs) {
-    spec.components.schemas[ref.name] = ref.value;
-  }
-  await writeFile(
-    join(process.cwd(), "openai.json"),
-    JSON.stringify(spec, null, 2)
-  );
-  const models = Object.entries(spec.components.schemas).reduce((acc, [name, schema]) => {
-    const serializer = new DartSerializer(spec, (name2, content) => {
-      acc[`models/${snakecase2(name2)}.dart`] = `import 'dart:io';import 'dart:typed_data'; import './index.dart';
-
-${content}`;
-    });
-    serializer.handle(pascalcase2(name), schema);
-    return acc;
-  }, {});
+  const models = serializeModels(spec);
   const clazzez = Object.entries(groups).reduce(
     (acc, [name, { methods }]) => {
       return {
@@ -1128,14 +863,14 @@ import './http.dart';
 
   class ${clientName} {
   final Options options;
-${Object.keys(groups).map((name) => `late final ${pascalcase2(name)}Client ${camelcase3(name)};`).join("\n")}
+${Object.keys(groups).map((name) => `late final ${pascalcase2(name)}Client ${camelcase2(name)};`).join("\n")}
 
   ${clientName}(this.options) {
-    final interceptors = [BaseUrlInterceptor(() => this.options.baseUrl)];
+    final interceptors = [BaseUrlInterceptor(() => this.options.baseUrl), LoggingInterceptor()];
     final dispatcher = Dispatcher(interceptors);
     final receiver = Receiver(interceptors);
     ${Object.keys(groups).map(
-    (name) => `this.${camelcase3(name)} = ${pascalcase2(name)}Client(dispatcher, receiver);`
+    (name) => `this.${camelcase2(name)} = ${pascalcase2(name)}Client(dispatcher, receiver);`
   ).join("\n")}
 
       }
@@ -1154,39 +889,63 @@ class Options {
 }
 
   `;
-  await writeFiles(output, {
-    ...models,
-    ...inputs,
-    ...outputs
-  });
-  await writeFiles(output, {
-    "models/index.dart": await getFolderExportsV2(join(output, "models"), {
-      exportSyntax: "export",
-      extensions: "dart"
-    }),
-    "inputs/index.dart": await getFolderExportsV2(join(output, "inputs"), {
-      exportSyntax: "export",
-      extensions: "dart"
-    }),
-    "outputs/index.dart": await getFolderExportsV2(join(output, "outputs"), {
-      exportSyntax: "export",
-      extensions: "dart"
-    }),
+  await settings.writer(output, models);
+  const metadata = await readWriteMetadata(
+    settings.output,
+    Array.from(writtenFiles)
+  );
+  if (settings.cleanup !== false && writtenFiles.size > 0) {
+    await cleanFiles(metadata.content, settings.output, [
+      "/package.dart",
+      "/**/index.dart",
+      "pubspec.yaml",
+      "/metadata.json"
+    ]);
+  }
+  await settings.writer(output, {
+    "models/index.dart": await getFolderExportsV2(
+      join(output, "models"),
+      settings.readFolder,
+      {
+        exportSyntax: "export",
+        extensions: "dart"
+      }
+    ),
+    "inputs/index.dart": await getFolderExportsV2(
+      join(output, "inputs"),
+      settings.readFolder,
+      {
+        exportSyntax: "export",
+        extensions: "dart"
+      }
+    ),
+    "outputs/index.dart": await getFolderExportsV2(
+      join(output, "outputs"),
+      settings.readFolder,
+      {
+        exportSyntax: "export",
+        extensions: "dart"
+      }
+    ),
     "interceptors.dart": interceptors_default,
     "http.dart": dispatcher_default,
     "responses.dart": responses_default,
     ...clazzez
   });
-  await writeFiles(output, {
-    "package.dart": `${await getFolderExportsV2(join(output), {
-      exportSyntax: "export",
-      extensions: "dart",
-      ignore(dirent) {
-        return dirent.isFile() && dirent.name === "package.dart";
+  await settings.writer(output, {
+    "package.dart": `${await getFolderExportsV2(
+      join(output),
+      settings.readFolder,
+      {
+        exportSyntax: "export",
+        extensions: "dart",
+        ignore(dirent) {
+          return !dirent.isFolder && dirent.fileName === "package.dart";
+        }
       }
-    })}${client}`
+    )}${client}`
   });
-  await writeFiles(settings.output, {
+  await settings.writer(settings.output, {
     "pubspec.yaml": {
       ignoreIfExists: true,
       content: yaml.stringify({
@@ -1202,85 +961,152 @@ class Options {
       })
     }
   });
+  await writeFile(
+    join(settings.output, "openapi.json"),
+    JSON.stringify(spec, null, 2)
+  );
   await settings.formatCode?.({
     output
   });
 }
 function toInputs(spec, { entry, operation }) {
-  const inputs = {};
-  const inputName = pascalcase2(`${operation.operationId} input`);
+  let inputName;
   let contentType = "empty";
   let encode = "";
-  if (!isEmpty2(operation.requestBody)) {
-    const requestBody = isRef3(operation.requestBody) ? followRef3(spec, operation.requestBody.$ref) : operation.requestBody;
-    for (const type in requestBody.content) {
-      const ctSchema = isRef3(requestBody.content[type].schema) ? followRef3(spec, requestBody.content[type].schema.$ref) : requestBody.content[type].schema;
-      if (!ctSchema) {
-        console.warn(
-          `Schema not found for ${type} in ${entry.method} ${entry.path}`
-        );
-        continue;
-      }
-      const serializer = new DartSerializer(spec, (name, content) => {
-        inputs[join(`inputs/${name}.dart`)] = `import 'dart:io';import 'dart:typed_data';import '../models/index.dart'; import './index.dart';
-
-${content}`;
-      });
-      const serialized = serializer.handle(inputName, ctSchema, true, {
-        alias: isObjectSchema(ctSchema) ? void 0 : inputName
-      });
-      encode = serialized.encode;
-      const [mediaType, mediaSubType] = partContentType(type).type.split("/");
-      if (mediaType === "application") {
-        contentType = parseJsonContentType(type);
-      } else {
-        contentType = mediaType;
-      }
+  let haveInput = false;
+  for (const type in operation.requestBody.content) {
+    const objectSchema = resolveRef2(
+      spec,
+      operation.requestBody.content[type].schema
+    );
+    const serializer = new DartSerializer(spec);
+    inputName = objectSchema["x-inputname"];
+    const serialized = serializer.handle(inputName, objectSchema, true, {
+      alias: isObjectSchema(objectSchema) ? void 0 : inputName,
+      requestize: objectSchema["x-requestbody"] === true,
+      noEmit: true
+    });
+    encode = serialized.encode;
+    const [mediaType, mediaSubType] = partContentType(type).type.split("/");
+    if (mediaSubType === "empty") {
+      contentType = "empty";
+    } else if (mediaSubType === "x-www-form-urlencoded") {
+      contentType = "urlencoded";
+    } else if (mediaSubType === "octet-stream") {
+      contentType = "binary";
+    } else if (mediaType === "application") {
+      contentType = parseJsonContentType(type);
+    } else if (mediaType === "multipart") {
+      contentType = "formdata";
+    } else {
+      contentType = "binary";
+    }
+    if (!isEmpty2({ ...objectSchema.properties, ...objectSchema["x-properties"] })) {
+      haveInput = true;
     }
   }
-  return { inputs, inputName, contentType, encode };
+  if (!inputName) {
+    throw new Error(
+      `No input name found for operation ${operation.operationId} in ${entry.path}`
+    );
+  }
+  return { inputName, contentType, encode, haveInput };
 }
 function toOutput(spec, operation) {
-  const outputName = pascalcase2(`${operation.operationId} output`);
   operation.responses ??= {};
-  const outputs = {};
   for (const status in operation.responses) {
-    const response = isRef3(operation.responses[status]) ? followRef3(spec, operation.responses[status].$ref) : operation.responses[status];
+    if (!isSuccessStatusCode(status))
+      continue;
+    const response = operation.responses[status];
+    const outputName = response["x-response-name"];
+    if ((response.headers ?? {})["Transfer-Encoding"]) {
+      return streamedOutput();
+    }
     for (const type in response.content) {
-      const { schema } = response.content[type];
-      if (!schema) {
-        console.warn(
-          `Schema not found for ${type} in ${operation.operationId}`
-        );
-        continue;
-      }
-      const serializer = new DartSerializer(spec, (name, content) => {
-      });
+      const schema = response.content[type].schema;
       if (isStreamingContentType(type)) {
-        return {
-          type: "stream",
-          outputName,
-          outputs,
-          decode: `return stream`,
-          returnType: `http.StreamedResponse`
-        };
+        return streamedOutput();
+      }
+      if (isSseContentType(type)) {
+        continue;
       }
       if (parseJsonContentType(type)) {
+        if (!schema) {
+          return streamedOutput();
+        }
+        const serializer = new DartSerializer(spec);
         const serialized = serializer.handle(outputName, schema, true, {
           // alias: outputName,
           noEmit: true
         });
         return {
           type: "json",
-          outputName,
-          outputs,
           decode: `final json = await this.receiver.json(stream); return ${serialized.fromJson}`,
           returnType: serialized.use
         };
       }
     }
   }
-  return null;
+  return streamedOutput();
+}
+function streamedOutput() {
+  return {
+    type: "stream",
+    decode: `return stream`,
+    returnType: `http.StreamedResponse`
+  };
+}
+function serializeModels(spec) {
+  const serializer = new DartSerializer(spec);
+  return Object.entries(spec.components.schemas).reduce(
+    (acc, [name, schema]) => {
+      serializer.onEmit((name2, content, schema2) => {
+        const isResponseBody = schema2["x-responsebody"];
+        const isRequestBody = schema2["x-requestbody"];
+        const folder = isRequestBody ? "inputs" : isResponseBody ? "outputs" : "models";
+        acc[join(folder, `${snakecase2(name2)}.dart`)] = [
+          `import 'dart:io';`,
+          `import 'dart:typed_data';`,
+          // `import './index.dart';`,
+          // `import '../interceptors.dart';`,
+          `import '../package.dart';`,
+          // folder === 'inputs' || folder === 'outputs'
+          //   ? `import '../models/index.dart';`
+          //   : `import '../inputs/index.dart';`,
+          content
+        ].join("\n");
+      });
+      if (isRef2(schema)) {
+        serializer.handle(pascalcase2(name), schema, true, {
+          alias: isRef2(schema) ? name : void 0
+        });
+        return acc;
+      }
+      if (schema["x-requestbody"]) {
+        serializer.handle(
+          pascalcase2(name),
+          schema.type !== "object" ? {
+            type: "object",
+            required: ["$body"],
+            properties: {
+              $body: {
+                ...schema,
+                "x-special": true
+              }
+            }
+          } : schema,
+          true,
+          {
+            requestize: true
+          }
+        );
+      } else {
+        serializer.handle(pascalcase2(name), schema, true, {});
+      }
+      return acc;
+    },
+    {}
+  );
 }
 export {
   generate