@sdk-it/dart 0.16.0 → 0.18.0

package/dist/index.js

@@ -1,12 +1,13 @@
 // 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 { join } from "node:path";
-import { camelcase as camelcase2 } from "stringcase";
+import { camelcase as camelcase3 } from "stringcase";
+import yaml from "yaml";
 import {
   followRef as followRef2,
-  forEachOperation,
   getFolderExportsV2,
   isEmpty as isEmpty2,
   isRef as isRef2,
@@ -16,10 +17,302 @@ import {
   writeFiles
 } from "@sdk-it/core";
 
+// 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, snakecase } from "stringcase";
+import { camelcase as camelcase2, snakecase } from "stringcase";
 import {
   cleanRef,
   followRef,
@@ -30,8 +323,11 @@ import {
   pascalcase
 } from "@sdk-it/core";
 var formatName = (it) => {
-  const startsWithDigitPattern = /^\d/;
+  const startsWithDigitPattern = /^-?\d/;
   if (typeof it === "number") {
+    if (Math.sign(it) === -1) {
+      return `$_${Math.abs(it)}`;
+    }
     return `$${it}`;
   }
   if (it === "default") {
@@ -39,7 +335,12 @@ var formatName = (it) => {
   }
   if (typeof it === "string") {
     if (startsWithDigitPattern.test(it)) {
-      return `$${it}`;
+      if (typeof it === "number") {
+        if (Math.sign(it) === -1) {
+          return `$_${Math.abs(it)}`;
+        }
+        return `$${it}`;
+      }
     }
     let nameToFormat = it;
     if (nameToFormat.startsWith("[")) {
@@ -87,12 +388,14 @@ var DartSerializer = class {
   }
   #object(className, schema, context) {
     if (schema.additionalProperties) {
+      this.#emit(className, `typedef ${className} = Map<String, dynamic>;`);
       return {
         content: "",
         use: "Map<String, dynamic>",
-        toJson: `this.${camelcase(context.name)}`,
-        fromJson: `json['${camelcase(context.name)}']`,
-        matches: `json['${camelcase(context.name)}'] is 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)) {
@@ -118,6 +421,7 @@ var DartSerializer = class {
       }
       return {
         content: "",
+        encode: "input.toJson()",
         use: className,
         toJson: `${this.#safe(context.name, context.required)}`,
         fromJson: `${className}.fromJson(json['${context.name}'])`,
@@ -137,24 +441,24 @@ var DartSerializer = class {
         required,
         propName: [className, propName].filter(Boolean).join("_")
       });
-      const nullable2 = !required;
+      const nullable2 = typeStr.nullable || !required;
       const nullableSuffix = nullable2 ? "?" : "";
       props.push(
-        `final ${typeStr.use}${nullableSuffix} ${camelcase(propName)};`
+        `final ${typeStr.use}${nullableSuffix} ${camelcase2(propName)};`
       );
-      fromJsonParams.push(`${camelcase(propName)}: ${typeStr.fromJson}`);
+      fromJsonParams.push(`${camelcase2(propName)}: ${typeStr.fromJson}`);
       toJsonProperties.push(`'${propName}': ${typeStr.toJson}`);
       constructorParams.push(
-        `${required ? "required " : ""}this.${camelcase(propName)},`
+        `${required ? "required " : ""}this.${camelcase2(propName)},`
       );
       if (required) {
         matches.push(`(
-  json.containsKey('${camelcase(propName)}')
+  json.containsKey('${camelcase2(propName)}')
   ? ${nullable2 ? `json['${propName}'] == null` : `json['${propName}'] != null`} && ${typeStr.matches}
   : false)`);
       } else {
         matches.push(`(
-  json.containsKey('${camelcase(propName)}')
+  json.containsKey('${camelcase2(propName)}')
   ? ${nullable2 ? `json['${propName}'] == null` : `json['${propName}'] != null`} || ${typeStr.matches}
   : true)`);
       }
@@ -182,38 +486,55 @@ return ${matches.join(" && ")};
     return {
       use: className,
       content,
+      encode: "input.toJson()",
       toJson: `${this.#safe(context.name, context.required)}`,
-      fromJson: `${className}.fromJson(json['${context.name}'])`,
+      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.${camelcase(accces)}.toJson()` : `this.${camelcase(accces)} != null ? this.${camelcase(accces)}!.toJson() : null`;
+    return required ? `this.${camelcase2(accces)}.toJson()` : `this.${camelcase2(accces)} != null ? this.${camelcase2(accces)}!.toJson() : null`;
   }
   #array(className, schema, required = false, context) {
-    const { items } = schema;
-    if (!items) {
-      return {
+    let serialized;
+    if (!schema.items) {
+      serialized = {
         content: "",
         use: "List<dynamic>",
         toJson: "",
-        fromJson: "",
+        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})`
+      };
     }
-    const itemsType = this.handle(className, items, true, context);
-    return {
-      content: "",
-      use: `List<${itemsType.use}>`,
-      fromJson: required ? `(json['${context.name}'] as List<${itemsType.simple ? itemsType.use : "dynamic"}>).map((it) => ${itemsType.simple ? "it" : `${itemsType.use}.fromJson(it)`}).toList()` : `json['${context.name}'] != null ? (json['${context.name}'] as List).map((it) => ${itemsType.fromJson}).toList() : null`,
-      toJson: `${context.required ? `this.${camelcase(context.name)}${itemsType.simple ? "" : ".map((it) => it.toJson()).toList()"}` : `this.${camelcase(context.name)}!= null? this.${camelcase(context.name)}${itemsType.simple ? "" : "!.map((it) => it.toJson()).toList()"} : null`}`,
-      matches: `json['${camelcase(context.name)}'].every((it) => ${itemsType.matches})`
-    };
+    return serialized;
   }
   /**
    * Convert a basic type to Dart
    */
-  primitive(className, type, schema, context, required = false) {
+  #primitive(className, type, schema, context, required = false) {
     switch (type) {
       case "string":
         return this.#string(schema, context);
@@ -224,7 +545,7 @@ return ${matches.join(" && ")};
         return {
           content: "",
           use: "bool",
-          toJson: `${camelcase(context.name)}`,
+          toJson: `${camelcase2(context.name)}`,
           fromJson: `json['${context.name}']`,
           matches: `json['${context.name}'] is bool`
         };
@@ -236,31 +557,31 @@ return ${matches.join(" && ")};
         return {
           content: "",
           use: "Null",
-          toJson: `${camelcase(context.name)}`,
+          toJson: `${camelcase2(context.name)}`,
           fromJson: `json['${context.name}']`
         };
       default:
         return {
           content: "",
           use: "dynamic",
-          toJson: `${camelcase(context.name)}`,
+          toJson: `${camelcase2(context.name)}`,
           fromJson: `json['${context.name}']`
         };
     }
   }
-  #ref($ref, required, context) {
+  #ref(className, $ref, required, context) {
     const schemaName = cleanRef($ref).split("/").pop();
-    const result = this.handle(
-      context.alias || schemaName,
+    const serialized = this.handle(
+      schemaName,
       followRef(this.#spec, $ref),
       required,
       {
         ...context,
         propName: schemaName,
-        noEmit: !context.forceEmit
+        noEmit: !!context.alias || !!className || !context.forceEmit
       }
     );
-    return result;
+    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) {
@@ -278,16 +599,30 @@ return ${matches.join(" && ")};
     delete objectSchema.allOf;
     return this.handle(name, objectSchema, true, context);
   }
-  anyOf(className, schemas, context) {
+  #anyOf(className, schemas, context) {
     if (schemas.length === 0) {
       return {
         content: "",
         use: "dynamic",
-        toJson: `${camelcase(context.name)}`,
+        toJson: `${camelcase2(context.name)}`,
         fromJson: `json['${context.name}']`
       };
     }
-    return this.handle(className, schemas[0], true, context);
+    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);
@@ -306,7 +641,7 @@ return ${matches.join(" && ")};
       return {
         content: "",
         use: "dynamic",
-        toJson: `${camelcase(context.name)}`,
+        toJson: `${camelcase2(context.name)}`,
         fromJson: `json['${context.name}']`
       };
     }
@@ -315,7 +650,7 @@ return ${matches.join(" && ")};
     const objects = schemas.filter(notRef).filter((it) => it.type === "object");
     for (const schema of schemas) {
       if (isRef(schema)) {
-        const refType = this.#ref(schema.$ref, true, context);
+        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
@@ -457,7 +792,9 @@ return ${matches.join(" && ")};
       ${values.map((it) => `static const _EnumValue ${formatName(it)} = _EnumValue(${typeof it === "number" ? it : `'${it}'`});`).join("\n")}
       dynamic toJson();
 
-    static _EnumValue fromJson(${valType} value) {
+      ${valType} get value;
+
+      static _EnumValue fromJson(${valType} value) {
       switch (value) {
 ${values.map(
       (it) => `case ${typeof it === "number" ? it : `'${it}'`}: return ${formatName(it)};`
@@ -484,7 +821,7 @@ return false;
       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.${camelcase(context.name)}.toJson()` : `this.${camelcase(context.name)} != null ? this.${camelcase(context.name)}!.toJson() : null`}`,
+      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}'])`
     };
@@ -501,27 +838,30 @@ return false;
           content: "",
           use: "DateTime",
           simple: true,
-          toJson: `this.${camelcase(context.name)}.toIso8601String()`,
-          fromJson: `DateTime.parse(json['${context.name}'])`,
+          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: "Uint8List",
-          toJson: `this.${camelcase(context.name)}`,
+          use: "File",
+          toJson: `this.${camelcase2(context.name)}`,
           simple: true,
-          fromJson: `json['${context.name}']`,
+          fromJson: context.name ? `json['${context.name}']` : "json",
           matches: `json['${context.name}'] is Uint8List`
         };
       default:
         return {
-          use: "String",
+          encode: "input",
+          use: `String`,
           content: "",
           simple: true,
-          toJson: `this.${camelcase(context.name)}`,
-          fromJson: `json['${context.name}'] as String`,
+          toJson: `this.${camelcase2(context.name)}`,
+          fromJson: context.name ? `json['${context.name}'] as String` : "json",
           matches: `json['${context.name}'] is String`
         };
     }
@@ -530,35 +870,44 @@ return false;
    * Handle number/integer types with formats
    */
   number(schema, context) {
-    const type = schema.type === "integer" ? "int" : "double";
-    if (schema.format === "int64") {
+    if (schema.type === "integer") {
       return {
         content: "",
         use: "int",
         simple: true,
-        toJson: `this.${camelcase(context.name)}`,
+        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,
-      use: type,
-      toJson: `this.${camelcase(context.name)}`,
+      toJson: `this.${camelcase2(context.name)}`,
       fromJson: `json['${context.name}']`,
-      matches: `json['${context.name}'] is int`
+      matches: `json['${context.name}'] is double`
     };
   }
-  handle(className, schema, required = true, context = {}) {
+  #serialize(className, schema, required = true, context = {}) {
     if (isRef(schema)) {
-      return this.#ref(schema.$ref, required, context);
+      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);
+      return this.#anyOf(className, schema.anyOf, context);
     }
     if (schema.oneOf && Array.isArray(schema.oneOf)) {
       return this.#oneOf(className, schema.oneOf, context);
@@ -585,11 +934,11 @@ return false;
       return {
         content: "",
         use: "dynamic",
-        toJson: `${camelcase(context.name)}`,
+        toJson: `${camelcase2(context.name)}`,
         fromJson: `json['${context.name}']`
       };
     }
-    return this.primitive(
+    return this.#primitive(
       className,
       types[0],
       schema,
@@ -597,9 +946,28 @@ return false;
       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/interceptors.txt
+// 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
@@ -665,25 +1033,58 @@ function tuneSpec(spec, schemas, refs) {
   }
 }
 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) => {
+    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 ${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> ${camelcase2(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;"}
       }
     `);
   });
@@ -698,7 +1099,7 @@ async function generate(spec, settings) {
   );
   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:typed_data'; import './index.dart';
+      acc[`models/${snakecase2(name2)}.dart`] = `import 'dart:io';import 'dart:typed_data'; import './index.dart';
 
 ${content}`;
     });
@@ -710,13 +1111,19 @@ ${content}`;
       return {
         ...acc,
         [`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 ${pascalcase2(name)} {
+    class ${pascalcase2(name)}Client {
       final Dispatcher dispatcher;
-      ${pascalcase2(name)}(this.dispatcher);
+      ${pascalcase2(name)}Client(this.dispatcher);
       ${methods.join("\n")}
     }
     `
@@ -729,15 +1136,15 @@ import '../http.dart';
 import './interceptors.dart';
 import './http.dart';
 
-  class Client {
+  class ${clientName} {
   final Options options;
-${Object.keys(groups).map((name) => `late final ${pascalcase2(name)} ${camelcase2(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.${camelcase2(name)} = new ${pascalcase2(name)}(dispatcher);`
+    (name) => `this.${camelcase3(name)} = new ${pascalcase2(name)}Client(dispatcher);`
   ).join("\n")}
 
       }
@@ -757,41 +1164,137 @@ class Options {
 
   `;
   await writeFiles(output, {
-    ...models
+    ...models,
+    ...inputs,
+    ...outputs
   });
   await writeFiles(output, {
     "models/index.dart": await getFolderExportsV2(join(output, "models"), {
       exportSyntax: "export",
-      extensions: ["dart"]
+      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"
     }),
-    "index.dart": client,
     "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);
-
-  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();
-  }
-}
-`,
+    "http.dart": dispatcher_default,
     ...clazzez
-    // 'index.dart': await getFolderExports(output, settings.useTsExtension),
+  });
+  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';
+
+${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 };
+}
+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
 };