@arrirpc/codegen-dart 0.49.1 → 0.50.0

package/dist/index.cjs

@@ -1,1032 +1,1232 @@
 'use strict';
 
+const node_child_process = require('node:child_process');
+const fs = require('node:fs/promises');
 const codegenUtils = require('@arrirpc/codegen-utils');
-const schema = require('@arrirpc/schema');
-const child_process = require('child_process');
-const fs = require('fs');
+const path = require('pathe');
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-function camelCaseWrapper(input) {
-  if (input.toUpperCase() === input) {
-    return codegenUtils.camelCase(input, { normalize: true });
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+function outputIsNullable(schema, context) {
+  if (schema.nullable) {
+    return true;
+  }
+  if (context.isOptional) {
+    return true;
   }
-  return codegenUtils.camelCase(input);
+  return false;
 }
-const dartClientGenerator = codegenUtils.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 numProcedures = Object.keys(def.procedures).length;
-        if (numProcedures <= 0) {
-          console.warn(
-            "No procedures found in definition file. Dart client will not be generated"
-          );
-        }
-        const result = createDartClient(def, options);
-        fs.writeFileSync(options.outputFile, result);
-        try {
-          child_process.execSync(`dart format ${options.outputFile}`);
-        } catch (err) {
-          console.error("Error formatting dart client", err);
-        }
-      },
-      options
-    };
+const reservedIdentifierKeywords = {
+  abstract: 2,
+  as: 2,
+  assert: 0,
+  async: 3,
+  await: 1,
+  base: 3,
+  break: 0,
+  case: 0,
+  catch: 0,
+  class: 0,
+  const: 0,
+  continue: 0,
+  covariant: 2,
+  default: 0,
+  deferred: 2,
+  do: 0,
+  dynamic: 2,
+  else: 0,
+  enum: 0,
+  export: 2,
+  extends: 0,
+  extension: 2,
+  external: 2,
+  factory: 2,
+  false: 0,
+  final: 0,
+  finally: 0,
+  for: 0,
+  Function: 2,
+  get: 2,
+  hide: 3,
+  if: 0,
+  implements: 2,
+  import: 2,
+  in: 0,
+  interface: 2,
+  is: 0,
+  late: 2,
+  library: 2,
+  mixin: 2,
+  new: 0,
+  null: 0,
+  of: 3,
+  on: 3,
+  operator: 2,
+  part: 2,
+  required: 2,
+  rethrow: 0,
+  return: 0,
+  sealed: 3,
+  set: 2,
+  show: 3,
+  static: 2,
+  super: 0,
+  switch: 0,
+  sync: 3,
+  this: 0,
+  throw: 0,
+  true: 0,
+  try: 0,
+  type: 2,
+  typedef: 2,
+  var: 0,
+  void: 0,
+  when: 3,
+  with: 0,
+  while: 0,
+  yield: 1
+};
+function canUseIdentifier(input) {
+  const reservedId = reservedIdentifierKeywords[input];
+  if (typeof reservedId === "undefined") {
+    return true;
   }
-);
-class DartClientGenerator {
-  constructor() {
-    __publicField(this, "generatedModels", []);
+  switch (reservedId) {
+    case 0:
+      return false;
+    case 1:
+      return true;
+    case 2:
+      return true;
+    case 3:
+      return true;
+    default:
+      throw new Error("Unhandled case");
   }
 }
-function getAnnotations(metadata) {
-  const commentParts = [];
-  if (metadata?.description?.length) {
-    const parts = metadata.description.split("\n");
-    for (const part of parts) {
-      commentParts.push(`/// ${part}`);
-    }
+function sanitizeIdentifier(input) {
+  const bannedCharacters = "!@#$%^&*()-=+[{}]\\|/?.><,;`~";
+  const result = codegenUtils.removeDisallowedChars(input, bannedCharacters);
+  const numbers = "0123456789";
+  if (numbers.includes(result.charAt(0))) {
+    return `k_${result}`;
   }
-  if (metadata?.isDeprecated) {
-    commentParts.push("@deprecated");
+  return result;
+}
+function canUseClassName(input) {
+  const reservedId = reservedIdentifierKeywords[input];
+  if (typeof reservedId === "undefined") {
+    return true;
   }
-  if (commentParts.length === 0) {
-    return "";
+  switch (reservedId) {
+    case 0:
+      return false;
+    case 1:
+      return false;
+    case 2:
+      return false;
+    case 3:
+      return true;
+    default:
+      throw new Error("Unhandled case");
   }
-  return `${commentParts.join("\n")}
-`;
 }
-function createDartClient(def, opts) {
-  const existingClassNames = [];
-  const clientVersion = def.info?.version ?? "";
-  const services = codegenUtils.unflattenProcedures(def.procedures);
-  const rpcParts = [];
-  const serviceGetterParts = [];
-  const serviceParts = [];
-  const modelParts = [];
-  for (const key of Object.keys(services)) {
-    const item = services[key];
-    if (codegenUtils.isRpcDefinition(item)) {
-      const rpc = dartRpcFromDefinition(key, item);
-      if (rpc) {
-        rpcParts.push(rpc);
-      }
-      continue;
-    }
-    if (codegenUtils.isServiceDefinition(item)) {
-      const serviceName = codegenUtils.pascalCase(`${opts.clientName}_${key}`);
-      const service = dartServiceFromDefinition(serviceName, item, {
-        versionNumber: clientVersion,
-        ...opts
-      });
-      serviceParts.push(service);
-      serviceGetterParts.push(`${serviceName}Service get ${key} {
-  return ${serviceName}Service(
-    httpClient: _httpClient,
-    baseUrl: _baseUrl, 
-    headers: _headers,
+function validDartIdentifier(input) {
+  const finalIdentifier = sanitizeIdentifier(
+    codegenUtils.camelCase(input, { normalize: true })
   );
-}`);
-    }
+  if (!canUseIdentifier(finalIdentifier)) {
+    return `k_${finalIdentifier}`;
   }
-  for (const key of Object.keys(def.definitions)) {
-    const item = def.definitions[key];
-    if (codegenUtils.isSchemaFormProperties(item) || codegenUtils.isSchemaFormDiscriminator(item) || codegenUtils.isSchemaFormValues(item)) {
-      const result = dartTypeFromJtdSchema(key, item, {
-        isOptional: false,
-        existingClassNames
-      });
-      modelParts.push(result.content);
-    }
+  return finalIdentifier;
+}
+function validDartClassName(input, modelPrefix) {
+  const className = sanitizeIdentifier(
+    codegenUtils.pascalCase(input, { normalize: true })
+  );
+  if (canUseClassName(className) || modelPrefix.length) {
+    return className;
   }
-  if (rpcParts.length === 0 && serviceGetterParts.length === 0) {
-    return `// this file was autogenerated by arri
-// ignore_for_file: type=lint
-import "package:arri_client/arri_client.dart";
-
-${modelParts.join("\n")}`;
+  return `Class${className}`;
+}
+function getDartClassName(schema, context) {
+  if (schema.metadata?.id) {
+    return validDartClassName(schema.metadata.id, context.modelPrefix);
   }
-  return `// this file was autogenerated by arri
-// ignore_for_file: type=lint, unused_field
-import "dart:async";
-import "dart:convert";
-import "package:arri_client/arri_client.dart";
-import "package:http/http.dart" as http;
-
-class ${opts.clientName} {
-  final http.Client? _httpClient;
-  final String _baseUrl;
-  final String _clientVersion = "${def.info?.version ?? ""}";
-  late final FutureOr<Map<String, String>> Function()? _headers;
-  ${opts.clientName}({
-    http.Client? httpClient,
-    String baseUrl = "",
-    FutureOr<Map<String, String>> Function()? headers,
-})  : _httpClient = httpClient,
-    _baseUrl = baseUrl,
-    _headers = headers;
-  ${rpcParts.join("\n  ")}
-  ${serviceGetterParts.join("\n  ")}
+  if (context.discriminatorParentId) {
+    return validDartClassName(
+      `${context.discriminatorParentId}_${context.discriminatorValue}`,
+      context.modelPrefix
+    );
+  }
+  return validDartClassName(
+    context.instancePath.split("/").join("_"),
+    context.modelPrefix
+  );
 }
 
-${serviceParts.join("\n")}
+function dartAnyFromSchema(schema, context) {
+  const typeName = `dynamic`;
+  const isNullable = outputIsNullable(schema, context);
+  const defaultValue = `null`;
+  return {
+    typeName,
+    isNullable,
+    defaultValue,
+    fromJson(input) {
+      return `${input}`;
+    },
+    toJson(input) {
+      return input;
+    },
+    toQueryString() {
+      return `print("[WARNING] any's cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+}
 
-${modelParts.join("\n")}
-`;
+function dartListFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const innerType = dartTypeFromSchema(schema.elements, {
+    clientName: context.clientName,
+    modelPrefix: context.modelPrefix,
+    generatedTypes: context.generatedTypes,
+    instancePath: `${context.instancePath}/[Element]`,
+    schemaPath: `${context.schemaPath}/elements`
+  });
+  const typeName = isNullable ? `List<${innerType.typeName}>?` : `List<${innerType.typeName}>`;
+  const defaultValue = isNullable ? "null" : "[]";
+  return {
+    typeName,
+    isNullable,
+    defaultValue,
+    fromJson(input) {
+      if (isNullable) {
+        return `${input} is List
+                ? (${input} as List)
+                    .map((_el_) => ${innerType.fromJson(`_el_`)})
+                    .toList()
+                : null`;
+      }
+      return `${input} is List
+            ? (${input} as List)
+                .map((_el_) => ${innerType.fromJson(`_el_`)})
+                .toList()
+            : <${innerType.typeName}>[]`;
+    },
+    toJson(input) {
+      if (context.isOptional) {
+        return `${input}!.map((_el_) => ${innerType.toJson("_el_", "", "")}).toList()`;
+      }
+      if (schema.nullable) {
+        return `${input}?.map((_el_) => ${innerType.toJson("_el_", "", "")}).toList()`;
+      }
+      return `${input}.map((_el_) => ${innerType.toJson("_el_", "", "")}).toList()`;
+    },
+    toQueryString() {
+      return `print(
+        "[WARNING] arrays cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: innerType.content
+  };
 }
-function dartServiceFromDefinition(name, def, opts) {
-  const rpcParts = [];
-  const subServiceParts = [];
-  const serviceName = `${name}`;
-  Object.keys(def).forEach((key) => {
-    const item = def[key];
-    if (codegenUtils.isRpcDefinition(item)) {
-      const rpc = dartRpcFromDefinition(key, item);
-      if (rpc) {
-        rpcParts.push(rpc);
+
+function dartClassFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const className = getDartClassName(schema, context);
+  const finalClassName = `${context.modelPrefix}${className}`;
+  const typeName = isNullable ? `${finalClassName}?` : finalClassName;
+  const defaultValue = isNullable ? "null" : `${finalClassName}.empty()`;
+  const result = {
+    typeName,
+    isNullable,
+    defaultValue,
+    fromJson(input) {
+      if (isNullable) {
+        return `${input} is Map<String, dynamic>
+                ? ${finalClassName}.fromJson(${input})
+                : null`;
       }
-      return;
-    }
-    if (codegenUtils.isServiceDefinition(item)) {
-      const subServiceName = codegenUtils.pascalCase(`${serviceName}_${key}`);
-      const subService = dartServiceFromDefinition(
-        subServiceName,
-        item,
-        opts
-      );
-      subServiceParts.push({
-        name: subServiceName,
-        key,
-        content: subService
-      });
-    }
-  });
-  return `class ${serviceName}Service {
-  final http.Client? _httpClient;
-  final String _baseUrl;
-  final String _clientVersion = "${opts.versionNumber}";
-  late final FutureOr<Map<String, String>> Function()? _headers;
-  ${serviceName}Service({
-    http.Client? httpClient,
-    String baseUrl = "",
-    FutureOr<Map<String, String>> Function()? headers,
-  })  : _httpClient = httpClient,
-      _baseUrl = baseUrl,
-      _headers = headers;
-  ${subServiceParts.map(
-    (sub) => `${sub.name}Service get ${sub.key} {
-    return ${sub.name}Service(
-        httpClient: _httpClient,
-        baseUrl: _baseUrl,
-        headers: _headers,
+      return `${input} is Map<String, dynamic>
+            ? ${finalClassName}.fromJson(${input})
+            : ${finalClassName}.empty()`;
+    },
+    toJson(input) {
+      if (context.isOptional) {
+        return `${input}!.toJson()`;
+      }
+      if (schema.nullable) {
+        return `${input}?.toJson()`;
+      }
+      return `${input}.toJson()`;
+    },
+    toQueryString() {
+      return `print(
+        "[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+  if (context.generatedTypes.includes(className)) {
+    return result;
+  }
+  const propNames = [];
+  const fieldParts = [];
+  const constructorParts = [];
+  const defaultParts = [];
+  const fromJsonParts = [];
+  const toJsonRequiredParts = [];
+  if (context.discriminatorKey && context.discriminatorValue) {
+    toJsonRequiredParts.push(
+      `      "${context.discriminatorKey}": ${validDartIdentifier(context.discriminatorKey)},`
     );
-  }`
-  ).join("\n")}
-  ${rpcParts.join("\n  ")}
-}
-${subServiceParts.map((sub) => sub.content).join("\n")}
-`;
-}
-function dartRpcFromDefinition(key, def, opts) {
-  if (def.transport === "http") {
-    return dartHttpRpcFromSchema(key, def);
   }
-  if (def.transport === "ws") {
-    return dartWsRpcFromSchema(key, def);
+  const toJsonOptionalParts = [];
+  const toUrlQueryParts = [];
+  if (context.discriminatorKey && context.discriminatorValue) {
+    toUrlQueryParts.push(
+      `_queryParts_.add("${context.discriminatorKey}=$${validDartIdentifier(context.discriminatorKey)}");`
+    );
   }
-  console.warn(
-    `[codegen-dart] WARNING: unsupported transport "${def.transport}". Skipping "${def.path}".`
-  );
-  return "";
-}
-function dartHttpRpcFromSchema(key, def, _opts) {
-  let returnType = `Future<String>`;
-  let returnTypeName = "String";
-  if (def.response) {
-    returnTypeName = codegenUtils.pascalCase(def.response);
-    if (def.isEventStream) {
-      returnType = `EventSource<${returnTypeName}>`;
+  const copyWithParamParts = [];
+  const copyWithReturnParts = [];
+  const subContentParts = [];
+  for (const key of Object.keys(schema.properties)) {
+    const innerSchema = schema.properties[key];
+    const typeResult = dartTypeFromSchema(innerSchema, {
+      clientName: context.clientName,
+      modelPrefix: context.modelPrefix,
+      generatedTypes: context.generatedTypes,
+      instancePath: `/${className}/${key}`,
+      schemaPath: `${context.schemaPath}/properties/${key}`
+    });
+    const propName = validDartIdentifier(key);
+    propNames.push(propName);
+    fieldParts.push(`  final ${typeResult.typeName} ${propName};`);
+    constructorParts.push(`    required this.${propName},`);
+    defaultParts.push(`      ${propName}: ${typeResult.defaultValue},`);
+    fromJsonParts.push(
+      `    final ${propName} = ${typeResult.fromJson(`_input_["${key}"]`, key)};`
+    );
+    toJsonRequiredParts.push(
+      `      "${key}": ${typeResult.toJson(propName, "", key)},`
+    );
+    toUrlQueryParts.push(
+      `    ${typeResult.toQueryString(propName, "_queryParts_", key)};`
+    );
+    if (typeResult.isNullable) {
+      copyWithParamParts.push(
+        `    ${typeResult.typeName} Function()? ${propName},`
+      );
+      copyWithReturnParts.push(
+        `      ${propName}: ${propName} != null ? ${propName}() : this.${propName},`
+      );
     } else {
-      returnType = `Future<${returnTypeName}>`;
+      copyWithParamParts.push(
+        `    ${typeResult.typeName}${typeResult.typeName !== "dynamic" ? "?" : ""} ${propName},`
+      );
+      copyWithReturnParts.push(
+        `      ${propName}: ${propName} ?? this.${propName},`
+      );
+    }
+    if (typeResult.content) {
+      subContentParts.push(typeResult.content);
     }
-  } else {
-    returnType = "Future<void>";
   }
-  let paramsInput = "";
-  if (def.params) {
-    paramsInput = `${codegenUtils.pascalCase(def.params)} params`;
+  for (const key of Object.keys(schema.optionalProperties ?? {})) {
+    const innerSchema = schema.optionalProperties[key];
+    const typeResult = dartTypeFromSchema(innerSchema, {
+      clientName: context.clientName,
+      modelPrefix: context.modelPrefix,
+      generatedTypes: context.generatedTypes,
+      instancePath: `/${className}/${key}`,
+      schemaPath: `${context.schemaPath}/optionalProperties/${key}`,
+      isOptional: true
+    });
+    const propName = validDartIdentifier(key);
+    propNames.push(propName);
+    fieldParts.push(`  final ${typeResult.typeName} ${propName};`);
+    constructorParts.push(`    this.${propName},`);
+    fromJsonParts.push(
+      `    final ${propName} = ${typeResult.fromJson(`_input_["${key}"]`, key)};`
+    );
+    toJsonOptionalParts.push(
+      `    if (${propName} != null) _output_["${key}"] = ${typeResult.toJson(propName, "_output_", key)};`
+    );
+    toUrlQueryParts.push(
+      `    ${typeResult.toQueryString(propName, "_queryParts_", key)};`
+    );
+    copyWithParamParts.push(
+      `  ${typeResult.typeName} Function()? ${propName},`
+    );
+    copyWithReturnParts.push(
+      `      ${propName}: ${propName} != null ? ${propName}() : this.${propName},`
+    );
+    if (typeResult.content) {
+      subContentParts.push(typeResult.content);
+    }
   }
-  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;
+  let discriminatorPart = "";
+  if (context.discriminatorKey && context.discriminatorValue) {
+    discriminatorPart = `
+    @override
+    String get ${validDartIdentifier(context.discriminatorKey)} => "${context.discriminatorValue}";
+`;
   }
-  if (def.isEventStream) {
-    const hookParts = [
-      `SseHookOnData<${returnTypeName}>? onData`,
-      `SseHookOnError<${returnTypeName}>? onError`,
-      `SseHookOnConnectionError<${returnTypeName}>? onConnectionError`,
-      `SseHookOnOpen<${returnTypeName}>? onOpen`,
-      `SseHookOnClose<${returnTypeName}>? onClose`,
-      `String? lastEventId`
-    ];
-    return `${getAnnotations({ description: def.description, isDeprecated: def.isDeprecated })}${returnType} ${key}(${paramsInput.length ? `${paramsInput}, ` : ""}{${hookParts.join(", ")},}) {
-            return parsedArriSseRequest<${returnTypeName}>(
-                "$_baseUrl${def.path}",
-                httpClient: _httpClient,
-                method: HttpMethod.${def.method},
-                headers: _headers,
-                params: ${paramsInput.length ? `params.toJson()` : "null"},
-                parser: ${responseParser},
-                onData: onData,
-                onError: onError,
-                onConnectionError: onConnectionError,
-                onOpen: onOpen,
-                onClose: onClose,
-                lastEventId: lastEventId,
-                clientVersion: _clientVersion,
-            );
-        }`;
+  result.content = `class ${finalClassName} implements ${context.discriminatorParentId ?? "ArriModel"} {
+${fieldParts.join("\n")}
+  const ${finalClassName}({
+${constructorParts.join("\n")}
+  });
+${discriminatorPart}
+  factory ${finalClassName}.empty() {
+    return ${finalClassName}(
+    ${defaultParts.join("\n")}
+    );
   }
-  return `${getAnnotations({ description: def.description, isDeprecated: def.isDeprecated })}${returnType} ${key}(${paramsInput}) {
-    return parsedArriRequest(
-      "$_baseUrl${def.path}",
-      httpClient: _httpClient,
-      method: HttpMethod.${def.method},
-      headers: _headers,
-      params: ${paramsInput.length ? `params.toJson()` : "null"},
-      parser: ${responseParser},
-      clientVersion: _clientVersion,
+
+  factory ${finalClassName}.fromJson(Map<String, dynamic> _input_) {
+${fromJsonParts.join("\n")}
+    return ${finalClassName}(
+${propNames.map((prop) => `      ${prop}: ${prop},`).join("\n")}
     );
-  }`;
-}
-function dartWsRpcFromSchema(key, def, _opts) {
-  const serverMsg = def.response ? codegenUtils.pascalCase(def.response, { normalize: true }) : "Null";
-  const clientMsg = def.params ? codegenUtils.pascalCase(def.params, { normalize: true }) : "Null";
-  const returnType = `Future<ArriWebsocketController<${serverMsg}, ${clientMsg}>>`;
-  const parser = def.response ? `(body) => ${serverMsg}.fromJson(json.decode(body))` : `(_) => null`;
-  const serializer = def.params ? `(body) => json.encode(body.toJson())` : `(_) => ""`;
-  return `${getAnnotations({ description: def.description, isDeprecated: def.isDeprecated })}${returnType} ${key}() {
-        return arriWebsocketRequest<${serverMsg}, ${clientMsg}>(
-            "$_baseUrl${def.path}",
-            headers: _headers,
-            parser: ${parser},
-            serializer: ${serializer},
-            clientVersion: _clientVersion,
-        );
-    }`;
-}
-function dartTypeFromJtdSchema(nodePath, def, additionalOptions) {
-  if (codegenUtils.isSchemaFormType(def)) {
-    return dartScalarFromJtdScalar(nodePath, def, additionalOptions);
   }
-  if (codegenUtils.isSchemaFormProperties(def)) {
-    return dartClassFromJtdSchema(nodePath, def, additionalOptions);
+
+  factory ${finalClassName}.fromJsonString(String input) {
+    return ${finalClassName}.fromJson(json.decode(input));
   }
-  if (codegenUtils.isSchemaFormElements(def)) {
-    return dartArrayFromJtdSchema(nodePath, def, additionalOptions);
+
+  @override
+  Map<String, dynamic> toJson() {
+    final _output_ = <String, dynamic>{
+${toJsonRequiredParts.join("\n")}
+    };
+${toJsonOptionalParts.join("\n")}
+    return _output_;
   }
-  if (codegenUtils.isSchemaFormEnum(def)) {
-    return dartEnumFromJtdSchema(nodePath, def, additionalOptions);
+
+  @override
+  String toJsonString() {
+    return json.encode(toJson());
   }
-  if (codegenUtils.isSchemaFormValues(def)) {
-    return dartMapFromJtdSchema(nodePath, def, additionalOptions);
+
+  @override
+  String toUrlQueryParams() {
+    final _queryParts_ = <String>[];
+${toUrlQueryParts.join("\n")}
+    return _queryParts_.join("&");
   }
-  if (codegenUtils.isSchemaFormDiscriminator(def)) {
-    return dartSealedClassFromJtdSchema(nodePath, def, additionalOptions);
+
+  @override
+  ${finalClassName} copyWith({
+${copyWithParamParts.join("\n")}
+  }) {
+    return ${finalClassName}(
+${copyWithReturnParts.join("\n")}
+    );
   }
-  if (codegenUtils.isSchemaFormRef(def)) {
-    return dartRefFromJtdSchema(nodePath, def, additionalOptions);
+
+  @override
+  List<Object?> get props => [
+${propNames.map((prop) => `        ${prop},`).join("\n")}
+      ];
+
+  @override
+  bool operator ==(Object other) {
+    return other is ${finalClassName} &&
+      listsAreEqual(props, other.props);
   }
-  return dartDynamicFromAny(nodePath, schema.a.any(), additionalOptions);
-}
-function dartClassFromJtdSchema(nodePath, def, additionalOptions) {
-  const isException = additionalOptions?.isException ?? false;
-  const discOptions = additionalOptions?.discriminatorOptions;
-  const isDiscriminatorChild = (discOptions?.discriminatorKey.length ?? 0) > 0;
-  const jsonKey = nodePath.split(".").pop() ?? "";
-  const key = camelCaseWrapper(jsonKey);
-  let className = def.metadata?.id ? codegenUtils.pascalCase(def.metadata.id) : void 0;
-  if (!className) {
-    const relativePath = nodePath.split(".").pop();
-    if (additionalOptions.parentId && relativePath) {
-      className = codegenUtils.pascalCase(
-        `${additionalOptions.parentId}_${relativePath}`
-      );
-    } else {
-      className = codegenUtils.pascalCase(nodePath.split(".").join("_"));
-    }
+
+  @override
+  int get hashCode => listToHashCode(props);
+
+  @override
+  String toString() {
+    return "${finalClassName} \${toJsonString()}";
   }
-  const properties = [];
-  const optionalProperties = [];
+}
+  
+${subContentParts.join("\n\n")}`;
+  context.generatedTypes.push(className);
+  return result;
+}
+
+function dartSealedClassFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const className = getDartClassName(schema, context);
+  const finalClassName = `${context.modelPrefix}${className}`;
+  const typeName = isNullable ? `${finalClassName}?` : finalClassName;
+  const defaultValue = isNullable ? `null` : `${finalClassName}.empty()`;
+  const discriminatorKey = schema.discriminator;
+  const subTypeParts = [];
   const subContentParts = [];
-  if (!def.properties) {
-    return {
-      typeName: "",
-      fieldTemplate: "",
-      constructorTemplate: "",
-      fromJsonTemplate: () => "",
-      toJsonTemplate: () => "",
-      content: ""
-    };
-  }
-  for (const key2 of Object.keys(def.properties ?? {})) {
-    const keyPath = `${nodePath}.${key2}`;
-    const prop = def.properties[key2];
-    const mappedProp = dartTypeFromJtdSchema(keyPath, prop, {
-      parentId: className,
-      isOptional: false,
-      existingClassNames: additionalOptions.existingClassNames
+  for (const key of Object.keys(schema.mapping)) {
+    const subSchema = schema.mapping[key];
+    const discriminatorValue = key;
+    const subTypeResult = dartClassFromSchema(subSchema, {
+      clientName: context.clientName,
+      modelPrefix: context.modelPrefix,
+      generatedTypes: context.generatedTypes,
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/mapping/${key}`,
+      discriminatorKey,
+      discriminatorValue,
+      discriminatorParentId: className
     });
-    properties.push({
-      key: key2,
-      templates: mappedProp
+    subTypeParts.push({
+      name: subTypeResult.typeName,
+      value: discriminatorValue
     });
-    if (mappedProp?.content) {
-      subContentParts.push(mappedProp.content);
+    if (subTypeResult.content) {
+      subContentParts.push(subTypeResult.content);
     }
   }
-  if (def.optionalProperties) {
-    for (const key2 of Object.keys(def.optionalProperties ?? {})) {
-      const keyPath = `${nodePath}.${key2}`;
-      const prop = def.optionalProperties[key2];
-      const mappedProp = dartTypeFromJtdSchema(keyPath, prop, {
-        parentId: className,
-        isOptional: true,
-        existingClassNames: additionalOptions.existingClassNames
-      });
-      optionalProperties.push({ key: key2, templates: mappedProp });
-      if (mappedProp?.content) {
-        subContentParts.push(mappedProp.content);
+  const result = {
+    typeName,
+    isNullable,
+    defaultValue,
+    fromJson(input) {
+      if (isNullable) {
+        return `${input} is Map<String, dynamic>
+                    ? ${finalClassName}.fromJson(${input})
+                    : null`;
       }
-    }
-  }
-  const fieldParts = [];
-  const constructorParts = [];
-  const fromJsonParts = [];
-  const copyWithParamParts = [];
-  const copyWithInitParts = [];
-  if (discOptions) {
-    fieldParts.push(`@override
-final String ${camelCaseWrapper(discOptions.discriminatorKey)} = "${discOptions.discriminatorValue}"`);
-  }
-  for (const prop of properties) {
-    fieldParts.push(prop.templates.fieldTemplate);
-    constructorParts.push(prop.templates.constructorTemplate);
-    const subJsonKey = prop.key;
-    const subKey = camelCaseWrapper(prop.key);
-    fromJsonParts.push(
-      `${subKey}: ${prop.templates.fromJsonTemplate(
-        `json["${subJsonKey}"]`
-      )}`
-    );
-    if (prop.templates.typeName === "dynamic") {
-      copyWithParamParts.push(`dynamic ${subKey}`);
-      copyWithInitParts.push(`${subKey}: ${subKey} ?? this.${subKey}`);
-    } else {
-      if (prop.templates.typeName.endsWith("?")) {
-        copyWithParamParts.push(
-          `ArriBox<${prop.templates.typeName}>? ${subKey}`
-        );
-        copyWithInitParts.push(
-          `${subKey}: ${subKey} != null ? ${subKey}.value : this.${subKey}`
-        );
-      } else {
-        copyWithParamParts.push(
-          `${prop.templates.typeName}? ${subKey}`
-        );
-        copyWithInitParts.push(
-          `${subKey}: ${subKey} ?? this.${subKey}`
-        );
+      return `${input} is Map<String, dynamic>
+                ? ${finalClassName}.fromJson(${input})
+                : ${finalClassName}.empty()`;
+    },
+    toJson(input) {
+      if (context.isOptional) {
+        return `${input}!.toJson()`;
       }
-    }
-  }
-  for (const prop of optionalProperties) {
-    fieldParts.push(prop.templates.fieldTemplate);
-    constructorParts.push(prop.templates.constructorTemplate);
-    const subKey = camelCaseWrapper(prop.key);
-    const subJsonKey = prop.key;
-    fromJsonParts.push(
-      `${subKey}: ${prop.templates.fromJsonTemplate(
-        `json["${subJsonKey}"]`
-      )}`
-    );
-    if (prop.templates.typeName === "dynamic") {
-      copyWithParamParts.push(`dynamic ${subKey}`);
-      copyWithInitParts.push(`${subKey}: ${subKey} ?? this.${subKey}`);
-    } else {
-      if (prop.templates.typeName.endsWith("?")) {
-        copyWithParamParts.push(
-          `ArriBox<${prop.templates.typeName}>? ${subKey}`
-        );
-        copyWithInitParts.push(
-          `${subKey}: ${subKey} != null ? ${subKey}.value : this.${subKey}`
-        );
-      } else {
-        copyWithParamParts.push(
-          `${prop.templates.typeName}? ${subKey}`
-        );
-        copyWithInitParts.push(
-          `${subKey}: ${subKey} ?? this.${subKey}`
-        );
+      if (schema.nullable) {
+        return `${input}?.toJson()`;
       }
-    }
-  }
-  let classNamePart = `class ${className}`;
-  if (isDiscriminatorChild) {
-    classNamePart += ` implements ${discOptions?.discriminatorParentClassName}`;
-  } else if (isException) {
-    classNamePart += ` implements Exception`;
+      return `${input}.toJson()`;
+    },
+    toQueryString() {
+      return `print(
+        "[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+  if (context.generatedTypes.includes(className)) {
+    return result;
   }
-  let content = `${getAnnotations(def.metadata)}${classNamePart} {
-    ${fieldParts.join(";\n  ")};
-  const ${className}({
-    ${constructorParts.join(",\n    ")},
-  });
-  factory ${className}.fromJson(Map<String, dynamic> json) {
-    return ${className}(
-      ${fromJsonParts.join(",\n      ")},
+  const discriminatorProp = validDartIdentifier(schema.discriminator);
+  result.content = `sealed class ${finalClassName} implements ArriModel {
+    String get ${discriminatorProp};
+    const ${finalClassName}();
+
+    factory ${finalClassName}.empty() {
+        return ${subTypeParts[0]?.name}.empty();
+    }
+
+    factory ${finalClassName}.fromJson(Map<String, dynamic> _input_) {
+        final ${discriminatorProp} = typeFromDynamic<String>(_input_["${schema.discriminator}"], "");
+        switch (${discriminatorProp}) {
+${subTypeParts.map(
+    (type) => `      case "${type.value}":
+        return ${type.name}.fromJson(_input_);`
+  ).join("\n")}
+          default:
+            return ${finalClassName}.empty();
+        }
+    }
+    
+    factory ${finalClassName}.fromJsonString(String input) {
+        return ${finalClassName}.fromJson(json.decode(input));
+    }
+}
+    
+${subContentParts.join("\n\n")}`;
+  context.generatedTypes.push(className);
+  return result;
+}
+
+function dartEnumFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const enumName = getDartClassName(schema, context);
+  const typeName = isNullable ? `${enumName}?` : enumName;
+  const enumValues = schema.enum.map((val) => ({
+    name: codegenUtils.camelCase(val, { normalize: true }),
+    serialValue: val
+  }));
+  if (!enumValues.length) {
+    throw new Error(
+      `Enum schemas must have at least one enum value. At ${context.instancePath}.`
     );
   }
-  ${isDiscriminatorChild ? `@override` : ""}
-  Map<String, dynamic> toJson() {
-    final __result = <String, dynamic>{${isDiscriminatorChild ? `
-      "${discOptions?.discriminatorKey}": ${camelCaseWrapper(
-    discOptions?.discriminatorKey ?? ""
-  )},` : ""}
-      ${properties.map(
-    (prop) => `"${prop.key}": ${prop.templates.toJsonTemplate(
-      camelCaseWrapper(prop.key)
-    )}`
-  ).join(",\n      ")}${properties.length ? "," : ""}
-    };
-    ${optionalProperties.map(
-    (prop) => `if (${camelCaseWrapper(prop.key)} != null) {
-      __result["${prop.key}"] = ${prop.templates.toJsonTemplate(
-      camelCaseWrapper(prop.key)
-    )};
-    }`
-  ).join("\n")}
-    return __result;
+  const defaultValue = isNullable ? "null" : `${context.modelPrefix}${enumName}.${enumValues[0]?.name}`;
+  const output = {
+    typeName,
+    isNullable,
+    defaultValue,
+    fromJson(input, _key) {
+      if (isNullable) {
+        return `${input} is String ? ${context.modelPrefix}${enumName}.fromString(${input}) : null`;
+      }
+      return `${context.modelPrefix}${enumName}.fromString(typeFromDynamic<String>(${input}, ""))`;
+    },
+    toJson(input) {
+      if (context.isOptional) {
+        return `${input}!.serialValue`;
+      }
+      if (schema.nullable) {
+        return `${input}?.serialValue`;
+      }
+      return `${input}.serialValue`;
+    },
+    toQueryString(input, target, key) {
+      if (context.isOptional) {
+        return `if (${input} != null) ${target}.add("${key}=\${${input}!.serialValue}")`;
+      }
+      if (schema.nullable) {
+        return `${target}.add("${key}=\${${input}?.serialValue}")`;
+      }
+      return `${target}.add("${key}=\${${input}.serialValue}")`;
+    },
+    content: ""
+  };
+  if (context.generatedTypes.includes(enumName)) {
+    return output;
   }
-  ${className} copyWith({
-    ${copyWithParamParts.join(",\n    ")},
-  }) {
-    return ${className}(
-      ${copyWithInitParts.join(",\n      ")},
-    );
+  output.content = `enum ${context.modelPrefix}${enumName} implements Comparable<${context.modelPrefix}${enumName}> {
+${enumValues.map((val) => `  ${val.name}("${val.serialValue}")`).join(",\n")};
+
+  const ${context.modelPrefix}${enumName}(this.serialValue);
+  final String serialValue;
+
+  factory ${context.modelPrefix}${enumName}.fromString(String input) {
+    for (final val in values) {
+      if (val.serialValue == input) {
+        return val;
+      }
+    }
+    return ${enumValues[0].name};
   }
+
+  @override
+  int compareTo(${enumName} other) => name.compareTo(other.name);
+}`;
+  context.generatedTypes.push(enumName);
+  return output;
 }
-${subContentParts.join("\n")}
 
-`;
-  if (additionalOptions.existingClassNames.includes(className)) {
-    content = "";
-  } else {
-    additionalOptions.existingClassNames.push(className);
-  }
-  const isNullable = def.nullable ?? additionalOptions?.isOptional;
-  const typeName = isNullable ? `${className}?` : className;
+function dartStringFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const typeName = isNullable ? `String?` : "String";
+  const defaultValue = isNullable ? "null" : '""';
   return {
     typeName,
-    fieldTemplate: fieldTemplateString(
-      typeName,
-      key,
-      def.metadata?.description,
-      def.metadata?.isDeprecated
-    ),
-    constructorTemplate: additionalOptions.isOptional ? `this.${key}` : `required this.${key}`,
-    fromJsonTemplate: (input) => isNullable ? `${input} is Map<String, dynamic> ? ${className}.fromJson(${input}) : null` : `${className}.fromJson(${input})`,
-    toJsonTemplate: (input) => `${input}${isNullable ? "?" : ""}.toJson()`,
-    content
+    isNullable,
+    defaultValue,
+    fromJson(input, _key) {
+      if (isNullable) {
+        return `nullableTypeFromDynamic<String>(${input})`;
+      }
+      return `typeFromDynamic<String>(${input}, "")`;
+    },
+    toJson(input, _target, _key) {
+      return input;
+    },
+    toQueryString(input, target, key) {
+      if (context.isOptional) {
+        return `if (${input} != null) ${target}.add("${key}=$${input}")`;
+      }
+      return `${target}.add("${key}=$${input}")`;
+    },
+    content: ""
   };
 }
-function dartDynamicFromAny(nodePath, def, additionalOptions) {
-  const jsonKey = nodePath.split(".").pop() ?? "";
-  const key = camelCaseWrapper(jsonKey);
+function dartBoolFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const typeName = isNullable ? "bool?" : "bool";
+  const defaultValue = isNullable ? "null" : "false";
   return {
-    typeName: "dynamic",
-    fieldTemplate: fieldTemplateString(
-      "dynamic",
-      key,
-      def.metadata?.description,
-      def.metadata?.isDeprecated
-    ),
-    constructorTemplate: additionalOptions.isOptional ? `this.${key}` : `required this.${key}`,
-    fromJsonTemplate: (input) => `${input}`,
-    toJsonTemplate: (input) => input,
+    typeName,
+    isNullable,
+    defaultValue,
+    fromJson(input, _key) {
+      if (isNullable) {
+        return `nullableTypeFromDynamic<bool>(${input})`;
+      }
+      return `typeFromDynamic<bool>(${input}, false)`;
+    },
+    toJson(input, _target, _key) {
+      return input;
+    },
+    toQueryString(input, target, key) {
+      if (context.isOptional) {
+        return `if (${input} != null) ${target}.add("${key}=$${input}")`;
+      }
+      return `${target}.add("${key}=$${input}")`;
+    },
     content: ""
   };
 }
-function fieldTemplateString(typeName, key, description, deprecated) {
-  let result = "";
-  if (deprecated) {
-    result += `@deprecated
-`;
-  }
-  if (description) {
-    const parts = description.split("\n");
-    for (const part of parts) {
-      result += `/// ${part}
-`;
-    }
-  }
-  result += `final ${typeName} ${key}`;
-  return result;
-}
-function dartArrayFromJtdSchema(nodePath, def, additionalOptions) {
-  const isNullable = additionalOptions.isOptional || (def.nullable ?? false);
-  const jsonKey = nodePath.split(".").pop() ?? "";
-  const key = camelCaseWrapper(jsonKey);
-  const subtype = dartTypeFromJtdSchema(`${nodePath}.Item`, def.elements, {
-    existingClassNames: additionalOptions.existingClassNames,
-    isOptional: false
-  });
-  const typeName = isNullable ? `List<${subtype.typeName}>?` : `List<${subtype.typeName}>`;
+function dartDateTimeFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const typeName = isNullable ? "DateTime?" : "DateTime";
+  const defaultValue = isNullable ? "null" : "DateTime.now()";
   return {
     typeName,
-    fieldTemplate: fieldTemplateString(
-      typeName,
-      key,
-      def.metadata?.description,
-      def.metadata?.isDeprecated
-    ),
-    constructorTemplate: additionalOptions.isOptional ? `this.${key}` : `required this.${key}`,
-    fromJsonTemplate: (input) => {
+    isNullable,
+    defaultValue,
+    fromJson(input, _key) {
       if (isNullable) {
-        return `${input} is List ? 
-                    // ignore: unnecessary_cast
-                    (${input} as List).map((item) => ${subtype.fromJsonTemplate(
-          "item"
-        )}).toList() as ${typeName} : null`;
+        return `nullableDateTimeFromDynamic(${input})`;
       }
-      return `${input} is List ? 
-                // ignore: unnecessary_cast
-                (${input} as List).map((item) => ${subtype.fromJsonTemplate(
-        "item"
-      )}).toList() as ${typeName} : <${subtype.typeName}>[]`;
+      return `dateTimeFromDynamic(${input}, DateTime.now())`;
     },
-    toJsonTemplate: (input) => {
-      return `${input}${isNullable ? "?" : ""}.map((item) => ${subtype.toJsonTemplate("item")}).toList()`;
+    toJson(input, _target, _key) {
+      if (context.isOptional) {
+        return `${input}!.toUtc().toIso8601String()`;
+      }
+      if (schema.nullable) {
+        return `${input}?.toUtc().toIso8601String()`;
+      }
+      return `${input}.toUtc().toIso8601String()`;
+    },
+    toQueryString(input, target, key) {
+      if (context.isOptional) {
+        return `if (${input} != null) ${target}.add("${key}=\${${input}!.toUtc().toIso8601String()}")`;
+      }
+      if (schema.nullable) {
+        return `${target}.add("${key}=\${${input}?.toUtc().toIso8601String()}")`;
+      }
+      return `${target}.add("${key}=\${${input}.toUtc().toIso8601String()}")`;
     },
-    content: subtype.content
+    content: ""
   };
 }
-function dartScalarFromJtdScalar(nodePath, def, additionalOptions) {
-  const isNullable = additionalOptions.isOptional || (def.nullable ?? false);
-  const jsonKey = nodePath.split(".").pop() ?? "";
-  const key = camelCaseWrapper(jsonKey);
-  const defaultInitializationTemplate = additionalOptions.isOptional ? `this.${key}` : `required this.${key}`;
-  const { description } = def.metadata ?? {};
-  const defaultToJsonTemplate = (input) => input;
-  switch (def.type) {
-    case "boolean":
+function dartDoubleFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const typeName = isNullable ? "double?" : "double";
+  const defaultValue = isNullable ? "null" : "0.0";
+  return {
+    typeName,
+    isNullable,
+    defaultValue,
+    fromJson(input, _key) {
       if (isNullable) {
-        return {
-          typeName: "bool?",
-          fieldTemplate: fieldTemplateString(
-            "bool?",
-            key,
-            description,
-            def.metadata?.isDeprecated
-          ),
-          constructorTemplate: defaultInitializationTemplate,
-          fromJsonTemplate: (input) => `nullableTypeFromDynamic<bool>(${input})`,
-          toJsonTemplate: defaultToJsonTemplate,
-          content: ""
-        };
+        return `nullableDoubleFromDynamic(${input})`;
       }
-      return {
-        typeName: "bool",
-        fieldTemplate: fieldTemplateString(
-          "bool",
-          key,
-          description,
-          def.metadata?.isDeprecated
-        ),
-        constructorTemplate: defaultInitializationTemplate,
-        fromJsonTemplate: (input) => `typeFromDynamic<bool>(${input}, false)`,
-        toJsonTemplate: defaultToJsonTemplate,
-        content: ""
-      };
-    case "float32":
-    case "float64":
-      if (isNullable) {
-        return {
-          typeName: "double?",
-          fieldTemplate: fieldTemplateString(
-            "double?",
-            key,
-            description,
-            def.metadata?.isDeprecated
-          ),
-          constructorTemplate: defaultInitializationTemplate,
-          fromJsonTemplate: (input) => `nullableDoubleFromDynamic(${input})`,
-          toJsonTemplate: defaultToJsonTemplate,
-          content: ""
-        };
+      return `doubleFromDynamic(${input}, 0.0)`;
+    },
+    toJson(input, _, __) {
+      return input;
+    },
+    toQueryString(input, target, key) {
+      if (context.isOptional) {
+        return `if (${input} != null) ${target}.add("${key}=$${input}")`;
       }
-      return {
-        typeName: "double",
-        fieldTemplate: fieldTemplateString(
-          "double",
-          key,
-          description,
-          def.metadata?.isDeprecated
-        ),
-        constructorTemplate: defaultInitializationTemplate,
-        fromJsonTemplate: (input) => `doubleFromDynamic(${input}, 0)`,
-        toJsonTemplate: defaultToJsonTemplate,
-        content: ""
-      };
-    case "int16":
-    case "int32":
-    case "int8":
-    case "uint16":
-    case "uint32":
-    case "uint8":
+      return `${target}.add("${key}=$${input}")`;
+    },
+    content: ""
+  };
+}
+function dartIntFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const typeName = isNullable ? "int?" : "int";
+  const defaultValue = isNullable ? "null" : "0";
+  return {
+    typeName,
+    isNullable,
+    defaultValue,
+    fromJson(input, _key) {
       if (isNullable) {
-        return {
-          typeName: "int?",
-          fieldTemplate: fieldTemplateString(
-            "int?",
-            key,
-            description,
-            def.metadata?.isDeprecated
-          ),
-          constructorTemplate: defaultInitializationTemplate,
-          fromJsonTemplate: (input) => `nullableIntFromDynamic(${input})`,
-          toJsonTemplate: defaultToJsonTemplate,
-          content: ""
-        };
+        return `nullableIntFromDynamic(${input})`;
       }
-      return {
-        typeName: "int",
-        fieldTemplate: fieldTemplateString(
-          `int`,
-          key,
-          description,
-          def.metadata?.isDeprecated
-        ),
-        constructorTemplate: defaultInitializationTemplate,
-        fromJsonTemplate: (input) => `intFromDynamic(${input}, 0)`,
-        toJsonTemplate: defaultToJsonTemplate,
-        content: ""
-      };
-    case "int64":
-    case "uint64":
-      if (isNullable) {
-        return {
-          typeName: "BigInt?",
-          fieldTemplate: fieldTemplateString(
-            `BigInt?`,
-            key,
-            description,
-            def.metadata?.isDeprecated
-          ),
-          constructorTemplate: defaultInitializationTemplate,
-          fromJsonTemplate: (input) => `nullableBigIntFromDynamic(${input})`,
-          toJsonTemplate: (input) => `${input}?.toString()`,
-          content: ""
-        };
+      return `intFromDynamic(${input}, 0)`;
+    },
+    toJson(input) {
+      return input;
+    },
+    toQueryString(input, target, key) {
+      if (context.isOptional) {
+        return `if (${input} != null) ${target}.add("${key}=$${input}")`;
       }
-      return {
-        typeName: "BigInt",
-        fieldTemplate: fieldTemplateString(
-          `BigInt`,
-          key,
-          description,
-          def.metadata?.isDeprecated
-        ),
-        constructorTemplate: defaultInitializationTemplate,
-        fromJsonTemplate: (input) => `bigIntFromDynamic(${input}, BigInt.zero)`,
-        toJsonTemplate: (input) => `${input}.toString()`,
-        content: ""
-      };
-    case "timestamp":
+      return `${target}.add("${key}=$${input}")`;
+    },
+    content: ""
+  };
+}
+function dartBigIntFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const typeName = isNullable ? "BigInt?" : "BigInt";
+  const defaultValue = isNullable ? "null" : "BigInt.zero";
+  return {
+    typeName,
+    isNullable,
+    defaultValue,
+    fromJson(input, _key) {
       if (isNullable) {
-        return {
-          typeName: "DateTime?",
-          fieldTemplate: fieldTemplateString(
-            "DateTime?",
-            key,
-            description,
-            def.metadata?.isDeprecated
-          ),
-          constructorTemplate: defaultInitializationTemplate,
-          fromJsonTemplate: (input) => `nullableDateTimeFromDynamic(${input})`,
-          toJsonTemplate: (input) => `${input}?.toUtc().toIso8601String()`,
-          content: ""
-        };
+        return `nullableBigIntFromDynamic(${input})`;
       }
-      return {
-        typeName: "DateTime",
-        fieldTemplate: fieldTemplateString(
-          "DateTime",
-          key,
-          description,
-          def.metadata?.isDeprecated
-        ),
-        constructorTemplate: defaultInitializationTemplate,
-        fromJsonTemplate: (input) => `dateTimeFromDynamic(
-      ${input},
-      DateTime.fromMillisecondsSinceEpoch(0),
-    )`,
-        toJsonTemplate: (input) => `${input}.toUtc().toIso8601String()`,
-        content: ""
-      };
-    case "string":
-      if (isNullable) {
-        return {
-          typeName: "String?",
-          fieldTemplate: fieldTemplateString(
-            "String?",
-            key,
-            description,
-            def.metadata?.isDeprecated
-          ),
-          constructorTemplate: defaultInitializationTemplate,
-          fromJsonTemplate: (input) => `nullableTypeFromDynamic<String>(${input})`,
-          toJsonTemplate: defaultToJsonTemplate,
-          content: ""
-        };
+      return `bigIntFromDynamic(${input}, BigInt.zero)`;
+    },
+    toJson(input, _target, _key) {
+      if (context.isOptional) {
+        return `${input}!.toString()`;
+      }
+      if (schema.nullable) {
+        return `${input}?.toString()`;
       }
-      return {
-        typeName: "String",
-        fieldTemplate: fieldTemplateString(
-          "String",
-          key,
-          description,
-          def.metadata?.isDeprecated
-        ),
-        constructorTemplate: defaultInitializationTemplate,
-        fromJsonTemplate: (input) => `typeFromDynamic<String>(${input}, "")`,
-        toJsonTemplate: defaultToJsonTemplate,
-        content: ""
-      };
+      return `${input}.toString()`;
+    },
+    toQueryString(input, target, key) {
+      if (context.isOptional) {
+        return `if (${input} != null) ${target}.add("${key}=$${input}")`;
+      }
+      return `${target}.add("${key}=$${input}")`;
+    },
+    content: ""
+  };
+}
+
+function dartRpcFromSchema(schema, context) {
+  switch (schema.transport) {
+    case "http":
+      return dartHttpRpcFromSchema(schema, context);
+    case "ws":
+      return dartWsRpcFromSchema(schema, context);
     default:
-      return {
-        typeName: "dynamic",
-        fieldTemplate: fieldTemplateString(
-          "dynamic",
-          key,
-          description,
-          def.metadata?.isDeprecated
-        ),
-        constructorTemplate: defaultInitializationTemplate,
-        fromJsonTemplate: (input) => input,
-        toJsonTemplate: defaultToJsonTemplate,
-        content: ""
-      };
+      console.warn(
+        `[WARNING] unsupported transport "${schema.transport}". Skipping ${context.instancePath}.`
+      );
+      return "";
   }
 }
-function dartEnumFromJtdSchema(nodePath, def, additionalOptions) {
-  const isNullable = additionalOptions.isOptional || (def.nullable ?? false);
-  const jsonKey = nodePath.split(".").pop() ?? "";
-  const key = camelCaseWrapper(jsonKey);
-  let className = def.metadata?.id ? codegenUtils.pascalCase(def.metadata.id) : void 0;
-  if (!className) {
-    className = codegenUtils.pascalCase(nodePath.split(".").join("_"));
+function dartHttpRpcFromSchema(schema, context) {
+  const functionName = getFunctionName(context.instancePath);
+  let responseType = "void";
+  let paramsType = "";
+  if (schema.response) {
+    responseType = `${context.modelPrefix}${validDartClassName(schema.response, context.modelPrefix)}`;
   }
-  const valNames = [];
-  const fieldParts = [];
-  for (const val of def.enum) {
-    valNames.push(`${camelCaseWrapper(val)}`);
-    fieldParts.push(`${camelCaseWrapper(val)}("${val}")`);
+  if (schema.params) {
+    paramsType = `${context.modelPrefix}${validDartClassName(schema.params, context.modelPrefix)}`;
   }
-  let content = `${getAnnotations(def.metadata)}enum ${className} implements Comparable<${className}> {
-  ${fieldParts.join(",\n  ")};
-  const ${className}(this.value);
-  final String value;
-
-  factory ${className}.fromJson(dynamic json) {
-    for(final v in values) {
-      if(v.value == json) {
-        return v;
-      }
-    }
-    return ${valNames[0]};
-  }
-
-  @override
-  compareTo(${className} other) => name.compareTo(other.name);
-}`;
-  if (additionalOptions.existingClassNames.includes(className)) {
-    content = "";
-  } else {
-    additionalOptions.existingClassNames.push(className);
+  if (schema.isEventStream) {
+    return `EventSource<${responseType}> ${functionName}(
+            ${paramsType ? `${paramsType} params, ` : ""} {
+            void Function(${responseType} data, EventSource<${responseType}> connection)? onMessage,
+            void Function(http.StreamedResponse response, EventSource<${responseType}> connection)? onOpen,
+            void Function(EventSource<${responseType}> connection)? onClose,
+            void Function(ArriError error, EventSource<${responseType}> connection)? onError,
+            Duration? retryDelay,
+            int? maxRetryCount,
+            String? lastEventId,
+        }) {
+            return parsedArriSseRequest(
+                "$_baseUrl${schema.path}",
+                method: HttpMethod.${schema.method.toLowerCase()},
+                httpClient: _httpClient,
+                headers: _headers,
+                clientVersion: _clientVersion,
+                retryDelay: retryDelay,
+                maxRetryCount: maxRetryCount,
+                lastEventId: lastEventId,
+                ${paramsType ? "params: params.toJson()," : ""}
+                parser: (body) ${schema.response ? `=> ${responseType}.fromJsonString(body)` : `{}`},
+                onMessage: onMessage,
+                onOpen: onOpen,
+                onClose: onClose,
+                onError: onError,
+            );
+        }`;
   }
-  return {
-    typeName: className,
-    fieldTemplate: fieldTemplateString(
-      isNullable ? `${className}?` : className,
-      key,
-      def.metadata?.description,
-      def.metadata?.isDeprecated
-    ),
-    constructorTemplate: additionalOptions.isOptional ? `this.${key}` : `required this.${key}`,
-    fromJsonTemplate: (input) => {
-      if (isNullable) {
-        return `${input} is String ? ${className}.fromJson(${input}) : null`;
-      }
-      return `${className}.fromJson(${input})`;
-    },
-    toJsonTemplate: (input) => `${input}${isNullable ? "?" : ""}.value`,
-    content
-  };
+  return `Future<${responseType}> ${functionName}(${paramsType ? `${paramsType} params` : ""}) async {
+        return parsedArriRequest(
+            "$_baseUrl${schema.path}",
+            method: HttpMethod.${schema.method.toLowerCase()},
+            httpClient: _httpClient,
+            headers: _headers,
+            clientVersion: _clientVersion,
+            ${paramsType ? "params: params.toJson()," : ""}
+            parser: (body) ${schema.response ? `=> ${responseType}.fromJsonString(body)` : "{}"},
+        );
+    }`;
 }
-function dartMapFromJtdSchema(nodePath, def, additionalOptions) {
-  const isNullable = additionalOptions.isOptional || (def.nullable ?? false);
-  const jsonKey = nodePath.split(".").pop() ?? "";
-  const key = camelCaseWrapper(jsonKey);
-  const innerType = dartTypeFromJtdSchema(`${nodePath}.Value`, def.values, {
-    existingClassNames: additionalOptions.existingClassNames,
-    isOptional: false
-  });
-  const typeName = `Map<String, ${innerType.typeName}>${isNullable ? "?" : ""}`;
-  return {
-    typeName: isNullable ? `Map<String, ${innerType.typeName}>?` : `Map<String, ${innerType.typeName}>`,
-    fieldTemplate: fieldTemplateString(
-      typeName,
-      key,
-      def.metadata?.description,
-      def.metadata?.isDeprecated
-    ),
-    constructorTemplate: additionalOptions.isOptional ? `this.${key}` : `required this.${key}`,
-    fromJsonTemplate: (input) => `${input} is Map<String, dynamic>
-          ? (${input} as Map<String, dynamic>).map(
-              (key, value) => MapEntry(key, ${innerType.fromJsonTemplate(
-      "value"
-    )}))
-          : <String, ${innerType.typeName}>{}`,
-    toJsonTemplate: (input) => `${input}${isNullable ? "?" : ""}.map((key, value) => MapEntry(key, ${innerType.toJsonTemplate(
-      "value"
-    )}))`,
-    content: innerType.content
-  };
+function getFunctionName(instancePath) {
+  const parts = instancePath.split(".");
+  return parts.pop() ?? "";
 }
-function dartSealedClassFromJtdSchema(nodePath, def, additionalOptions) {
-  const className = def.metadata?.id ? codegenUtils.pascalCase(def.metadata?.id) : codegenUtils.pascalCase(nodePath.split(".").join("_"));
-  const isNullable = additionalOptions.isOptional || (def.nullable ?? false);
-  const jsonKey = nodePath.split(".").pop() ?? "";
-  const key = camelCaseWrapper(jsonKey);
-  const discriminatorJsonKey = def.discriminator;
-  const discriminatorKey = camelCaseWrapper(def.discriminator);
-  const fromJsonCaseParts = [];
-  const childContentParts = [];
-  Object.keys(def.mapping).forEach((discKeyValue) => {
-    const childDef = def.mapping[discKeyValue];
-    if (!codegenUtils.isSchemaFormProperties(childDef)) {
-      return;
-    }
-    const child = dartClassFromJtdSchema(
-      `${nodePath}.${camelCaseWrapper(discKeyValue.toLowerCase())}`,
-      childDef,
-      {
-        parentId: className,
-        isOptional: false,
-        existingClassNames: additionalOptions.existingClassNames,
-        discriminatorOptions: {
-          discriminatorKey,
-          discriminatorValue: discKeyValue,
-          discriminatorParentClassName: className
-        }
+function dartWsRpcFromSchema(schema, context) {
+  const functionName = getFunctionName(context.instancePath);
+  let responseType;
+  let paramsType;
+  if (schema.response) {
+    responseType = `${context.modelPrefix}${validDartClassName(schema.response, context.modelPrefix)}`;
+  }
+  if (schema.params) {
+    paramsType = `${context.modelPrefix}${validDartClassName(schema.params, context.modelPrefix)}`;
+  }
+  return `Future<ArriWebsocketController<${responseType ?? "void"}, ${paramsType ?? "void"}>> ${functionName}() {
+        return arriWebsocketRequest(
+            "$_baseUrl${schema.path}",
+            headers: _headers,
+            clientVersion: _clientVersion,
+            parser: (msg) ${responseType ? `=> ${responseType}.fromJsonString(msg)` : "{}"},
+            serializer: (msg) ${paramsType ? "=> msg.toJsonString()" : '=> ""'},
+        );
+    }`;
+}
+function dartServiceFromSchema(schema, context) {
+  const rpcParts = [];
+  const subServices = [];
+  const subServiceParts = [];
+  const serviceName = getServiceName(
+    context.instancePath,
+    context.clientName
+  );
+  for (const key of Object.keys(schema)) {
+    const subSchema = schema[key];
+    if (codegenUtils.isServiceDefinition(subSchema)) {
+      const subSchemaResult = dartServiceFromSchema(subSchema, {
+        clientName: context.clientName,
+        modelPrefix: context.modelPrefix,
+        generatedTypes: context.generatedTypes,
+        instancePath: `${context.instancePath}.${key}`,
+        schemaPath: `${context.schemaPath}.${key}`
+      });
+      if (subSchemaResult) {
+        subServiceParts.push(subSchemaResult);
+        subServices.push({
+          key: validDartIdentifier(key),
+          name: getServiceName(
+            `${context.instancePath}.${key}`,
+            context.clientName
+          )
+        });
       }
-    );
-    fromJsonCaseParts.push(`case "${discKeyValue}":
-        return ${child.typeName}.fromJson(json);`);
-    childContentParts.push(child.content);
-  });
-  let content = "";
-  if (!additionalOptions.existingClassNames.includes(className)) {
-    content = `${getAnnotations(def.metadata)}sealed class ${className} {
-  final String ${discriminatorKey};
-  const ${className}({
-    required this.${discriminatorKey},
-  });
-  factory ${className}.fromJson(Map<String, dynamic> json) {
-    if(json["${discriminatorJsonKey}"] is! String) {
-      throw Exception(
-        "Unable to decode ${className}. Expected String from \\"${discriminatorJsonKey}\\". Received \${json["${discriminatorJsonKey}"]}}",
-      );
+      continue;
     }
-    switch (json["${discriminatorJsonKey}"]) {
-      ${fromJsonCaseParts.join("\n      ")}
+    if (codegenUtils.isRpcDefinition(subSchema)) {
+      const subSchemaResult = dartRpcFromSchema(subSchema, {
+        clientName: context.clientName,
+        modelPrefix: context.modelPrefix,
+        generatedTypes: context.generatedTypes,
+        instancePath: `${context.instancePath}.${key}`,
+        schemaPath: `${context.schemaPath}.${key}`
+      });
+      if (subSchemaResult) {
+        rpcParts.push(subSchemaResult);
+      }
+      continue;
     }
-    throw Exception(
-        "Unable to decode ${className}. \\"\${json["${discriminatorJsonKey}"]}\\" doesn't match any of the accepted discriminator values.",
+    console.warn(
+      `Unknown schema in procedures at "${context.instancePath}".`
     );
   }
-  Map<String, dynamic> toJson();
+  return `class ${serviceName}{
+  final http.Client? _httpClient;
+  final String _baseUrl;
+  final String _clientVersion = "${context.clientVersion ?? ""}";
+  late final FutureOr<Map<String, String>> Function()? _headers;
+  ${serviceName}({
+    http.Client? httpClient,
+    required String baseUrl,
+    FutureOr<Map<String, String>> Function()? headers,
+  }) : _httpClient = httpClient,
+       _baseUrl = baseUrl,
+       _headers = headers;
+
+  ${rpcParts.join("\n\n")}
+
+  ${subServices.map(
+    (service) => `  ${service.name} get ${service.key} => ${service.name}(
+          baseUrl: _baseUrl,
+          headers: _headers,
+          httpClient: _httpClient,
+        );`
+  ).join("\n\n")}
 }
-${childContentParts.join("\n")}`;
-    additionalOptions.existingClassNames.push(className);
-  }
-  const typeName = `${className}${isNullable ? "?" : ""}`;
+${subServiceParts.join("\n\n")}`;
+}
+function getServiceName(instancePath, clientName) {
+  return validDartClassName(
+    `${clientName}_${instancePath.split(".").join("_")}_Service`,
+    ""
+  );
+}
+
+function dartMapFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const innerType = dartTypeFromSchema(schema.values, {
+    clientName: context.clientName,
+    modelPrefix: context.modelPrefix,
+    generatedTypes: context.generatedTypes,
+    instancePath: `${context.instancePath}/[entry]`,
+    schemaPath: `${context.schemaPath}/values`
+  });
+  const typeName = isNullable ? `Map<String, ${innerType.typeName}>?` : `Map<String, ${innerType.typeName}>`;
+  const defaultValue = isNullable ? "null" : "{}";
   return {
     typeName,
-    fieldTemplate: fieldTemplateString(
-      typeName,
-      key,
-      def.metadata?.description,
-      def.metadata?.isDeprecated
-    ),
-    constructorTemplate: additionalOptions.isOptional ? `this.${key}` : `required this.${key}`,
-    fromJsonTemplate: (input) => {
+    isNullable,
+    defaultValue,
+    fromJson(input) {
       if (isNullable) {
-        return `${input} is Map<String, dynamic> ? ${className}.fromJson(${input}) : null`;
+        return `${input} is Map<String, dynamic>
+                    ? (${input} as Map<String, dynamic>).map(
+                        (_key_, _val_) => MapEntry(
+                          _key_,
+                          ${innerType.fromJson("_val_")},
+                        ),
+                      )
+                    : null`;
       }
-      return `${className}.fromJson(${input})`;
+      return `${input} is Map<String, dynamic>
+                ? (${input} as Map<String, dynamic>).map(
+                    (_key_, _val_) => MapEntry(
+                      _key_,
+                      ${innerType.fromJson("_val_")},
+                    ),
+                  )
+                : <String, ${innerType.typeName}>{}`;
     },
-    toJsonTemplate: (input) => {
-      if (isNullable) {
-        return `${input}?.toJson()`;
+    toJson(input) {
+      if (context.isOptional) {
+        return `${input}!.map((_key_, _val_) => MapEntry(_key_, ${innerType.toJson("_val_", "", "")},),)`;
       }
-      return `${input}.toJson()`;
+      if (schema.nullable) {
+        return `${input}?.map((_key_, _val_) => MapEntry(_key_, ${innerType.toJson("_val_", "", "")},),)`;
+      }
+      return `${input}.map((_key_, _val_) => MapEntry(_key_, ${innerType.toJson("_val_", "", "")},),)`;
+    },
+    toQueryString() {
+      return `print(
+        "[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
     },
-    content
+    content: innerType.content
   };
 }
-function dartRefFromJtdSchema(nodePath, def, additionalOptions) {
-  const jsonKey = nodePath.split(".").pop() ?? "";
-  const key = camelCaseWrapper(jsonKey);
-  const className = codegenUtils.pascalCase(def.ref, { normalize: true });
-  const isNullable = additionalOptions.isOptional || (def.nullable ?? false);
-  const typeName = `${className}${isNullable ? "?" : ""}`;
+
+function dartRefFromSchema(schema, context) {
+  const isNullable = outputIsNullable(schema, context);
+  const className = sanitizeIdentifier(
+    codegenUtils.pascalCase(schema.ref, { normalize: true })
+  );
+  const finalClassName = `${context.modelPrefix}${className}`;
+  const typeName = isNullable ? `${finalClassName}?` : finalClassName;
+  const defaultValue = isNullable ? `null` : `${finalClassName}.empty()`;
   return {
     typeName,
-    fieldTemplate: fieldTemplateString(
-      typeName,
-      key,
-      def.metadata?.description,
-      def.metadata?.isDeprecated
-    ),
-    constructorTemplate: additionalOptions.isOptional ? `this.${key}` : `required this.${key}`,
-    fromJsonTemplate(input) {
+    isNullable,
+    defaultValue,
+    fromJson(input) {
       if (isNullable) {
-        return `${input} is Map<String, dynamic> ? ${className}.fromJson(${input}) : null`;
+        return `${input} is Map<String, dynamic>
+                    ? ${finalClassName}.fromJson(${input})
+                    : null`;
       }
-      return `${className}.fromJson(${input})`;
+      return `${input} is Map<String, dynamic>
+                ? ${finalClassName}.fromJson(${input})
+                : ${finalClassName}.empty()`;
     },
-    toJsonTemplate(input) {
-      if (isNullable) {
+    toJson(input) {
+      if (context.isOptional) {
+        return `${input}!.toJson()`;
+      }
+      if (schema.nullable) {
         return `${input}?.toJson()`;
       }
       return `${input}.toJson()`;
     },
+    toQueryString() {
+      return `print(
+        "[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
     content: ""
   };
 }
 
-exports.DartClientGenerator = DartClientGenerator;
+const dartClientGenerator = codegenUtils.defineClientGeneratorPlugin(
+  (options) => {
+    return {
+      async generator(def) {
+        if (!options.outputFile) {
+          throw new Error(
+            'Missing "outputFile" cannot generate dart code'
+          );
+        }
+        try {
+          const result = createDartClient(def, options);
+          const destination = path__default.resolve(options.outputFile);
+          await fs__default.writeFile(destination, result);
+          if (options.format !== false) {
+            node_child_process.execSync(`dart format ${destination}`, {
+              stdio: "inherit"
+            });
+          }
+        } catch (err) {
+          console.error(err);
+        }
+      },
+      options
+    };
+  }
+);
+function createDartClient(def, options) {
+  const typeParts = [];
+  const context = {
+    clientName: options.clientName ?? "Client",
+    modelPrefix: options.modelPrefix ?? "",
+    generatedTypes: [],
+    instancePath: "",
+    schemaPath: "",
+    clientVersion: def.info?.version
+  };
+  const services = codegenUtils.unflattenProcedures(def.procedures);
+  const subServices = [];
+  const subServiceParts = [];
+  const rpcParts = [];
+  for (const key of Object.keys(services)) {
+    const subSchema = services[key];
+    if (codegenUtils.isServiceDefinition(subSchema)) {
+      const service = dartServiceFromSchema(subSchema, {
+        clientName: context.clientName,
+        modelPrefix: context.modelPrefix,
+        generatedTypes: context.generatedTypes,
+        instancePath: key,
+        schemaPath: `procedures.${key}`,
+        clientVersion: context.clientVersion
+      });
+      if (service) {
+        subServiceParts.push(service);
+        subServices.push({
+          key: validDartIdentifier(key),
+          name: getServiceName(key, context.clientName)
+        });
+      }
+      continue;
+    }
+    if (codegenUtils.isRpcDefinition(subSchema)) {
+      const rpc = dartRpcFromSchema(subSchema, {
+        clientName: context.clientName,
+        modelPrefix: context.modelPrefix,
+        generatedTypes: context.generatedTypes,
+        instancePath: key,
+        schemaPath: `procedures.${key}`
+      });
+      if (rpc) {
+        rpcParts.push(rpc);
+      }
+      continue;
+    }
+    console.warn(`Unknown schema in procedures at "${key}"`);
+  }
+  for (const key of Object.keys(def.definitions)) {
+    const subDef = def.definitions[key];
+    const result = dartTypeFromSchema(subDef, {
+      clientName: context.clientName,
+      modelPrefix: context.modelPrefix,
+      generatedTypes: context.generatedTypes,
+      instancePath: `/${key}`,
+      schemaPath: `/${key}`
+    });
+    if (result.content) {
+      typeParts.push(result.content);
+    }
+  }
+  if (rpcParts.length === 0 && subServiceParts.length === 0) {
+    const heading = `// this file was autogenerated by arri
+// ignore_for_file: type=lint, unused_field, unnecessary_cast
+import 'dart:convert';
+import 'package:arri_client/arri_client.dart';`;
+    return `${heading}
+
+${typeParts.join("\n\n")}`;
+  }
+  const clientName = validDartClassName(context.clientName, "");
+  return `// this file was autogenerated by arri
+// ignore_for_file: type=lint, unused_field, unnecessary_cast
+import 'dart:async';
+import 'dart:convert';
+import 'package:arri_client/arri_client.dart';
+import 'package:http/http.dart' as http;
+    
+class ${clientName} {
+  final http.Client? _httpClient;
+  final String _baseUrl;
+  final String _clientVersion = "${context.clientVersion ?? ""}";
+  late final FutureOr<Map<String, String>> Function()? _headers;
+  ${clientName}({
+    http.Client? httpClient,
+    required String baseUrl,
+    FutureOr<Map<String, String>> Function()? headers,
+  }) : _httpClient = httpClient,
+       _baseUrl = baseUrl,
+       _headers = headers;
+  
+  ${rpcParts.join("\n\n")}
+
+${subServices.map(
+    (service) => `  ${service.name} get ${service.key} => ${service.name}(
+          baseUrl: _baseUrl,
+          headers: _headers,
+          httpClient: _httpClient,
+        );`
+  ).join("\n\n")}
+}
+
+${subServiceParts.join("\n\n")}
+
+${typeParts.join("\n\n")}`;
+}
+function dartTypeFromSchema(schema, context) {
+  if (codegenUtils.isSchemaFormType(schema)) {
+    switch (schema.type) {
+      case "string":
+        return dartStringFromSchema(schema, context);
+      case "boolean":
+        return dartBoolFromSchema(schema, context);
+      case "timestamp":
+        return dartDateTimeFromSchema(schema, context);
+      case "float32":
+      case "float64":
+        return dartDoubleFromSchema(schema, context);
+      case "int8":
+      case "uint8":
+      case "int16":
+      case "uint16":
+      case "int32":
+      case "uint32":
+        return dartIntFromSchema(schema, context);
+      case "int64":
+      case "uint64":
+        return dartBigIntFromSchema(schema, context);
+      default:
+        schema.type;
+        throw new Error(`Unhandled schema.type ${schema.type}`);
+    }
+  }
+  if (codegenUtils.isSchemaFormEnum(schema)) {
+    return dartEnumFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormProperties(schema)) {
+    return dartClassFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormElements(schema)) {
+    return dartListFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormValues(schema)) {
+    return dartMapFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormDiscriminator(schema)) {
+    return dartSealedClassFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormRef(schema)) {
+    return dartRefFromSchema(schema, context);
+  }
+  return dartAnyFromSchema(schema, context);
+}
+
 exports.createDartClient = createDartClient;
-exports.dartClassFromJtdSchema = dartClassFromJtdSchema;
 exports.dartClientGenerator = dartClientGenerator;
-exports.dartHttpRpcFromSchema = dartHttpRpcFromSchema;
-exports.dartRpcFromDefinition = dartRpcFromDefinition;
-exports.dartServiceFromDefinition = dartServiceFromDefinition;
-exports.dartTypeFromJtdSchema = dartTypeFromJtdSchema;
-exports.dartWsRpcFromSchema = dartWsRpcFromSchema;
-exports.getAnnotations = getAnnotations;
+exports.dartTypeFromSchema = dartTypeFromSchema;