arri 0.0.5 → 0.0.6

package/dist/codegen.cjs

@@ -0,0 +1,844 @@
+'use strict';
+
+const index = require('./shared/arri.d77f4d0e.cjs');
+const index$1 = require('./shared/arri.38ad6cd0.cjs');
+const fs = require('fs');
+const require$$1 = require('child_process');
+require('module');
+require('url');
+require('path');
+require('process');
+require('os');
+require('tty');
+require('assert');
+require('fs/promises');
+require('v8');
+require('util');
+
+function defineClientGeneratorPlugin(plugin) {
+  return plugin;
+}
+
+let createdModels = [];
+const typescriptClientGenerator = defineClientGeneratorPlugin(
+  (options) => ({
+    generator: async (def) => {
+      if (!options.clientName) {
+        throw new Error("Name is requires");
+      }
+      if (!options.outputFile) {
+        throw new Error("No output file specified");
+      }
+      const result = await createTypescriptClient(
+        def,
+        options.clientName
+      );
+      fs.writeFileSync(options.outputFile, result);
+    },
+    options
+  })
+);
+async function createTypescriptClient(def, prefix = "Client") {
+  createdModels = [];
+  const services = index.unflattenObject(def.procedures);
+  const serviceParts = [];
+  const modelParts = [];
+  Object.keys(services).forEach((key) => {
+    const serviceName = index.pascalCase(`${prefix}_${key}_service`);
+    serviceParts.push({
+      name: serviceName,
+      key,
+      content: tsServiceFromServiceDefinition(serviceName, services[key])
+    });
+  });
+  Object.keys(def.models).forEach((key) => {
+    const modelName = index.pascalCase(`${key}`);
+    if (!createdModels.includes(modelName)) {
+      modelParts.push(tsModelFromDefinition(modelName, def.models[key]));
+      createdModels.push(modelName);
+    }
+  });
+  return index$1.format2(
+    `/* eslint-disable */
+    import { arriRequest, ArriRequestError } from 'arri-client';
+    
+    export class ${prefix} {
+        ${serviceParts.map((service) => `${service.key}: ${service.name}`).join("\n")}
+        constructor(opts: { baseUrl?: string; headers?: Record<string, string> }) {
+            ${serviceParts.map(
+      (service) => `this.${service.key} = new ${service.name}(opts);`
+    ).join("\n")}
+        }
+    }
+
+    ${serviceParts.map((service) => service.content).join("\n")}
+    ${modelParts.join("\n")}`,
+    {
+      parser: "typescript"
+    }
+  );
+}
+function tsServiceFromServiceDefinition(name, def) {
+  const rpcParts = [];
+  const subServiceParts = [];
+  Object.keys(def).forEach((key) => {
+    const val = def[key];
+    if (index.isProcedureDefinition(val)) {
+      rpcParts.push(tsRpcFromProcedureDefinition(key, val));
+      return;
+    }
+    const subServiceName = index.pascalCase(
+      `${name.split("Service").join("")}_${key}_service`
+    );
+    subServiceParts.push({
+      name: subServiceName,
+      key,
+      content: tsServiceFromServiceDefinition(subServiceName, val)
+    });
+  });
+  return `export class ${name} {
+        private baseUrl: string;
+        private headers: Record<string, string>;
+        ${subServiceParts.map((service) => `${service.key}: ${service.name};`).join("\n")}
+        constructor(opts: { baseUrl?: string; headers?: Record<string, string> }) {
+            this.baseUrl = opts.baseUrl ?? "";
+            this.headers = opts.headers ?? {};
+            ${subServiceParts.map(
+    (service) => `this.${service.key} = new ${service.name}(opts);`
+  ).join("\n")}
+        }
+        ${rpcParts.join("\n")}
+    }
+    ${subServiceParts.map((service) => service.content).join("\n")}`;
+}
+function tsRpcFromProcedureDefinition(name, def) {
+  let paramStr = "";
+  let responseName = "";
+  if (def.params) {
+    paramStr = `params: ${def.params}`;
+  }
+  if (def.response) {
+    responseName = def.response;
+  }
+  return `async ${name}(${paramStr}) {
+        return arriRequest<${responseName || "undefined"}>({
+            url: \`\${this.baseUrl}${def.path}\`,
+            method: '${def.method}',
+            ${paramStr.length ? `params,` : ""}
+            headers: this.headers,
+        });
+    }`;
+}
+function tsModelFromDefinition(name, def) {
+  const fieldParts = [];
+  const subModelParts = [];
+  Object.keys(def.properties ?? {}).forEach((key) => {
+    const isOptional = !def.required?.includes(key);
+    const prop = def.properties?.[key];
+    const keyPart = isOptional ? `${key}?` : key;
+    if (index.isJsonSchemaScalarType(prop)) {
+      fieldParts.push(
+        tsInterfaceScalarField(key, prop, isOptional) ?? ""
+      );
+      return;
+    }
+    if (index.isJsonSchemaNullType(prop)) {
+      switch (prop.type) {
+        case "null":
+          fieldParts.push(`${keyPart}: null;`);
+          break;
+        case "undefined":
+          fieldParts.push(`${keyPart}: undefined`);
+          break;
+      }
+      return;
+    }
+    if (index.isJsonSchemaObject(prop)) {
+      const subModelName = prop.$id ?? index.pascalCase(`${name}_${key}`);
+      if (!createdModels.includes(subModelName)) {
+        const content = tsModelFromDefinition(
+          subModelName,
+          prop
+        );
+        subModelParts.push(content);
+      }
+      fieldParts.push(`${keyPart}: ${subModelName};`);
+      return;
+    }
+    if (index.isJsonSchemaEnum(prop)) {
+      const vals = prop.anyOf.map(
+        (opt) => opt.type === "string" ? `'${opt.const}'` : `${opt.const}`
+      );
+      fieldParts.push(`${keyPart}: ${vals.join(" | ")};`);
+      return;
+    }
+    if (index.isJsonSchemaArray(prop)) {
+      if (index.isJsonSchemaScalarType(prop.items)) {
+        const part = tsInterfaceScalarField(
+          key,
+          prop.items,
+          isOptional
+        ).replace(";", "[];");
+        fieldParts.push(part);
+        return;
+      }
+      if (index.isJsonSchemaNullType(prop.items)) {
+        if (prop.items.type === "null") {
+          fieldParts.push(`${keyPart}: null[]`);
+          return;
+        }
+        fieldParts.push(`${keyPart}: undefined[]`);
+        return;
+      }
+      if (index.isJsonSchemaObject(prop.items)) {
+        const subModelName = prop.items.$id ?? index.pascalCase(`${name}_${key}_item`);
+        if (!createdModels.includes(subModelName)) {
+          subModelParts.push(
+            tsModelFromDefinition(subModelName, prop.items)
+          );
+        }
+        fieldParts.push(`${keyPart}: ${subModelName}[];`);
+      }
+    }
+  });
+  return `export interface ${name} {
+        ${fieldParts.join("\n")}
+    }
+    ${subModelParts.join("\n")}`;
+}
+function tsInterfaceScalarField(key, prop, isOptional = false) {
+  const keyPart = isOptional ? `${key}?` : key;
+  switch (prop.type) {
+    case "string":
+      return `${keyPart}: string;`;
+    case "bigint":
+      return `${keyPart}: bigint;`;
+    case "Date":
+      return `${keyPart}: Date;`;
+    case "boolean":
+      return `${keyPart}: boolean;`;
+    case "integer":
+      return `/**
+                    * must be an integer
+                    */
+                    ${keyPart}: number;`;
+    case "number":
+      return `${keyPart}: number;`;
+  }
+}
+
+const dartClientGenerator = defineClientGeneratorPlugin(
+  (options) => {
+    return {
+      generator: async (def) => {
+        if (!options.clientName) {
+          throw new Error(
+            'Missing "clientName" cannot generate dart client'
+          );
+        }
+        if (!options.outputFile) {
+          throw new Error(
+            'Missing "outputFile" cannot generate dart client'
+          );
+        }
+        const result = createDartClient(def, options.clientName);
+        fs.writeFileSync(options.outputFile, result);
+        require$$1.execSync(`dart format ${options.outputFile}`);
+      },
+      options
+    };
+  }
+);
+const generatedModels = [];
+function createDartClient(appDef, prefix = "Client") {
+  const { models, procedures } = appDef;
+  const serviceParts = [];
+  const services = index.unflattenObject(procedures);
+  Object.keys(services).forEach((k) => {
+    const service = services[k];
+    const serviceName = index.pascalCase(`$_${prefix}_${k}_service`);
+    serviceParts.push({
+      name: serviceName,
+      key: k,
+      content: dartServiceFromServiceDefinition(
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        serviceName,
+        service,
+        prefix
+      )
+    });
+  });
+  const endpoints = {};
+  Object.keys(procedures).forEach((key) => {
+    const rpc = procedures[key];
+    endpoints[rpc.path] = rpc.method;
+  });
+  const modelParts = [];
+  Object.keys(models).forEach((key) => {
+    const model = models[key];
+    const typeName = `${prefix}${index.pascalCase(key)}`;
+    const objModel = model;
+    if (!generatedModels.includes(typeName)) {
+      modelParts.push(
+        dartModelFromJsonSchema(
+          `${prefix}${index.pascalCase(key)}`,
+          objModel
+        )
+      );
+      generatedModels.push(typeName);
+    }
+  });
+  return `// This code was autogenerated by arri. Do not modify directly.
+import "dart:convert";
+import "package:http/http.dart" as http;
+import "package:arri_client/arri_client.dart";
+
+class ${prefix} {
+  final String _baseUrl;
+  final Map<String, String> _headers;
+  const ${prefix}({
+    String baseUrl = "",
+    Map<String, String> headers = const {},
+  }): _headers = headers,
+    _baseUrl = baseUrl;
+  ${prefix} withHeaders(Map<String, String> headers) {
+    return ${prefix}(
+      baseUrl: _baseUrl,
+      headers: headers,
+    );
+  }
+  ${serviceParts.map(
+    (service) => `${service.name} get ${service.key} {
+    return ${service.name}(
+      baseUrl: _baseUrl, headers: _headers,
+    );
+  }`
+  ).join("\n  ")}
+  Future<http.Response> rawRequest(
+    ${prefix}Endpoints endpoint, {
+    Map<String, String>? query,
+    dynamic body,
+    Map<String, String>? headers,
+    Encoding? encoding,
+  }) async {
+    return arriRequest(
+      "$_baseUrl\${endpoint.path}",
+      method: endpoint.method,
+      headers: headers ?? this._headers,
+      body: body,
+      query: query,
+      encoding: encoding,
+    );
+  }
+}
+${serviceParts.map((item) => item.content).join("\n")}
+${modelParts.join("\n")}
+
+enum ${prefix}Endpoints implements Comparable<${prefix}Endpoints>, ArriEndpoint {
+  ${Object.keys(endpoints).map(
+    (key) => `${index.camelCase(key.split("/").join("_"))}(
+        path: "${key}",
+        method: HttpMethod.${endpoints[key]},
+      )`
+  ).join(",\n  ")};
+
+  const ${prefix}Endpoints({
+    required this.path, required this.method,
+  });
+  @override
+  final String path;
+  @override
+  final HttpMethod method;
+
+  @override
+  compareTo(${prefix}Endpoints other) => name.compareTo(other.name);
+}`;
+}
+function dartServiceFromServiceDefinition(name, def, prefix = "") {
+  const rpcParts = [];
+  const subServiceParts = [];
+  const serviceName = `${name}`;
+  Object.keys(def).forEach((key) => {
+    const item = def[key];
+    if (index.isProcedureDefinition(item)) {
+      let returnType = `Future<String>`;
+      let returnTypeName = "String";
+      if (item.response) {
+        returnType = `Future<${prefix}${item.response}>`;
+        returnTypeName = `${prefix}${item.response}`;
+      } else {
+        returnType = "Future<void>";
+      }
+      let paramsInput = "";
+      if (item.params) {
+        paramsInput = `${prefix}${item.params} params`;
+      }
+      let responseParser = "(body) => body;";
+      switch (returnType) {
+        case "Future<String>":
+          break;
+        case "Future<int>":
+          responseParser = `(body) => Int.parse(body)`;
+          break;
+        case "Future<double>":
+          responseParser = `(body) => Double.parse(body)`;
+          break;
+        case "Future<void>":
+          responseParser = `(body) {}`;
+          break;
+        case "Future<bool>":
+          responseParser = `(body) {
+                        switch(body) {
+                            case "true":
+                            case "1":
+                                return true;
+                            case "false":
+                            case "0":
+                            default:
+                                return false;
+                        }
+                    }`;
+          break;
+        default:
+          responseParser = `(body) => ${returnTypeName}.fromJson(json.decode(body))`;
+          break;
+      }
+      rpcParts.push(`${returnType} ${key}(${paramsInput}) {
+    return parsedArriRequest(
+      "$_baseUrl${item.path}",
+      method: HttpMethod.${item.method},
+      headers: _headers,
+      params: ${paramsInput.length ? `params.toJson()` : "null"},
+      parser: ${responseParser},
+    );
+  }`);
+      return;
+    }
+    const subServiceName = index.pascalCase(`${name}_${key}_Service`);
+    const subService = dartServiceFromServiceDefinition(
+      index.pascalCase(`${name}_${key}_Service`),
+      item,
+      prefix
+    );
+    subServiceParts.push({
+      name: subServiceName,
+      key,
+      content: subService
+    });
+  });
+  return `class ${serviceName} {
+  final String _baseUrl;
+  final Map<String, String> _headers;
+  const ${serviceName}({
+    String baseUrl = "",
+    Map<String, String> headers = const {},
+  }): _baseUrl = baseUrl,
+  _headers = headers;
+  ${subServiceParts.map(
+    (sub) => `${sub.name} get ${sub.key} {
+    return ${sub.name}(
+        baseUrl: _baseUrl,
+        headers: _headers,
+    );
+  }`
+  ).join("\n")}
+  ${rpcParts.join("\n  ")}
+}
+${subServiceParts.map((sub) => sub.content).join("\n")}
+`;
+}
+function dartModelFromJsonSchema(name, schema) {
+  const fields = [];
+  const subModelParts = [];
+  Object.entries(schema.properties ?? {}).forEach(([key, val]) => {
+    if (typeof val !== "object") {
+      return;
+    }
+    const [dartType, subTypes] = dartPropertyTypeFromSchema(
+      name,
+      key,
+      schema
+    );
+    if (subTypes?.length) {
+      for (const sub of subTypes) {
+        subModelParts.push(sub);
+      }
+    }
+    fields.push({ type: dartType, name: key });
+    if (!isDartType(dartType) && "type" in val && val.type === "object") {
+      subModelParts.push(
+        dartModelFromJsonSchema(dartType.replace("?", ""), val)
+      );
+    }
+  });
+  return `class ${name} {
+  ${fields.map((field) => `final ${field.type} ${field.name};`).join("\n  ")}
+  const ${name}({
+    ${fields.map(
+    (field) => field.type.includes("?") ? `this.${field.name},` : `required this.${field.name},`
+  ).join("\n    ")}
+  });
+  factory ${name}.fromJson(Map<String, dynamic> json) {
+    return ${name}(
+      ${fields.map((field) => `${dartParsedJsonField(field.name, field.type)},`).join("\n      ")}
+    );
+  }
+  Map<String, dynamic> toJson() {
+    return {
+      ${fields.map((field) => {
+    const isNullable = field.type.endsWith("?");
+    const typeName = field.type.replace("?", "");
+    if (isDartTypeWithNullables(field.type)) {
+      const transformer = transformers[typeName];
+      return transformer.toJsonBody(field.name, isNullable);
+    }
+    if (field.type.includes("List<")) {
+      return classListTransformer(typeName).toJsonBody(
+        field.name,
+        isNullable
+      );
+    }
+    return classTransformer(typeName, isNullable).toJsonBody(
+      field.name,
+      isNullable
+    );
+  }).join(",\n      ")},
+    };
+  }
+  ${name} copyWith({
+    ${fields.map((field) => `${field.type.replace("?", "")}? ${field.name},`).join("\n    ")}
+  }) {
+    return ${name}(
+      ${fields.map((field) => `${field.name}: ${field.name} ?? this.${field.name},`).join("\n      ")}
+    );
+  }
+}
+
+${subModelParts.join("\n")}`;
+}
+function dartPropertyTypeFromSchema(objectName, propertyName, schema) {
+  const prop = schema.properties?.[propertyName];
+  const isOptional = !schema.required?.includes(propertyName);
+  let finalType = "";
+  const subTypes = [];
+  if (index.isJsonSchemaEnum(prop)) {
+    const enumName = index.pascalCase(`${objectName}_${propertyName}`);
+    finalType = isOptional ? `${enumName}?` : enumName;
+    const options = [];
+    for (const opt of prop.anyOf) {
+      if (opt.type === "string") {
+        options.push({
+          name: opt.const.toString(),
+          type: "String",
+          value: opt.const
+        });
+      }
+      if (opt.type === "number" || opt.type === "integer") {
+        options.push({
+          name: index.camelCase(
+            `num_${opt.const}`.split(".").join("Point")
+          ),
+          type: opt.type === "number" ? "double" : "int",
+          value: opt.const
+        });
+      }
+    }
+    subTypes.push(`enum ${enumName} implements Comparable<${enumName}> {
+  ${options.map(
+      (opt) => `${opt.name}(${opt.type === "String" ? `"${opt.value}"` : opt.value})`
+    ).join(",\n  ")};
+  const ${enumName}(this.value);
+  final dynamic value;
+
+  @override
+  compareTo(${enumName} other) => name.compareTo(other.name);
+
+  factory ${enumName}.fromJson(dynamic input) {
+    for(final val in values) {
+      if(val.value == input) {
+        return val;
+      }
+    }
+    return ${options[0].name};
+  }
+
+  dynamic toJson() {
+    return value;
+  }
+}`);
+    return [finalType, subTypes];
+  }
+  if (index.isJsonSchemaNullType(prop)) {
+    finalType = "null";
+    return [finalType, subTypes];
+  }
+  if (index.isJsonSchemaScalarType(prop)) {
+    switch (prop.type) {
+      case "string":
+        finalType = isOptional ? "String?" : "String";
+        break;
+      case "integer":
+        finalType = isOptional ? "int?" : "int";
+        break;
+      case "number":
+        finalType = isOptional ? "double?" : "double";
+        break;
+      case "Date":
+        finalType = isOptional ? "DateTime?" : "DateTime";
+        break;
+      case "boolean":
+        finalType = isOptional ? "bool?" : "bool";
+        break;
+    }
+  }
+  if (index.isJsonSchemaObject(prop)) {
+    const joinedPropName = index.pascalCase(
+      `${objectName}_${propertyName}`
+    );
+    finalType = isOptional ? `${joinedPropName}?` : joinedPropName;
+  }
+  if (index.isJsonSchemaArray(prop)) {
+    const item = prop.items;
+    const type = item.type;
+    if (typeof type !== "string") {
+      throw new Error(
+        "Union types are not supported in arrays at this time"
+      );
+    }
+    switch (type) {
+      case "string":
+        finalType = isOptional ? "List<String>?" : "List<String>";
+        break;
+      case "integer":
+        finalType = isOptional ? "List<int>?" : "List<int>";
+        break;
+      case "number":
+        finalType = isOptional ? "List<double>?" : "List<double>";
+        break;
+      case "null":
+        finalType = isOptional ? "List<null>?" : "List<null>";
+        break;
+      case "boolean":
+        finalType = isOptional ? "List<bool>?" : "List<bool>";
+        break;
+      case "Date":
+        finalType = isOptional ? "List<DateTime>?" : "List<DateTime>";
+        break;
+      case "object": {
+        const subTypeName = item.$id ?? index.pascalCase(`${objectName}_${propertyName}_item`);
+        const model = dartModelFromJsonSchema(subTypeName, item);
+        if (!generatedModels.includes(subTypeName)) {
+          subTypes.push(model);
+          generatedModels.push(subTypeName);
+        }
+        finalType = isOptional ? `List<${subTypeName}>?` : `List<${subTypeName}>`;
+        break;
+      }
+    }
+  }
+  return [finalType, subTypes.length ? subTypes : void 0];
+}
+function dartParsedJsonField(fieldName, dartType) {
+  if (isDartTypeWithNullables(dartType)) {
+    switch (dartType) {
+      case "String":
+        return transformers.String.fromJsonBody(fieldName, '""');
+      case "String?":
+        return transformers.String.fromJsonBody(fieldName, "null");
+      case "bool":
+        return transformers.bool.fromJsonBody(fieldName, "false");
+      case "double":
+        return transformers.double.fromJsonBody(fieldName, "0.0");
+      case "int":
+        return transformers.int.fromJsonBody(fieldName, "0");
+      case "null":
+        return transformers.null.fromJsonBody(fieldName, "");
+      case "DateTime":
+        return transformers.DateTime.fromJsonBody(
+          fieldName,
+          "DateTime(0)"
+        );
+      case "DateTime?":
+        return transformers.DateTime.fromJsonBody(fieldName, "null");
+      case "List<String>":
+      case "List<bool>":
+      case "List<double>":
+      case "List<int>":
+      case "List<null>":
+        return defaultListFromJsonBody(
+          fieldName,
+          dartType.replace("List<", "").replace(">", ""),
+          "[]"
+        );
+      default:
+        return `${fieldName}: json["${fieldName}"] is ${dartType.replace(
+          "?",
+          ""
+        )} ? json["${fieldName}"] : null`;
+    }
+  }
+  if (dartType.includes("List<")) {
+    const innerType = dartType.replace("List<", "").replace(">", "").replace("?", "");
+    return classListTransformer(innerType).fromJsonBody(
+      fieldName,
+      dartType.endsWith("?") ? "null" : "[]"
+    );
+  }
+  const classType = dartType.split("?").join("").trim();
+  return classTransformer(classType, dartType.endsWith("?")).fromJsonBody(
+    fieldName,
+    classType
+  );
+}
+const dartTypeMap = {
+  integer: "int",
+  bigint: "int",
+  number: "double",
+  string: "String",
+  boolean: "bool",
+  null: "null",
+  Date: "DateTime",
+  object: void 0,
+  list: void 0,
+  // eslint-disable-next-line object-shorthand
+  undefined: void 0,
+  array: void 0,
+  Uint8Array: "Uint8List"
+};
+const transformers = {
+  null: {
+    fromJsonBody: (_) => `null`,
+    toJsonBody: defaultToJsonBody
+  },
+  int: {
+    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "int", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  double: {
+    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "double", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  String: {
+    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "String", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  bool: {
+    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "bool", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  DateTime: {
+    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is String ? DateTime.parse(json["${key}"]) : ${fallback}`,
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toIso8601String()`
+  },
+  "List<null>": {
+    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "null", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<int>": {
+    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "int", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<double>": {
+    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "double", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<String>": {
+    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "String", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<bool>": {
+    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "bool", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<DateTime>": {
+    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List<String> ?
+            (json["${key}"] as List<String>)
+                .map((item) => DateTime.parse(item)).toList() : ${fallback}`,
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toIso8601String()).toList()`
+  },
+  Uint8List: {
+    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List ? Uint8List.fromList(json["${key}"]) : ${fallback}`,
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toList()`
+  },
+  "List<Uint8List>": {
+    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List && (json["${key}"] as List).isNotEmpty && (json["${key}"] as List).first is List ? json["${key}"] : ${fallback}`,
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toList()).toList()`
+  }
+};
+function defaultFromJsonBody(key, typename, fallback) {
+  return `${key}: json["${key}"] is ${typename} ? json["${key}"] : ${fallback}`;
+}
+function defaultListFromJsonBody(key, typename, fallback) {
+  return `${key}: json["${key}"] is List<${typename}> ? json["${key}"] : ${fallback}`;
+}
+function defaultToJsonBody(key) {
+  return `"${key}": ${key}`;
+}
+const classTransformer = (typename, nullable) => {
+  return {
+    fromJsonBody: (key, fallback) => {
+      if (nullable) {
+        return `${key}: json["${key}"] is Map<String, dynamic> ? 
+                ${typename}.fromJson(json["${key}"]) : null`;
+      }
+      return `${key}: ${typename}.fromJson(json["${key}"])`;
+    },
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toJson()`
+  };
+};
+const classListTransformer = (typename) => {
+  return {
+    fromJsonBody: (key, fallback) => {
+      return `${key}: json["${key}"] is List<Map<String, dynamic>> ? 
+                (json["${key}"] as List<Map<String, dynamic>>)
+                    .map((val) => ${typename}.fromJson(val)).toList() : ${fallback}`;
+    },
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toJson()).toList()`
+  };
+};
+function isDartType(input) {
+  if (typeof input !== "string") {
+    return false;
+  }
+  for (const val of Object.values(dartTypeMap)) {
+    if (input === val) {
+      return true;
+    }
+    if (input.replace("List<", "").replace(">", "") === val) {
+      return true;
+    }
+  }
+  return false;
+}
+function isDartTypeWithNullables(input) {
+  if (typeof input !== "string") {
+    return false;
+  }
+  for (const val of Object.values(dartTypeMap)) {
+    if (input.replace("?", "") === val) {
+      return true;
+    }
+    if (input.replace("?", "").replace("List<", "").replace(">", "") === val) {
+      return true;
+    }
+  }
+  return false;
+}
+
+exports.classListTransformer = classListTransformer;
+exports.classTransformer = classTransformer;
+exports.createDartClient = createDartClient;
+exports.createTypescriptClient = createTypescriptClient;
+exports.dartClientGenerator = dartClientGenerator;
+exports.dartModelFromJsonSchema = dartModelFromJsonSchema;
+exports.dartParsedJsonField = dartParsedJsonField;
+exports.dartPropertyTypeFromSchema = dartPropertyTypeFromSchema;
+exports.dartServiceFromServiceDefinition = dartServiceFromServiceDefinition;
+exports.defineClientGeneratorPlugin = defineClientGeneratorPlugin;
+exports.isDartType = isDartType;
+exports.isDartTypeWithNullables = isDartTypeWithNullables;
+exports.transformers = transformers;
+exports.tsModelFromDefinition = tsModelFromDefinition;
+exports.tsRpcFromProcedureDefinition = tsRpcFromProcedureDefinition;
+exports.tsServiceFromServiceDefinition = tsServiceFromServiceDefinition;
+exports.typescriptClientGenerator = typescriptClientGenerator;