@sdk-it/dart 0.15.0 → 0.17.0

package/dist/index.js

@@ -1,48 +1,1129 @@
 // packages/dart/src/lib/generate.ts
-import { execSync } from "node:child_process";
+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 { join } from "node:path";
-import "npm-run-path";
-import { camelcase, pascalcase, spinalcase } from "stringcase";
-import { forEachOperation, writeFiles } from "@sdk-it/core";
+import { camelcase as camelcase3 } from "stringcase";
+import yaml from "yaml";
+import {
+  followRef as followRef2,
+  getFolderExportsV2,
+  isEmpty as isEmpty2,
+  isRef as isRef2,
+  notRef as notRef2,
+  pascalcase as pascalcase2,
+  snakecase as snakecase2,
+  writeFiles
+} from "@sdk-it/core";
 
-// packages/dart/src/lib/interceptors.txt
+// 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";
+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] || determineGenericTag(path, operation);
+  }
+};
+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
+          }
+        )
+      );
+    }
+  }
+  return result;
+}
+var reservedKeywords = /* @__PURE__ */ new Set([
+  "abstract",
+  "arguments",
+  "await",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "function",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "int",
+  "interface",
+  "let",
+  "long",
+  "native",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "volatile",
+  "while",
+  "with",
+  "yield",
+  // Potentially problematic identifiers / Common Verbs used as tags
+  "object",
+  "string",
+  "number",
+  "any",
+  "unknown",
+  "never",
+  "get",
+  "list",
+  "create",
+  "update",
+  "delete",
+  "post",
+  "put",
+  "patch",
+  "do",
+  "send",
+  "add",
+  "remove",
+  "set",
+  "find",
+  "search",
+  "check",
+  "make"
+  // Added make, check
+]);
+function sanitizeTag(camelCasedTag) {
+  if (/^\d/.test(camelCasedTag)) {
+    return `_${camelCasedTag}`;
+  }
+  return reservedKeywords.has(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"
+    // Added 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;
+}
+
+// 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 {
+  cleanRef,
+  followRef,
+  isEmpty,
+  isRef,
+  notRef,
+  parseRef,
+  pascalcase
+} 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";
+  }
+  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);
+  }
+  return snakecase(String(it));
+};
+var DartSerializer = class {
+  #spec;
+  #emit;
+  constructor(spec, emit) {
+    this.#spec = spec;
+    this.#emit = emit;
+  }
+  #getRefUsage(schemaName, list = []) {
+    this.#spec.components ??= {};
+    this.#spec.components.schemas ??= {};
+    this.#spec.components.responses ??= {};
+    const checkSchema = (schema) => {
+      if (isRef(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);
+      }
+    }
+    return list;
+  }
+  #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(
+          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
+  }
+}`
+        );
+      }
+      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}'])`
+      };
+    }
+    const props = [];
+    const toJsonProperties = [];
+    const constructorParams = [];
+    const fromJsonParams = [];
+    const matches = [];
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      const propName = key.replace("[]", "");
+      const required = (schema.required ?? []).includes(key);
+      const typeStr = this.handle(className, propSchema, required, {
+        name: propName,
+        required,
+        propName: [className, propName].filter(Boolean).join("_")
+      });
+      const nullable2 = typeStr.nullable || !required;
+      const nullableSuffix = nullable2 ? "?" : "";
+      props.push(
+        `final ${typeStr.use}${nullableSuffix} ${camelcase2(propName)};`
+      );
+      fromJsonParams.push(`${camelcase2(propName)}: ${typeStr.fromJson}`);
+      toJsonProperties.push(`'${propName}': ${typeStr.toJson}`);
+      constructorParams.push(
+        `${required ? "required " : ""}this.${camelcase2(propName)},`
+      );
+      if (required) {
+        matches.push(`(
+  json.containsKey('${camelcase2(propName)}')
+  ? ${nullable2 ? `json['${propName}'] == null` : `json['${propName}'] != null`} && ${typeStr.matches}
+  : false)`);
+      } else {
+        matches.push(`(
+  json.containsKey('${camelcase2(propName)}')
+  ? ${nullable2 ? `json['${propName}'] == null` : `json['${propName}'] != null`} || ${typeStr.matches}
+  : true)`);
+      }
+    }
+    const { mixins, withMixins } = this.#mixinise(className, context);
+    const content = `class ${className} ${withMixins} {
+      ${props.join("\n")}
+      ${!mixins.length ? "const" : ""} ${className}({
+      ${constructorParams.join("\n")}})${mixins.length > 1 ? "" : `:super()`};
+       factory ${className}.fromJson(Map<String, dynamic> json) {
+return ${className}(
+${fromJsonParams.join(",\n")});
+      }
+      Map<String, dynamic> toJson() => {
+${toJsonProperties.join(",\n")}
+      };
+      static bool matches(Map<String, dynamic> json) {
+return ${matches.join(" && ")};
+      }
+    }`;
+    if (context.noEmit !== true) {
+      this.#emit(className, content);
+    }
+    const nullable = !context.required || context.nullable === true;
+    return {
+      use: className,
+      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}'])`
+    };
+  }
+  #safe(accces, required) {
+    return required ? `this.${camelcase2(accces)}.toJson()` : `this.${camelcase2(accces)} != null ? this.${camelcase2(accces)}!.toJson() : null`;
+  }
+  #array(className, schema, required = false, context) {
+    let serialized;
+    if (!schema.items) {
+      serialized = {
+        content: "",
+        use: "List<dynamic>",
+        toJson: "",
+        fromJson: `List<dynamic>.from(${context.name ? `json['${context.name}']` : `json`})})`,
+        matches: ""
+      };
+    } else {
+      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)`})
+                .toList()
+            : null` : `json != null
+            ? (json as List<${itemsType.simple ? itemsType.use : "dynamic"}>)
+                .map((it) => ${itemsType.simple ? "it" : `${itemsType.use}.fromJson(it)`})
+                .toList()
+            : null`;
+      serialized = {
+        encode: `input.map((it) => ${itemsType.simple ? "it" : `it.toJson()`}).toList()`,
+        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})`
+      };
+    }
+    return serialized;
+  }
+  /**
+   * Convert a basic type to Dart
+   */
+  #primitive(className, type, schema, context, required = false) {
+    switch (type) {
+      case "string":
+        return this.#string(schema, context);
+      case "number":
+      case "integer":
+        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`
+        };
+      case "object":
+        return this.#object(className, schema, context);
+      case "array":
+        return this.#array(className, schema, required, context);
+      case "null":
+        return {
+          content: "",
+          use: "Null",
+          toJson: `${camelcase2(context.name)}`,
+          fromJson: `json['${context.name}']`
+        };
+      default:
+        return {
+          content: "",
+          use: "dynamic",
+          toJson: `${camelcase2(context.name)}`,
+          fromJson: `json['${context.name}']`
+        };
+    }
+  }
+  #ref(className, $ref, required, context) {
+    const schemaName = cleanRef($ref).split("/").pop();
+    const serialized = this.handle(
+      schemaName,
+      followRef(this.#spec, $ref),
+      required,
+      {
+        ...context,
+        propName: schemaName,
+        noEmit: !!context.alias || !!className || !context.forceEmit
+      }
+    );
+    return serialized;
+  }
+  // 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(isRef);
+    const nonRefs = schemas.filter(notRef);
+    if (nonRefs.some((it) => it.type && it.type !== "object")) {
+      assert(false, `allOf ${name} must be an object`);
+    }
+    const objectSchema = merge(
+      {},
+      ...nonRefs,
+      ...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: "",
+        use: "dynamic",
+        toJson: `${camelcase2(context.name)}`,
+        fromJson: `json['${context.name}']`
+      };
+    }
+    const nullSchemaIndex = schemas.findIndex((schema) => {
+      if (isRef(schema)) {
+        const refSchema = followRef(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);
+    if (context.mixin) {
+      mixins.unshift(context.mixin);
+    }
+    const withMixins = mixins.length > 1 ? ` with ${mixins.join(", ")}` : mixins.length === 1 ? `extends ${mixins[0]}` : "";
+    return {
+      withMixins,
+      mixins
+    };
+  }
+  #oneOf(className, schemas, context) {
+    const name = pascalcase(context.propName || className);
+    if (schemas.length === 0) {
+      return {
+        content: "",
+        use: "dynamic",
+        toJson: `${camelcase2(context.name)}`,
+        fromJson: `json['${context.name}']`
+      };
+    }
+    const content = [];
+    const patterns = [];
+    const objects = schemas.filter(notRef).filter((it) => it.type === "object");
+    for (const schema of schemas) {
+      if (isRef(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) {
+          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;
+          break;
+        }
+      }
+      if (discriminatorProp) {
+        for (const schema of objects) {
+          const discriminatorValue = schema.properties[discriminatorProp].enum?.[0];
+          const varientName = `${name}${pascalcase(discriminatorValue)}`;
+          patterns.push({
+            pattern: `case Map<String, dynamic> map when ${varientName}.matches(json): return ${varientName}.fromJson(map);`,
+            name: varientName
+          });
+          const objResult = this.#object(varientName, schema, {
+            ...context,
+            noEmit: true,
+            mixin: name
+          });
+          content.push(objResult.content);
+        }
+      }
+    }
+    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"));
+    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}'])`
+    };
+  }
+  #simple(type) {
+    switch (type) {
+      case "string":
+        return "String";
+      case "number":
+        return "double";
+      case "integer":
+        return "int";
+      case "boolean":
+        return "bool";
+      default:
+        return "dynamic";
+    }
+  }
+  #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 content = `
+  class _EnumValue implements ${pascalcase(name)} {
+  final ${valType} value;
+  const _EnumValue(this.value);
+  @override
+  toJson() {return this.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")}
+      dynamic toJson();
+
+      ${valType} get value;
+
+      static _EnumValue fromJson(${valType} value) {
+      switch (value) {
+${values.map(
+      (it) => `case ${typeof it === "number" ? it : `'${it}'`}: return ${formatName(it)};`
+    ).join("\n")}
+default:
+  throw ArgumentError.value(value, "value", "No enum value with that name");
+      }
+    }
+
+    static bool matches(${valType} value) {
+      try {
+fromJson(value);
+return true;
+      } catch (error) {
+return false;
+      }
+  }
+
+    }`;
+    if (context.noEmit !== true) {
+      this.#emit(name, content);
+    }
+    return {
+      type: Array.isArray(schema.type) ? this.#simple(schema.type[0]) : schema.type ? this.#simple(schema.type) : void 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}'])`
+    };
+  }
+  /**
+   * Handle string type with formats
+   */
+  #string(schema, context) {
+    switch (schema.format) {
+      case "date-time":
+      case "datetime":
+      case "date":
+        return {
+          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`
+        };
+      case "binary":
+      case "byte":
+        return {
+          content: "",
+          use: "File",
+          toJson: `this.${camelcase2(context.name)}`,
+          simple: true,
+          fromJson: context.name ? `json['${context.name}']` : "json",
+          matches: `json['${context.name}'] is Uint8List`
+        };
+      default:
+        return {
+          encode: "input",
+          use: `String`,
+          content: "",
+          simple: true,
+          toJson: `this.${camelcase2(context.name)}`,
+          fromJson: context.name ? `json['${context.name}'] as String` : "json",
+          matches: `json['${context.name}'] is String`
+        };
+    }
+  }
+  /**
+   * Handle number/integer types with formats
+   */
+  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`
+      };
+    }
+    if (["float", "double"].includes(schema.format)) {
+      return {
+        content: "",
+        use: "double",
+        simple: true,
+        toJson: `this.${camelcase2(context.name)}`,
+        fromJson: `json['${context.name}']`,
+        matches: `json['${context.name}'] is double`
+      };
+    }
+    return {
+      content: "",
+      use: "num",
+      simple: true,
+      toJson: `this.${camelcase2(context.name)}`,
+      fromJson: `json['${context.name}']`,
+      matches: `json['${context.name}'] is double`
+    };
+  }
+  #serialize(className, schema, required = true, context = {}) {
+    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.anyOf && Array.isArray(schema.anyOf)) {
+      return this.#anyOf(className, schema.anyOf, context);
+    }
+    if (schema.oneOf && Array.isArray(schema.oneOf)) {
+      return this.#oneOf(className, schema.oneOf, 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] : [];
+    let nullable = false;
+    if ("nullable" in schema && schema.nullable) {
+      nullable = true;
+    } else if (schema.default === null) {
+      nullable = true;
+    } else if (types.includes("null")) {
+      nullable = true;
+    }
+    if (!types.length) {
+      if ("properties" in schema) {
+        return this.#object(className, schema, context);
+      }
+      if ("items" in schema) {
+        return this.#array(className, schema, true, context);
+      }
+      return {
+        content: "",
+        use: "dynamic",
+        toJson: `${camelcase2(context.name)}`,
+        fromJson: `json['${context.name}']`
+      };
+    }
+    return this.#primitive(
+      className,
+      types[0],
+      schema,
+      { ...context, nullable },
+      required
+    );
+  }
+  handle(className, schema, required = true, context = {}) {
+    const alias = context.alias;
+    context.alias = void 0;
+    const serialized = this.#serialize(className, schema, required, {
+      ...context,
+      forJson: alias
+    });
+    if (alias) {
+      this.#emit(className, `typedef ${alias} = ${serialized.use};`);
+      return serialized;
+    }
+    return serialized;
+  }
+};
+function isObjectSchema(schema) {
+  return !isRef(schema) && (schema.type === "object" || !!schema.properties);
+}
+
+// packages/dart/src/lib/http/dispatcher.txt
+var dispatcher_default = "import 'package:mime/mime.dart' as mime;\nimport 'dart:convert';\nimport 'dart:io';\n\nimport './interceptors.dart';\nimport 'package:http/http.dart' as http;\nimport 'package:http_parser/http_parser.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    if ((body is Map || body is List)) {\n      request.headers['Content-Type'] = 'application/json';\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";
+
+// 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";
 
 // packages/dart/src/lib/generate.ts
+function tuneSpec(spec, schemas, refs) {
+  for (const [name, schema] of Object.entries(schemas)) {
+    if (isRef2(schema))
+      continue;
+    if (schema.allOf && Array.isArray(schema.allOf) && schema.allOf.length) {
+      const schemas2 = schema.allOf;
+      const refs2 = schemas2.filter(isRef2);
+      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) => followRef2(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 (isRef2(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 (isRef2(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 (isRef2(schema.items))
+        continue;
+      const refName = name;
+      refs.push({ name: refName, value: schema.items ?? {} });
+      schema.items = {
+        $ref: `#/components/schemas/${refName}`
+      };
+    }
+  }
+}
 async function generate(spec, settings) {
-  const output = settings.mode === "full" ? join(settings.output, "src") : settings.output;
+  const clientName = settings.name || "Client";
+  const output = join(settings.output, "lib");
   const groups = {};
+  spec.components ??= {};
+  spec.components.schemas ??= {};
+  const inputs = {};
+  const outputs = {};
   forEachOperation({ spec }, (entry, operation) => {
-    const [groupName] = operation.tags ?? [];
-    const group = groups[groupName] ?? (groups[groupName] = {
+    operation.responses ??= {};
+    for (const status in operation.responses) {
+      if (!isSuccessStatusCode(status))
+        continue;
+      const response2 = isRef2(operation.responses[status]) ? followRef2(spec, operation.responses[status].$ref) : operation.responses[status];
+      if (response2.content && Object.keys(response2.content).length) {
+        for (const [contentType, mediaType] of Object.entries(
+          response2.content
+        )) {
+          if (parseJsonContentType(contentType)) {
+            if (mediaType.schema && !isRef2(mediaType.schema)) {
+              spec.components ??= {};
+              spec.components.schemas ??= {};
+              const outputName = pascalcase2(`${operation.operationId} output`);
+              spec.components.schemas[outputName] = mediaType.schema;
+              operation.responses[status].content[contentType].schema = {
+                $ref: `#/components/schemas/${outputName}`
+              };
+            }
+          }
+        }
+      }
+    }
+    console.log(`Processing ${entry.method} ${entry.path}`);
+    const group = groups[entry.groupName] ?? (groups[entry.groupName] = {
       methods: [],
-      use: `final ${groupName} = new ${pascalcase(groupName)}();`
+      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<http.Response> ${camelcase(operation.operationId)}() async {
-          final stream = await this.dispatcher.dispatch(RequestConfig(
+        Future<${response ? response.returnType : "http.StreamedResponse"}> ${camelcase3(operation.operationId)}(
+       ${isEmpty2(operation.requestBody) ? "" : `${input.inputName} input`}
+        ) async {
+          final stream = await this.dispatcher.${input.contentType}(RequestConfig(
             method: '${entry.method}',
             url: Uri.parse('${entry.path}'),
             headers: {},
-          ));
-          final response = await http.Response.fromStream(stream);
-          return response;
+          ), ${["json", "multipart"].includes(input.contentType) ? input.encode : ``});
+          ${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 clazzez = Object.entries(groups).reduce(
     (acc, [name, { methods }]) => {
       return {
         ...acc,
-        [`api/${spinalcase(name)}.dart`]: `
-        import 'dart:convert';
+        [`api/${snakecase2(name)}.dart`]: `
+import 'dart:convert';
+
 import 'package:http/http.dart' as http;
+
 import '../interceptors.dart';
+import '../inputs/index.dart';
+import '../outputs/index.dart';
+import '../models/index.dart';
 import '../http.dart';
 
-    class ${pascalcase(name)} {
+    class ${pascalcase2(name)}Client {
       final Dispatcher dispatcher;
-      ${pascalcase(name)}(this.dispatcher);
+      ${pascalcase2(name)}Client(this.dispatcher);
       ${methods.join("\n")}
     }
     `
@@ -50,21 +1131,20 @@ import '../http.dart';
     },
     {}
   );
-  console.dir({ groups }, { depth: null });
   const client = `
+  ${Object.keys(groups).map((name) => `import './api/${snakecase2(name)}.dart';`).join("\n")}
 import './interceptors.dart';
 import './http.dart';
-${Object.keys(groups).map((name) => `import './api/${spinalcase(name)}.dart';`).join("\n")}
 
-  class Client {
+  class ${clientName} {
   final Options options;
-${Object.keys(groups).map((name) => `late final ${pascalcase(name)} ${camelcase(name)};`).join("\n")}
+${Object.keys(groups).map((name) => `late final ${pascalcase2(name)}Client ${camelcase3(name)};`).join("\n")}
 
-  Client(this.options) {
+  ${clientName}(this.options) {
     final interceptors = [new BaseUrlInterceptor(() => this.options.baseUrl)];
-
+    final dispatcher = new Dispatcher(interceptors);
     ${Object.keys(groups).map(
-    (name) => `this.${camelcase(name)} = new ${pascalcase(name)}(new Dispatcher(interceptors));`
+    (name) => `this.${camelcase3(name)} = new ${pascalcase2(name)}Client(dispatcher);`
   ).join("\n")}
 
       }
@@ -84,31 +1164,136 @@ class Options {
 
   `;
   await writeFiles(output, {
-    "index.dart": client,
+    ...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"
+    }),
     "interceptors.dart": interceptors_default,
-    "http.dart": `
-   import 'interceptors.dart';
-import 'package:http/http.dart' as http;
-
-class Dispatcher {
-  final List<Interceptor> interceptors;
-
-  Dispatcher(this.interceptors);
+    "http.dart": dispatcher_default,
+    ...clazzez
+  });
+  await writeFiles(output, {
+    "package.dart": `${await getFolderExportsV2(join(output), {
+      exportSyntax: "export",
+      extensions: "dart",
+      ignore(dirent) {
+        return dirent.isFile() && dirent.name === "package.dart";
+      }
+    })}${client}`
+  });
+  await writeFiles(settings.output, {
+    "pubspec.yaml": {
+      ignoreIfExists: true,
+      content: yaml.stringify({
+        name: settings.name ? `${snakecase2(clientName.toLowerCase())}_sdk` : "sdk",
+        version: "0.0.1",
+        environment: {
+          sdk: "^3.7.2"
+        },
+        dependencies: {
+          http: "^1.3.0",
+          mime: "^2.0.0"
+        }
+      })
+    }
+  });
+  await settings.formatCode?.({
+    output
+  });
+}
+function toInputs(spec, { entry, operation }) {
+  const inputs = {};
+  const inputName = pascalcase2(`${operation.operationId} input`);
+  let contentType = "empty";
+  let encode = "";
+  if (!isEmpty2(operation.requestBody)) {
+    const requestBody = isRef2(operation.requestBody) ? followRef2(spec, operation.requestBody.$ref) : operation.requestBody;
+    for (const type in requestBody.content) {
+      const ctSchema = isRef2(requestBody.content[type].schema) ? followRef2(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';
 
-  Future<http.StreamedResponse> dispatch(RequestConfig config) {
-    final modifedConfig = interceptors.fold(
-      config,
-      (acc, interceptor) => interceptor.before(acc),
-    );
-    final request = http.Request(modifedConfig.method, modifedConfig.url);
-    return request.send();
+${content}`;
+      });
+      const serialized = serializer.handle(inputName, ctSchema, true, {
+        alias: isObjectSchema(ctSchema) ? void 0 : inputName
+      });
+      encode = serialized.encode;
+      if (contentType) {
+        console.warn(
+          `${entry.method} ${entry.path} have more than one content type`
+        );
+      }
+      const [mediaType, mediaSubType] = partContentType(type).type.split("/");
+      if (mediaType === "application") {
+        contentType = parseJsonContentType(type);
+      } else {
+        contentType = mediaType;
+      }
+    }
   }
+  return { inputs, inputName, contentType, encode };
 }
-`,
-    ...clazzez
-    // 'index.dart': await getFolderExports(output, settings.useTsExtension),
-  });
-  execSync("dart format .", { cwd: output });
+function toOutput(spec, operation) {
+  const outputName = pascalcase2(`${operation.operationId} output`);
+  operation.responses ??= {};
+  const outputs = {};
+  for (const status in operation.responses) {
+    const response = isRef2(operation.responses[status]) ? followRef2(spec, operation.responses[status].$ref) : operation.responses[status];
+    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) => {
+      });
+      if (isStreamingContentType(type)) {
+        return {
+          type: "stream",
+          outputName,
+          outputs,
+          decode: `return stream`,
+          returnType: `http.StreamedResponse`
+        };
+      }
+      if (parseJsonContentType(type)) {
+        const serialized = serializer.handle(outputName, schema, true, {
+          // alias: outputName,
+          noEmit: true
+        });
+        return {
+          type: "json",
+          outputName,
+          outputs,
+          decode: `final response = await http.Response.fromStream(stream);final dynamic json = jsonDecode(response.body); return ${serialized.fromJson}`,
+          returnType: serialized.use
+        };
+      }
+    }
+  }
+  return null;
 }
 export {
   generate