@arrirpc/codegen-ts 0.55.0 → 0.57.2

package/dist/index.mjs

@@ -1,316 +1,29 @@
-import { defineGeneratorPlugin, pascalCase, unflattenProcedures, isRpcDefinition, isServiceDefinition, isSchemaFormProperties, isSchemaFormDiscriminator, isSchemaFormType, isSchemaFormEnum, isSchemaFormElements, isSchemaFormValues, isSchemaFormRef, camelCase } from '@arrirpc/codegen-utils';
-import { getSchemaParsingCode, getSchemaSerializationCode } from '@arrirpc/schema';
+import { stringStartsWithNumber, removeDisallowedChars, pascalCase, camelCase, isServiceDefinition, isRpcDefinition, defineGeneratorPlugin, unflattenProcedures, isSchemaFormType, isSchemaFormEnum, isSchemaFormProperties, isSchemaFormElements, isSchemaFormValues, isSchemaFormDiscriminator, isSchemaFormRef } from '@arrirpc/codegen-utils';
 import { writeFileSync } from 'fs';
 import prettier from 'prettier';
 
-const typescriptClientGenerator = defineGeneratorPlugin(
-  (options) => ({
-    generator: async (def) => {
-      if (!options.clientName) {
-        throw new Error("Name is requires");
-      }
-      if (!options.outputFile) {
-        throw new Error("No output file specified");
-      }
-      if (Object.keys(def.procedures).length <= 0) {
-        console.warn(
-          `No procedures defined in AppDefinition. Only data models will be outputted.`
-        );
-      }
-      const result = await createTypescriptClient(def, options);
-      writeFileSync(options.outputFile, result);
-    },
-    options
-  })
-);
-async function createTypescriptClient(def, options) {
-  const clientName = pascalCase(options.clientName);
-  const services = unflattenProcedures(def.procedures);
-  const serviceFieldParts = [];
-  const serviceInitializationParts = [];
-  const procedureParts = [];
-  const subContentParts = [];
-  const existingTypeNames = [];
-  const rpcOptions = {
-    ...options,
-    versionNumber: def.info?.version ?? "",
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    typesNeedingParser: Object.keys(def.definitions),
-    hasSseProcedures: false,
-    hasWsProcedures: false
-  };
-  Object.keys(services).forEach((key) => {
-    const item = services[key];
-    if (isRpcDefinition(item)) {
-      const rpc = tsRpcFromDefinition(key, item, rpcOptions);
-      if (rpc) {
-        procedureParts.push(rpc);
-      }
-      return;
-    }
-    if (isServiceDefinition(item)) {
-      const serviceName = pascalCase(`${clientName}_${key}`);
-      const service = tsServiceFromDefinition(
-        serviceName,
-        item,
-        rpcOptions
-      );
-      serviceFieldParts.push(`${key}: ${serviceName}Service;`);
-      serviceInitializationParts.push(
-        `this.${key} = new ${serviceName}Service(options);`
-      );
-      subContentParts.push(service);
-    }
-  });
-  for (const key of rpcOptions.typesNeedingParser) {
-    const schema = def.definitions[key];
-    if (isSchemaFormProperties(schema) || isSchemaFormDiscriminator(schema)) {
-      const type = tsTypeFromJtdSchema(key, schema, rpcOptions, {
-        isOptional: false,
-        existingTypeNames
-      });
-      subContentParts.push(type.content);
-    }
-  }
-  const importParts = ["arriRequest"];
-  if (rpcOptions.hasSseProcedures) {
-    importParts.push("arriSseRequest");
-    importParts.push("type SseOptions");
-    importParts.push("type EventSourceController");
-  }
-  if (rpcOptions.hasWsProcedures) {
-    importParts.push("arriWsRequest");
-    importParts.push("type WsOptions");
-  }
-  if (procedureParts.length === 0 && serviceFieldParts.length === 0) {
-    const result2 = `/* eslint-disable */
-// @ts-nocheck
-// this file was autogenerated by arri-codegen-ts
-
-${subContentParts.join("\n")}`;
-    return prettier.format(result2, {
-      parser: "typescript",
-      ...options.prettierOptions
-    });
-  }
-  const result = `/* eslint-disable */
-// @ts-nocheck
-// this file was autogenerated by arri-codegen-ts
-import { ${importParts.join(", ")} } from '@arrirpc/client';
-    
-interface ${clientName}Options {
-    baseUrl?: string;
-    headers?: Record<string, string | undefined> | (() => Record<string, string | undefined> | Promise<Record<string, string | undefined>>);
-}
-
-export class ${clientName} {
-    private readonly baseUrl: string;
-    private readonly headers: Record<string, string | undefined> | (() => Record<string, string | undefined> | Promise<Record<string, string | undefined>>)
-    private readonly clientVersion = '${rpcOptions.versionNumber}';
-    ${serviceFieldParts.join("\n    ")}
-
-    constructor(options: ${clientName}Options = {}) {
-        this.baseUrl = options.baseUrl ?? "";
-        this.headers = options.headers ?? {};
-        ${serviceInitializationParts.join(";\n        ")}
-    }
-    ${procedureParts.join("\n    ")}
-}
-
-${subContentParts.join("\n")}
-`;
-  return await prettier.format(result, {
-    parser: "typescript",
-    ...options.prettierOptions
-  });
-}
-function tsRpcFromDefinition(key, schema, options) {
-  if (schema.transport === "http") {
-    return tsHttpRpcFromDefinition(key, schema, options);
-  }
-  if (schema.transport === "ws") {
-    return tsWsRpcFromDefinition(key, schema, options);
-  }
-  console.warn(
-    `[codegen-ts] Unsupported transport "${schema.transport}". Ignoring rpc.`
-  );
-  return "";
-}
-function tsHttpRpcFromDefinition(key, schema, options) {
-  const paramName = pascalCase(schema.params ?? "");
-  const responseName = pascalCase(schema.response ?? "");
-  const paramsInput = schema.params ? `params: ${paramName}` : "";
-  const hasInput = paramName.length > 0;
-  const hasOutput = responseName.length > 0;
-  let serializerPart = `(_) => {}`;
-  let parserPart = `(_) => {}`;
-  if (hasInput) {
-    serializerPart = `$$${paramName}.serialize`;
-  }
-  if (hasOutput) {
-    parserPart = `$$${responseName}.parse`;
-  }
-  const paramsOutput = hasInput ? `params` : `params: undefined`;
-  if (schema.isEventStream) {
-    options.hasSseProcedures = true;
-    return `${getJsDocComment({ isDeprecated: schema.isDeprecated, description: schema.description })}${key}(${paramsInput.length ? `${paramsInput}, ` : ""}options: SseOptions<${schema.response ?? "undefined"}>): EventSourceController {
-            return arriSseRequest<${schema.response ?? "undefined"}, ${schema.params ?? "undefined"}>({
-                url: \`\${this.baseUrl}${schema.path}\`,
-                method: "${schema.method}",
-                headers: this.headers,
-                ${paramsOutput},
-                parser: ${parserPart},
-                serializer: ${serializerPart},
-                clientVersion: this.clientVersion,
-            }, options);
-        }`;
-  }
-  return `${getJsDocComment({ isDeprecated: schema.isDeprecated, description: schema.description })}${key}(${paramsInput}) {
-        return arriRequest<${schema.response ?? "undefined"}, ${schema.params ?? "undefined"}>({
-            url: \`\${this.baseUrl}${schema.path}\`,
-            method: "${schema.method}",
-            headers: this.headers,
-            ${paramsOutput},
-            parser: ${parserPart},
-            serializer: ${serializerPart},
-            clientVersion: this.clientVersion,
-        });
-    }`;
-}
-function tsWsRpcFromDefinition(key, schema, options) {
-  options.hasWsProcedures = true;
-  const paramName = schema.params ? pascalCase(schema.params) : "undefined";
-  const responseName = schema.response ? pascalCase(schema.response) : "undefined";
-  const hasInput = paramName.length > 0 && paramName !== "undefined";
-  const hasOutput = responseName.length > 0 && paramName !== "undefined";
-  let serializerPart = `(_) => {}`;
-  let parserPart = `(_) => {}`;
-  if (hasInput) {
-    serializerPart = `$$${paramName}.serialize`;
-  }
-  if (hasOutput) {
-    parserPart = `$$${responseName}.parse`;
-  }
-  return `${getJsDocComment(schema)}${key}(options: WsOptions<${responseName}> = {}) {
-        return arriWsRequest<${paramName}, ${responseName}>({
-            url: \`\${this.baseUrl}${schema.path}\`,
-            headers: this.headers,
-            parser: ${parserPart},
-            serializer: ${serializerPart},
-            onOpen: options.onOpen,
-            onClose: options.onClose,
-            onError: options.onError,
-            onConnectionError: options.onConnectionError,
-            onMessage: options.onMessage,
-            clientVersion: this.clientVersion,
-        })
-    }`;
-}
-function tsServiceFromDefinition(name, schema, options) {
-  const serviceFieldParts = [];
-  const serviceConstructorParts = [];
-  const subServiceContent = [];
-  const rpcContent = [];
-  Object.keys(schema).forEach((key) => {
-    const def = schema[key];
-    if (isRpcDefinition(def)) {
-      const rpc = tsRpcFromDefinition(key, def, options);
-      if (rpc) {
-        rpcContent.push(rpc);
-      }
-      return;
-    }
-    if (isServiceDefinition(def)) {
-      const serviceName = pascalCase(`${name}_${key}`);
-      const service = tsServiceFromDefinition(serviceName, def, options);
-      serviceFieldParts.push(`${key}: ${serviceName}Service;`);
-      serviceConstructorParts.push(
-        `this.${key} = new ${serviceName}Service(options);`
-      );
-      subServiceContent.push(service);
-    }
-  });
-  return `export class ${name}Service {
-        private readonly baseUrl: string;
-        private readonly headers: Record<string, string | undefined> | (() => Record<string, string | undefined> | Promise<Record<string, string | undefined>>);
-        private readonly clientVersion = '${options.versionNumber}';
-        ${serviceFieldParts.join("\n    ")}
-
-        constructor(options: ${pascalCase(
-    `${options.clientName}_Options`
-  )} = {}) {
-            this.baseUrl = options.baseUrl ?? '';
-            this.headers = options.headers ?? {};
-            ${serviceConstructorParts.join("\n        ")}
-        }
-        ${rpcContent.join("\n    ")}
-    }
-    ${subServiceContent.join("\n")}`;
-}
-function tsTypeFromJtdSchema(nodePath, def, options, additionalOptions) {
-  if (additionalOptions.logDef) {
-    console.log(def);
-  }
-  if (isSchemaFormType(def)) {
-    return tsScalarFromJtdSchema(nodePath, def, options, additionalOptions);
-  }
-  if (isSchemaFormProperties(def)) {
-    return tsObjectFromJtdSchema(nodePath, def, options, additionalOptions);
-  }
-  if (isSchemaFormEnum(def)) {
-    return tsEnumFromJtdSchema(nodePath, def, options, additionalOptions);
-  }
-  if (isSchemaFormElements(def)) {
-    return tsArrayFromJtdSchema(nodePath, def, options, additionalOptions);
-  }
-  if (isSchemaFormDiscriminator(def)) {
-    return tsDiscriminatedUnionFromJtdSchema(
-      nodePath,
-      def,
-      options,
-      additionalOptions
-    );
-  }
-  if (isSchemaFormValues(def)) {
-    return tsRecordFromJtdSchema(nodePath, def, options, additionalOptions);
-  }
-  if (isSchemaFormRef(def)) {
-    return tsRefFromJtdSchema(nodePath, def, options, additionalOptions);
-  }
-  return tsAnyFromJtdSchema(nodePath, def, options, additionalOptions);
-}
-function maybeOptionalKey(keyName, isOptional = false) {
-  if (isOptional) {
-    return `${keyName}?`;
-  }
-  return keyName;
-}
-function maybeNullType(typeName, isNullable = false) {
-  if (isNullable) {
-    return `${typeName} | null`;
-  }
-  return typeName;
-}
-function tsAnyFromJtdSchema(nodePath, def, options, additionalOptions) {
-  const key = nodePath.split(".").pop() ?? "";
-  const isNullable = def.nullable ?? false;
-  const isOptional = additionalOptions.isOptional;
+function tsAnyFromSchema(schema, context) {
+  const typeName = "any";
+  const defaultValue = schema.nullable ? "null" : "undefined";
   return {
-    tsType: "any",
-    schema: def,
-    fieldTemplate: `${maybeOptionalKey(key, isOptional)}: ${maybeNullType(
-      "any",
-      isNullable
-    )}`,
-    fromJsonTemplate(input) {
-      return input;
-    },
-    toJsonTemplate(input) {
-      return `JSON.stringify(${input})`;
+    typeName,
+    defaultValue,
+    validationTemplate(_) {
+      return "true";
+    },
+    fromJsonTemplate(input, target) {
+      return `${target} = ${input}`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target} += JSON.stringify(${input})`;
+    },
+    toQueryStringTemplate(_input, _target, _key) {
+      return `console.warn("[WARNING] Cannot serialize any's to query string. Skipping property at ${context.instancePath}.")`;
     },
     content: ""
   };
 }
+
 function getJsDocComment(metadata) {
   const descriptionParts = [];
   if (metadata?.description?.length) {
@@ -330,507 +43,1169 @@ ${descriptionParts.join("\n")}
 */
 `;
 }
-function tsScalarFromJtdSchema(nodePath, def, options, additionalOptions) {
-  const key = nodePath.split(".").pop() ?? "";
-  const isNullable = def.nullable ?? false;
-  const isOptional = additionalOptions.isOptional;
-  switch (def.type) {
-    case "boolean":
-      return {
-        tsType: "boolean",
-        schema: def,
-        fieldTemplate: `${getJsDocComment(def.metadata)}${maybeOptionalKey(
-          key,
-          isOptional
-        )}: ${maybeNullType("boolean", isNullable)}`,
-        fromJsonTemplate(input) {
-          if (isOptional) {
-            return `typeof ${input} === 'boolean' ? ${input} : undefined`;
-          }
-          if (isNullable) {
-            return `typeof ${input} === 'boolean' ? ${input} : null`;
-          }
-          return `typeof ${input} === 'boolean' ? ${input} : false`;
-        },
-        toJsonTemplate(input) {
-          if (isNullable) {
-            return `typeof ${input} === 'boolean' ? ${input} : null`;
-          }
-          return `typeof ${input} === 'boolean' ? ${input} : false`;
-        },
-        content: ""
-      };
-    case "string":
-      return {
-        tsType: "string",
-        schema: def,
-        fieldTemplate: `${getJsDocComment(def.metadata)}${maybeOptionalKey(
-          key,
-          isOptional
-        )}: ${maybeNullType("string", isNullable)}`,
-        fromJsonTemplate(input) {
-          if (isOptional) {
-            return `typeof ${input} === 'string' ? ${input} : undefined`;
-          }
-          if (isNullable) {
-            return `typeof ${input} === 'string' ? ${input} : null`;
-          }
-          return `typeof ${input} === 'string' ? ${input} : ''`;
-        },
-        toJsonTemplate(input) {
-          if (isNullable) {
-            return `typeof ${input} === 'string' ? \`"${input}"\` : null`;
-          }
-          return `typeof ${input} === 'string' ? \`"${input}"\` : ""`;
-        },
-        content: ""
-      };
-    case "timestamp":
-      return {
-        tsType: "Date",
-        schema: def,
-        fieldTemplate: `${getJsDocComment(def.metadata)}${maybeOptionalKey(
-          key,
-          isOptional
-        )}: ${maybeNullType("Date", isNullable)}`,
-        fromJsonTemplate(input) {
-          if (isOptional) {
-            return `typeof ${input} === 'string' ? new Date(${input}) : undefined`;
-          }
-          if (isNullable) {
-            return `typeof ${input} === 'string' ? new Date(${input}) : null`;
-          }
-          return `typeof ${input} === 'string' ? new Date(${input}) : new Date(0)`;
-        },
-        toJsonTemplate(input) {
-          if (isOptional || isNullable) {
-            return `typeof ${input} === 'object' && ${input} instanceof Date ? "${input}.toISOString()" : null`;
-          }
-          return `"${input}.toISOString()"`;
-        },
-        content: ""
-      };
-    case "float32":
-    case "float64":
-    case "int8":
-    case "int16":
-    case "int32":
-    case "uint8":
-    case "uint16":
-    case "uint32":
-      return {
-        tsType: "number",
-        schema: def,
-        fieldTemplate: `${getJsDocComment(def.metadata)}${maybeOptionalKey(
-          key,
-          isOptional
-        )}: ${maybeNullType("number", isNullable)}`,
-        fromJsonTemplate(input) {
-          if (isOptional) {
-            return `typeof ${input} === 'number' ? ${input} : undefined`;
-          }
-          if (isNullable) {
-            return `typeof ${input} === 'number' ? ${input} : null`;
-          }
-          return `typeof ${input} === 'number' ? ${input} : 0`;
-        },
-        toJsonTemplate(input) {
-          return `JSON.stringify(${input})`;
-        },
-        content: ""
-      };
-    case "int64":
-    case "uint64":
-      return {
-        tsType: "bigint",
-        schema: def,
-        fieldTemplate: `${getJsDocComment(def.metadata)}${maybeOptionalKey(
-          key,
-          isOptional
-        )}: ${maybeNullType("bigint", isNullable)}`,
-        fromJsonTemplate(input) {
-          if (isOptional) {
-            return `typeof ${input} === 'string' ? BigInt(${input}) : undefined`;
-          }
-          if (isNullable) {
-            return `typeof ${input} === 'string' ? BigInt(${input}) : null`;
-          }
-          return `typeof ${input} === 'string' ? BigInt(${input}) : BigInt("0")`;
-        },
-        toJsonTemplate(input) {
-          if (isOptional || isNullable) {
-            return `${input}?.toString()`;
-          }
-          return `${input}.toString()`;
-        },
-        content: ""
-      };
-    default:
-      def.type;
-      throw new Error(`Invalid type in SchemaFormType`);
+const illegalChars = "!#^&*()-+=?/][{}|\\~`'\"";
+function validVarName(name) {
+  if (stringStartsWithNumber(name)) {
+    return `_${removeDisallowedChars(name, illegalChars)}`;
   }
+  return removeDisallowedChars(name, illegalChars);
 }
-function getTypeName(nodePath, def) {
-  if (def.metadata?.id) {
-    return pascalCase(def.metadata.id);
+function getTsTypeName(schema, context) {
+  if (schema.metadata?.id) {
+    const name2 = pascalCase(schema.metadata.id, { normalize: true });
+    return validVarName(name2);
   }
-  return pascalCase(nodePath.split(".").join("_"));
+  if (context.discriminatorParent && context.discriminatorValue) {
+    const name2 = pascalCase(
+      `${context.discriminatorParent}_${context.discriminatorValue}`,
+      { normalize: true }
+    );
+    return validVarName(name2);
+  }
+  const name = pascalCase(context.instancePath.split("/").join("_"), {
+    normalize: true
+  });
+  return validVarName(name);
+}
+
+function tsArrayFromSchema(schema, context) {
+  const innerType = tsTypeFromSchema(schema.elements, {
+    clientName: context.clientName,
+    typePrefix: context.typePrefix,
+    generatedTypes: context.generatedTypes,
+    instancePath: `${context.instancePath}/[element]`,
+    schemaPath: `${context.schemaPath}/elements`,
+    discriminatorParent: "",
+    discriminatorKey: "",
+    discriminatorValue: "",
+    versionNumber: context.versionNumber,
+    usedFeatures: context.usedFeatures
+  });
+  const typeName = `(${innerType.typeName})[]`;
+  const defaultValue = schema.nullable ? "null" : "[]";
+  return {
+    typeName: schema.nullable ? `${typeName} | null` : typeName,
+    defaultValue,
+    validationTemplate(input) {
+      const mainPart = `Array.isArray(${input}) 
+                && ${input}.every(
+                    (_element) => ${innerType.validationTemplate("_element")}
+            )`;
+      if (schema.nullable) {
+        return `((${mainPart}) || 
+                ${input} === null)`;
+      }
+      return mainPart;
+    },
+    fromJsonTemplate(input, target) {
+      return `if (Array.isArray(${input})) {
+                ${target} = [];
+                for (const ${target}El of ${input}) {
+                    let ${target}ElValue: ${innerType.typeName};
+                    ${innerType.fromJsonTemplate(`${target}El`, `${target}ElValue`)}
+                    ${target}.push(${target}ElValue);
+                }
+            } else {
+                ${target} = ${defaultValue};
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      const elVar = `_${camelCase(validVarName(input.split(".").join("_")), { normalize: true })}El`;
+      const elKeyVar = `${elVar}Key`;
+      if (schema.nullable) {
+        return `if (${input} !== null) {
+                    ${target} += '[';
+                    for (let i = 0; i < ${input}.length; i++) {
+                        if (i !== 0) ${target} += ',';
+                        const ${elVar} = ${input}[i];
+                        ${innerType.toJsonTemplate(elVar, target, elKeyVar)}
+                    }
+                    ${target} += ']';
+                } else {
+                    ${target} += 'null'; 
+                }`;
+      }
+      return `${target} += '[';
+            for (let i = 0; i < ${input}.length; i++) {
+                if (i !== 0) ${target} += ',';
+                const ${elVar} = ${input}[i];
+                ${innerType.toJsonTemplate(elVar, target, elKeyVar)}
+            }
+            ${target} += ']';`;
+    },
+    toQueryStringTemplate(_input, _target, _key) {
+      return `console.warn('[WARNING] Cannot serialize arrays to query string. Skipping property at ${context.instancePath}.')`;
+    },
+    content: innerType.content
+  };
 }
-function tsObjectFromJtdSchema(nodePath, def, options, additionalOptions) {
-  const typeName = getTypeName(nodePath, def);
-  const key = nodePath.split(".").pop() ?? "";
-  const fieldNames = [];
+
+function tsObjectFromSchema(schema, context) {
+  const typeName = getTsTypeName(schema, context);
+  const prefixedTypeName = `${context.typePrefix}${typeName}`;
+  const defaultValue = schema.nullable ? "null" : `$$${prefixedTypeName}.new()`;
+  const result = {
+    typeName: schema.nullable ? `${prefixedTypeName} | null` : prefixedTypeName,
+    defaultValue,
+    validationTemplate(input) {
+      if (schema.nullable) {
+        return `($$${prefixedTypeName}.validate(${input}) || ${input} === null)`;
+      }
+      return `$$${prefixedTypeName}.validate(${input})`;
+    },
+    fromJsonTemplate(input, target) {
+      return `if (isObject(${input})) {
+                ${target} = $$${prefixedTypeName}.fromJson(${input});
+            } else {
+                ${target} = ${defaultValue}; 
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      if (schema.nullable) {
+        return `if (${input} !== null) {
+                    ${target} += $$${prefixedTypeName}.toJsonString(${input}); 
+                } else {
+                    ${target} += 'null';
+                }`;
+      }
+      return `${target} += $$${prefixedTypeName}.toJsonString(${input});`;
+    },
+    toQueryStringTemplate(_input, _target) {
+      return `console.warn("[WARNING] Cannot serialize nested objects to query string. Skipping property at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+  if (context.generatedTypes.includes(typeName)) {
+    return result;
+  }
+  const newParts = [];
   const fieldParts = [];
+  const fromJsonParts = [];
+  const constructionParts = [];
+  const toJsonParts = [];
+  const toQueryParts = [];
+  const validationParts = ["isObject(input)"];
   const subContentParts = [];
-  const parserParts = [];
-  if (additionalOptions.discriminatorKey && additionalOptions.discriminatorKeyValue) {
-    parserParts.push(
-      `${additionalOptions.discriminatorKey}: '${additionalOptions.discriminatorKeyValue}'`
+  let hasKey = false;
+  if (context.discriminatorParent && context.discriminatorValue && context.discriminatorKey) {
+    hasKey = true;
+    const key = validVarName(
+      camelCase(context.discriminatorKey, { normalize: true })
     );
-    fieldParts.push(
-      `${additionalOptions.discriminatorKey}: "${additionalOptions.discriminatorKeyValue}"`
+    fieldParts.push(`${key}: "${context.discriminatorValue}",`);
+    fromJsonParts.push(`const _${key} = "${context.discriminatorValue}"`);
+    toJsonParts.push(`json += '"${key}":"${context.discriminatorValue}"'`);
+    toQueryParts.push(
+      `queryParts.push('${context.discriminatorKey}=${context.discriminatorValue}');`
     );
-    fieldNames.push(additionalOptions.discriminatorKey);
+    validationParts.push(
+      `input.${key} === '${context.discriminatorValue}'`
+    );
+    newParts.push(`${key}: "${context.discriminatorValue}",`);
+    constructionParts.push(`${key}: _${key},`);
   }
-  if (def.properties) {
-    for (const propKey of Object.keys(def.properties)) {
-      const propSchema = def.properties[propKey];
-      const type = tsTypeFromJtdSchema(
-        `${nodePath}.${propKey}`,
-        propSchema,
-        options,
-        {
-          isOptional: false,
-          existingTypeNames: additionalOptions.existingTypeNames
-        }
-      );
-      parserParts.push(
-        `${propKey}: ${type.fromJsonTemplate(`input.${propKey}`)}`
-      );
-      fieldParts.push(type.fieldTemplate);
-      fieldNames.push(propKey);
-      if (type.content) {
-        subContentParts.push(type.content);
-      }
+  for (const key of Object.keys(schema.properties)) {
+    const subSchema = schema.properties[key];
+    const prop = tsTypeFromSchema(subSchema, {
+      clientName: context.clientName,
+      typePrefix: context.typePrefix,
+      generatedTypes: context.generatedTypes,
+      instancePath: `/${typeName}/${key}`,
+      schemaPath: `/${typeName}/properties/${key}`,
+      discriminatorParent: "",
+      discriminatorKey: "",
+      discriminatorValue: "",
+      versionNumber: context.versionNumber,
+      usedFeatures: context.usedFeatures
+    });
+    if (prop.content)
+      subContentParts.push(prop.content);
+    const fieldName = validVarName(camelCase(key));
+    fieldParts.push(`${fieldName}: ${prop.typeName},`);
+    newParts.push(`${fieldName}: ${prop.defaultValue},`);
+    const tempKey = `_${validVarName(key)}`;
+    fromJsonParts.push(`let ${tempKey}: ${prop.typeName};`);
+    fromJsonParts.push(prop.fromJsonTemplate(`input.${key}`, tempKey));
+    if (hasKey) {
+      toJsonParts.push(`json += ',"${key}":';`);
+    } else {
+      toJsonParts.push(`json += '"${key}":';`);
     }
+    toJsonParts.push(
+      prop.toJsonTemplate(`input.${fieldName}`, "json", key)
+    );
+    toQueryParts.push(
+      prop.toQueryStringTemplate(`input.${fieldName}`, "queryParts", key)
+    );
+    const validationPart = prop.validationTemplate(`input.${fieldName}`);
+    validationParts.push(validationPart);
+    constructionParts.push(`${fieldName}: ${tempKey},`);
+    hasKey = true;
   }
-  if (def.optionalProperties) {
-    for (const propKey of Object.keys(def.optionalProperties)) {
-      const propSchema = def.optionalProperties[propKey];
-      const type = tsTypeFromJtdSchema(
-        `${nodePath}.${propKey}`,
-        propSchema,
-        options,
-        {
-          isOptional: true,
-          existingTypeNames: additionalOptions.existingTypeNames
-        }
-      );
-      parserParts.push(
-        `${propKey}: ${type.fromJsonTemplate(`input.${propKey}`)}`
-      );
-      fieldParts.push(type.fieldTemplate);
-      fieldNames.push(propKey);
-      if (type.content) {
-        subContentParts.push(type.content);
-      }
+  if (!hasKey) {
+    toJsonParts.push(`let _hasKey = false;`);
+  }
+  for (const key of Object.keys(schema.optionalProperties ?? {})) {
+    const subSchema = schema.optionalProperties[key];
+    const prop = tsTypeFromSchema(subSchema, {
+      clientName: context.clientName,
+      typePrefix: context.typePrefix,
+      generatedTypes: context.generatedTypes,
+      instancePath: `/${typeName}/${key}`,
+      schemaPath: `/${typeName}/optionalProperties/${key}`,
+      discriminatorParent: "",
+      discriminatorKey: "",
+      discriminatorValue: "",
+      versionNumber: context.versionNumber,
+      usedFeatures: context.usedFeatures
+    });
+    if (prop.content)
+      subContentParts.push(prop.content);
+    const fieldName = validVarName(camelCase(key));
+    fieldParts.push(`${fieldName}?: ${prop.typeName},`);
+    const tempKey = `_${validVarName(key)}`;
+    fromJsonParts.push(`let ${tempKey}: ${prop.typeName} | undefined;`);
+    fromJsonParts.push(`if (typeof input.${key} !== 'undefined') {
+            ${prop.fromJsonTemplate(`input.${key}`, tempKey)}
+        }`);
+    if (hasKey) {
+      toJsonParts.push(`if (typeof input.${key} !== 'undefined') {
+                json += \`,"${key}":\`;
+                ${prop.toJsonTemplate(`input.${key}`, "json", key)}
+            }`);
+    } else {
+      toJsonParts.push(`if (typeof input.${key} !== 'undefined') {
+            if (_hasKey) json += ',';
+            json += '"${key}":';
+            ${prop.toJsonTemplate(`input.${key}`, "json", key)}
+            _hasKey = true;
+        }`);
     }
+    toQueryParts.push(`if (typeof input.${fieldName} !== 'undefined') {
+            ${prop.toQueryStringTemplate(`input.${fieldName}`, "queryParts", key)}    
+        }`);
+    const validationPart = prop.validationTemplate(`input.${fieldName}`);
+    validationParts.push(
+      `((${validationPart}) || typeof input.${fieldName} === 'undefined')`
+    );
+    constructionParts.push(`${fieldName}: ${tempKey},`);
   }
-  let content = "";
-  const modifiedDef = {
-    ...def,
-    metadata: {
-      id: def.metadata?.id ?? typeName,
-      description: def.metadata?.description
-    },
-    nullable: false
+  result.content = `${getJsDocComment(schema.metadata)}export interface ${prefixedTypeName} {
+${fieldParts.map((part) => `    ${part}`).join("\n")}
+}
+${context.discriminatorParent && context.discriminatorValue ? "" : "export "}const $$${prefixedTypeName}: ArriModelValidator<${prefixedTypeName}> = {
+    new(): ${prefixedTypeName} {
+        return {
+${newParts.map((part) => `            ${part}`).join("\n")}        
+        };
+    },
+    validate(input): input is ${prefixedTypeName} {
+        return (
+${validationParts.map((part) => `            ${part}`).join("&& \n")}
+        )
+    },
+    fromJson(input): ${prefixedTypeName} {
+${fromJsonParts.map((part) => `        ${part}`).join("\n")}
+        return {
+${constructionParts.map((part) => `            ${part}`).join("\n")}
+        }
+    },
+    fromJsonString(input): ${prefixedTypeName} {
+        return $$${prefixedTypeName}.fromJson(JSON.parse(input));
+    },
+    toJsonString(input): string {
+        let json = "{";
+${toJsonParts.map((part) => `        ${part}`).join("\n")}
+        json += "}";
+        return json;
+    },
+    toUrlQueryString(input): string {
+        const queryParts: string[] = [];
+${toQueryParts.map((part) => `        ${part}`).join("\n")}
+        return queryParts.join("&");
+    }
+}
+    
+${subContentParts.join("\n")}`;
+  context.generatedTypes.push(typeName);
+  return result;
+}
+
+function tsTaggedUnionFromSchema(schema, context) {
+  const typeName = getTsTypeName(schema, context);
+  const prefixedTypeName = `${context.typePrefix}${typeName}`;
+  const defaultValue = schema.nullable ? "null" : `$$${prefixedTypeName}.new()`;
+  const result = {
+    typeName: schema.nullable ? `${prefixedTypeName} | null` : prefixedTypeName,
+    defaultValue,
+    validationTemplate(input) {
+      const mainPart = `$$${prefixedTypeName}.validate(${input})`;
+      if (schema.nullable) {
+        return `(${mainPart} || ${input} === null)`;
+      }
+      return mainPart;
+    },
+    fromJsonTemplate(input, target) {
+      return `if (isObject(${input})) {
+                ${target} = $$${prefixedTypeName}.fromJson(${input});
+            } else {
+                ${target} = ${defaultValue}; 
+            }`;
+    },
+    toJsonTemplate(input, target, _key) {
+      if (schema.nullable) {
+        return `if (${input} != null) {
+                    ${target} += $$${prefixedTypeName}.toJsonString(${input});
+                } else {
+                    ${target} += 'null'; 
+                }`;
+      }
+      return `${target} += $$${prefixedTypeName}.toJsonString(${input});`;
+    },
+    toQueryStringTemplate(_, __, ___) {
+      return `console.warn("[WARNING] Cannot serialize nested objects to query string. Skipping property at ${context.instancePath}.");`;
+    },
+    content: ""
   };
-  let validatorPart = "";
-  if (options.typesNeedingParser.includes(typeName)) {
-    const parsingCode = getSchemaParsingCode("input", modifiedDef);
-    const serializationCode = getSchemaSerializationCode(
-      "input",
-      modifiedDef
-    );
-    validatorPart = `export const $$${typeName} = {
-            parse(input: Record<any, any>): ${typeName} {
-                ${parsingCode}
-            },
-            serialize(input: ${typeName}): string {
-                ${serializationCode}
-            }
-        }`;
+  if (context.generatedTypes.includes(typeName))
+    return result;
+  const subTypes = [];
+  const discriminatorKey = schema.discriminator;
+  for (const key of Object.keys(schema.mapping)) {
+    const subSchema = schema.mapping[key];
+    const subType = tsObjectFromSchema(subSchema, {
+      clientName: context.clientName,
+      typePrefix: context.typePrefix,
+      generatedTypes: context.generatedTypes,
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/mapping/${key}`,
+      discriminatorParent: typeName,
+      discriminatorKey,
+      discriminatorValue: key,
+      versionNumber: context.versionNumber,
+      usedFeatures: context.usedFeatures
+    });
+    subTypes.push({ value: key, data: subType });
   }
-  if (!additionalOptions.existingTypeNames.includes(typeName)) {
-    content = `${getJsDocComment(def.metadata)}export interface ${typeName} {
-        ${fieldParts.join(";\n    ")};
+  result.content = `export type ${prefixedTypeName} = ${subTypes.map((type) => type.data.typeName).join(" |")};
+export const $$${prefixedTypeName}: ArriModelValidator<${prefixedTypeName}> = {
+    new(): ${prefixedTypeName} {
+        return $$${subTypes[0].data.typeName}.new();
+    },
+    validate(input): input is ${prefixedTypeName} {
+        if (!isObject(input)) {
+            return false;
+        }
+        if (typeof input.${discriminatorKey} !== 'string') {
+            return false;
+        }
+        switch (input.${discriminatorKey}) {
+${subTypes.map(
+    (type) => `            case "${type.value}":
+                return $$${type.data.typeName}.validate(input);`
+  ).join("\n")}
+            default:
+                return false;
+        }
+    },
+    fromJson(input): ${prefixedTypeName} {
+        switch (input.${discriminatorKey}) {
+${subTypes.map(
+    (type) => `            case "${type.value}":
+                return $$${type.data.typeName}.fromJson(input);`
+  ).join("\n")}
+            default:
+                return $$${subTypes[0].data.typeName}.new();
+        }
+    },
+    fromJsonString(input): ${prefixedTypeName} {
+        return $$${prefixedTypeName}.fromJson(JSON.parse(input));
+    },
+    toJsonString(input): string {
+        switch (input.${discriminatorKey}) {
+${subTypes.map(
+    (type) => `            case "${type.value}":
+                return $$${type.data.typeName}.toJsonString(input);`
+  ).join("\n")}
+            default:
+                throw new Error(\`Unhandled case "\${(input as any).${discriminatorKey}}"\`);
+        }
+    },
+    toUrlQueryString(input): string {
+        switch (input.${discriminatorKey}) {
+${subTypes.map(
+    (type) => `            case "${type.value}":
+                return $$${type.data.typeName}.toUrlQueryString(input);`
+  ).join("\n")}
+            default:
+                throw new Error('Unhandled case');
+        }
     }
-    ${validatorPart}
-    ${subContentParts.join("\n")}`;
-    additionalOptions.existingTypeNames.push(typeName);
+}
+${subTypes.map((type) => type.data.content).join("\n")}
+`;
+  context.generatedTypes.push(typeName);
+  return result;
+}
+
+function tsEnumFromSchema(schema, context) {
+  if (schema.enum.length === 0)
+    throw new Error(
+      `Error at ${context.schemaPath}. Enum schemas must have at least one enum value.`
+    );
+  const enumName = getTsTypeName(schema, context);
+  const prefixedEnumName = `${context.typePrefix}${enumName}`;
+  const typeName = schema.nullable ? `${prefixedEnumName} | null` : prefixedEnumName;
+  const defaultValue = schema.nullable ? "null" : `$$${prefixedEnumName}.new()`;
+  const result = {
+    typeName,
+    defaultValue,
+    validationTemplate(input) {
+      if (schema.nullable) {
+        return `($$${prefixedEnumName}.validate(${input}) || ${input} === null)`;
+      }
+      return `$$${prefixedEnumName}.validate(${input})`;
+    },
+    fromJsonTemplate(input, target) {
+      return `if (typeof ${input} === 'string') {
+                ${target} = $$${prefixedEnumName}.fromSerialValue(${input});
+            } else {
+                ${target} = ${defaultValue}; 
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      if (schema.nullable) {
+        return `if (typeof ${input} === 'string') {
+                    ${target} += \`"\${${input}}"\`;
+                } else {
+                    ${target} += 'null'; 
+                }`;
+      }
+      return `${target} += \`"\${${input}}"\``;
+    },
+    toQueryStringTemplate(input, target, key) {
+      return `${target}.push(\`${key}=\${${input}}\`)`;
+    },
+    content: ""
+  };
+  if (context.generatedTypes.includes(enumName)) {
+    return result;
   }
+  const name = `${context.typePrefix}${enumName}`;
+  const valuesName = `$$${name}Values`;
+  result.content = `${getJsDocComment(schema.metadata)}export type ${name} = (typeof ${valuesName})[number];
+const ${valuesName} = [${schema.enum.map((val) => `"${val}"`).join(", ")}] as const;
+export const $$${name}: ArriEnumValidator<${name}> = {
+    new(): ${name} {
+        return ${valuesName}[0];
+    },
+    validate(input): input is ${enumName} {
+        return (
+            typeof input === 'string' &&
+            ${valuesName}.includes(input as any)
+        );
+    },
+    values: ${valuesName},
+    fromSerialValue(input): ${name} {
+        if (${valuesName}.includes(input as any)) {
+            return input as ${name};
+        }
+        if (${valuesName}.includes(input.toLowerCase() as any)) {
+            return input.toLowerCase() as ${name};
+        }
+        if (${valuesName}.includes(input.toUpperCase() as any)) {
+            return input.toUpperCase() as ${name};
+        }
+        return "${schema.enum[0]}";
+    }
+}    
+`;
+  context.generatedTypes.push(enumName);
+  return result;
+}
+
+function tsStringFromSchema(schema, _context) {
+  const typeName = schema.nullable ? "string | null" : "string";
+  const defaultValue = schema.nullable ? "null" : '""';
   return {
-    tsType: typeName,
-    schema: def,
-    fieldTemplate: `${getJsDocComment(def.metadata)}${maybeOptionalKey(
-      key,
-      additionalOptions.isOptional
-    )}: ${maybeNullType(typeName, def.nullable ?? false)}`,
-    fromJsonTemplate(input) {
-      if (additionalOptions.isOptional) {
-        return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.parse(${input}) : undefined`;
+    typeName,
+    defaultValue,
+    validationTemplate(input) {
+      if (schema.nullable) {
+        return `(typeof ${input} === 'string' || ${input} === null)`;
       }
-      if (def.nullable) {
-        return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.parse(${input}) : null`;
+      return `typeof ${input} === 'string'`;
+    },
+    fromJsonTemplate(input, target) {
+      return `if (typeof ${input} === 'string') {
+                ${target} = ${input};
+            } else {
+                ${target} = ${defaultValue};
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      if (schema.nullable) {
+        return `if (typeof ${input} === 'string') {
+                    ${target} += serializeString(${input});
+                } else {
+                    ${target} += 'null'; 
+                }`;
       }
-      return `$$${typeName}.parse(${input})`;
+      return `${target} += serializeString(${input});`;
     },
-    toJsonTemplate(input) {
-      return `JSON.stringify(${input})`;
+    toQueryStringTemplate(input, target, key) {
+      return `${target}.push(\`${key}=\${${input}}\`);`;
     },
-    content
+    content: ""
   };
 }
-function tsEnumFromJtdSchema(nodePath, def, options, additionalOptions) {
-  const keyName = nodePath.split(".").pop() ?? "";
-  const typeName = getTypeName(nodePath, def);
-  let content = `${getJsDocComment(def.metadata)}export type ${typeName} = ${def.enum.map((val) => `"${val}"`).join(" | ")}`;
-  if (additionalOptions.existingTypeNames.includes(typeName)) {
-    content = "";
-  } else {
-    additionalOptions.existingTypeNames.push(typeName);
-  }
+function tsBooleanFromSchema(schema, _context) {
+  const typeName = schema.nullable ? `boolean | null` : "boolean";
+  const defaultValue = schema.nullable ? `null` : "false";
   return {
-    tsType: typeName,
-    schema: def,
-    fieldTemplate: `${getJsDocComment(def.metadata)}${maybeOptionalKey(
-      keyName,
-      additionalOptions.isOptional
-    )}: ${maybeNullType(typeName, def.nullable ?? false)}`,
-    fromJsonTemplate(input) {
-      if (additionalOptions.isOptional) {
-        return `typeof ${input} === 'string' ? $$${typeName}.parse(${input}) : undefined`;
-      }
-      if (def.nullable) {
-        return `typeof ${input} === 'string' ? $$${typeName}.parse(${input}) : null`;
+    typeName,
+    defaultValue,
+    validationTemplate(input) {
+      if (schema.nullable) {
+        return `(typeof ${input} === 'boolean' || ${input} === null)`;
       }
-      return `$$${typeName}.parse(${input})`;
+      return `typeof ${input} === 'boolean'`;
     },
-    toJsonTemplate(input) {
-      return `JSON.stringify(${input})`;
+    fromJsonTemplate(input, target) {
+      return `if (typeof ${input} === 'boolean') {
+                ${target} = ${input};
+            } else {
+                ${target} = ${defaultValue}; 
+            }`;
     },
-    content
+    toJsonTemplate(input, target) {
+      return `${target} += \`\${${input}}\`;`;
+    },
+    toQueryStringTemplate(input, target, key) {
+      return `${target}.push(\`${key}=\${${input}}\`);`;
+    },
+    content: ""
   };
 }
-function tsArrayFromJtdSchema(nodePath, def, options, additionalOptions) {
-  const key = nodePath.split(".").pop() ?? "";
-  const subType = tsTypeFromJtdSchema(
-    `${nodePath}.item`,
-    def.elements,
-    options,
-    {
-      isOptional: false,
-      existingTypeNames: additionalOptions.existingTypeNames
-    }
-  );
-  const tsType = `Array<${maybeNullType(
-    subType.tsType,
-    def.elements.nullable
-  )}>`;
+function tsDateFromSchema(schema, _context) {
+  const typeName = schema.nullable ? `Date | null` : "Date";
+  const defaultValue = schema.nullable ? `null` : "new Date()";
   return {
-    tsType,
-    schema: def,
-    fieldTemplate: `${getJsDocComment(def.metadata)}${maybeOptionalKey(
-      key,
-      additionalOptions.isOptional ?? false
-    )}: ${maybeNullType(tsType, def.nullable ?? false)}`,
-    fromJsonTemplate(input) {
-      if (additionalOptions.isOptional) {
-        return `Array.isArray(${input}) ? ${input}.map((item) => ${subType.fromJsonTemplate(
-          "item"
-        )}) : undefined`;
+    typeName,
+    defaultValue,
+    validationTemplate(input) {
+      if (schema.nullable) {
+        return `(${input} instanceof Date || ${input} === null)`;
       }
-      if (def.nullable) {
-        return `Array.isArray(${input}) ? ${input}.map((item) => ${subType.fromJsonTemplate(
-          "item"
-        )}) : null`;
+      return `${input} instanceof Date`;
+    },
+    fromJsonTemplate(input, target) {
+      return `if (typeof ${input} === 'string') {
+                ${target} = new Date(${input});
+            } else if (${input} instanceof Date) {
+                ${target} = ${input}; 
+            } else {
+                ${target} = ${defaultValue} 
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      if (schema.nullable) {
+        return `if (${input} instanceof Date) {
+                    ${target} += \`"\${${input}.toISOString()}"\`
+                } else {
+                    ${target} += 'null'; 
+                }`;
       }
-      return `Array.isArray(${input}) ? ${input}.map((item) => ${subType.fromJsonTemplate(
-        "item"
-      )}) : []`;
+      return `${target} += \`"\${${input}.toISOString()}"\``;
     },
-    toJsonTemplate(input) {
-      return `JSON.stringify(${input})`;
+    toQueryStringTemplate(input, target, key) {
+      if (schema.nullable) {
+        return `${target}.push(\`${key}=\${${input}?.toISOString()}\`)`;
+      }
+      return `${target}.push(\`${key}=\${${input}.toISOString()}\`)`;
     },
-    content: subType.content
+    content: ""
   };
 }
-function tsDiscriminatedUnionFromJtdSchema(nodePath, def, options, additionalOptions) {
-  const key = nodePath.split(".").pop() ?? "";
-  const typeName = getTypeName(nodePath, def);
-  const subTypeNames = [];
-  const subContentParts = [];
-  const parserParts = [];
-  for (const val of Object.keys(def.mapping)) {
-    const optionSchema = def.mapping[val];
-    if (!isSchemaFormProperties(optionSchema)) {
-      continue;
-    }
-    const optionType = tsObjectFromJtdSchema(
-      `${nodePath}.${camelCase(val.toLowerCase())}`,
-      optionSchema,
-      options,
-      {
-        discriminatorKey: def.discriminator,
-        discriminatorKeyValue: val,
-        isOptional: false,
-        existingTypeNames: additionalOptions.existingTypeNames
+function tsFloatFromSchema(schema, _context) {
+  const typeName = schema.nullable ? "number | null" : "number";
+  const defaultValue = schema.nullable ? "null" : "0";
+  return {
+    typeName,
+    defaultValue,
+    validationTemplate(input) {
+      if (schema.nullable) {
+        return `(typeof ${input} === 'number' || ${input} === null)`;
       }
-    );
-    parserParts.push(`case '${val}': 
-        return $$${optionType.tsType}.parse(input);`);
-    subTypeNames.push(optionType.tsType);
-    subContentParts.push(optionType.content);
-  }
-  let validatorPart = "";
-  if (options.typesNeedingParser.includes(typeName)) {
-    const modifiedDef = { ...def, nullable: false };
-    const parsingCode = getSchemaParsingCode(
-      "input",
-      modifiedDef
-    );
-    const serializationCode = getSchemaSerializationCode(
-      "input",
-      modifiedDef
-    );
-    validatorPart = `export const $$${typeName} = {
-    parse(input: Record<any, any>): ${typeName} {
-        ${parsingCode}
+      return `typeof ${input} === 'number'`;
     },
-    serialize(input: ${typeName}): string {
-        ${serializationCode}
-    }
-}`;
-  }
-  let content = `${getJsDocComment(def.metadata)}export type ${typeName} = ${subTypeNames.join(" | ")};
-${validatorPart}
-    ${subContentParts.join("\n")}`;
-  if (additionalOptions.existingTypeNames.includes(typeName)) {
-    content = "";
-  } else {
-    additionalOptions.existingTypeNames.push(typeName);
+    fromJsonTemplate(input, target) {
+      return `if (typeof ${input} === 'number') {
+                ${target} = ${input};
+            } else {
+                ${target} = ${defaultValue}; 
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target} += \`\${${input}}\``;
+    },
+    toQueryStringTemplate(input, target, key) {
+      return `${target}.push(\`${key}=\${${input}}\`)`;
+    },
+    content: ""
+  };
+}
+function tsIntFromSchema(schema, intType, _context) {
+  const typeName = schema.nullable ? "number | null" : "number";
+  const defaultValue = schema.nullable ? "null" : "0";
+  let min;
+  let max;
+  switch (intType) {
+    case "int8":
+      min = "INT8_MIN";
+      max = "INT8_MAX";
+      break;
+    case "uint8":
+      min = "0";
+      max = "UINT8_MAX";
+      break;
+    case "int16":
+      min = "INT16_MIN";
+      max = "INT16_MAX";
+      break;
+    case "uint16":
+      min = "0";
+      max = "UINT16_MAX";
+      break;
+    case "int32":
+      min = "INT32_MIN";
+      max = "INT32_MAX";
+      break;
+    case "uint32":
+      min = "0";
+      max = "UINT32_MAX";
+      break;
   }
   return {
-    tsType: typeName,
-    fieldTemplate: `${getJsDocComment(def.metadata)}${maybeOptionalKey(
-      key,
-      additionalOptions.isOptional
-    )}: ${maybeNullType(typeName, def.nullable)}`,
-    schema: def,
-    fromJsonTemplate(input) {
-      if (additionalOptions.isOptional) {
-        return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.parse(${input}) : undefined`;
+    typeName,
+    defaultValue,
+    validationTemplate(input) {
+      const mainPart = `typeof ${input} === 'number' && Number.isInteger(${input}) && ${input} >= ${min} && ${input} <= ${max}`;
+      if (schema.nullable) {
+        return `((${mainPart}) || ${input} === null)`;
       }
-      if (def.nullable) {
-        return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.parse(${input}) : null`;
-      }
-      return `$$${typeName}.parse(${input})`;
+      return mainPart;
+    },
+    fromJsonTemplate(input, target) {
+      return `if (
+                typeof ${input} === 'number' &&
+                Number.isInteger(${input}) &&
+                ${input} >= ${min} &&
+                ${input} <= ${max}
+            ) {
+                ${target} = ${input};    
+            } else {
+                ${target} = ${defaultValue}; 
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target} += \`\${${input}}\``;
     },
-    toJsonTemplate(input) {
-      return `JSON.stringify(${input})`;
+    toQueryStringTemplate(input, target, key) {
+      return `${target}.push(\`${key}=\${${input}}\`)`;
     },
-    content
+    content: ""
   };
 }
-function tsRecordFromJtdSchema(nodePath, def, options, additionalOptions) {
-  const key = nodePath.split(".").pop() ?? "";
-  const typeName = getTypeName(nodePath, def);
-  const subType = tsTypeFromJtdSchema(
-    `${nodePath}.value`,
-    def.values,
-    options,
-    {
-      isOptional: false,
-      existingTypeNames: additionalOptions.existingTypeNames
-    }
-  );
-  let content = "";
-  if (!additionalOptions.existingTypeNames.includes(typeName)) {
-    let validatorPart = "";
-    if (options.typesNeedingParser.includes(typeName)) {
-      const modifiedDef = { ...def, nullable: false };
-      const parsingCode = getSchemaParsingCode(
-        "input",
-        modifiedDef
-      );
-      const serializationCode = getSchemaSerializationCode(
-        "input",
-        modifiedDef
-      );
-      validatorPart = `export const $$${typeName} = {
-    parse(input: Record<any, any>): ${typeName} {
-        ${parsingCode}
-    },
-    serialize(input: ${typeName}): string {
-        ${serializationCode}
-    }
-}`;
-    }
-    content = `${getJsDocComment(def.metadata)}export type ${typeName} = Record<string, ${subType.tsType}>;
-${validatorPart}
-${subType.content}`;
-  }
+function tsBigIntFromSchema(schema, isUnsigned, _context) {
+  const typeName = schema.nullable ? `bigint | null` : `bigint`;
+  const defaultValue = schema.nullable ? `null` : "BigInt(0)";
   return {
-    tsType: typeName,
-    schema: def,
-    fieldTemplate: `${getJsDocComment(def.metadata)}${maybeOptionalKey(
-      key,
-      additionalOptions.isOptional
-    )}: ${maybeNullType(typeName, def.nullable)}`,
-    fromJsonTemplate(input) {
-      if (additionalOptions.isOptional) {
-        return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.parse(${input}) : undefined`;
+    typeName,
+    defaultValue,
+    validationTemplate(input) {
+      const mainPart = isUnsigned ? `typeof ${input} === 'bigint' && ${input} >= BigInt(0) && ${input} <= UINT64_MAX` : `typeof ${input} === 'bigint' && ${input} >= INT64_MIN && ${input} <= INT64_MAX`;
+      if (schema.nullable) {
+        return `((${mainPart}) || ${input} === null)`;
       }
-      if (def.nullable) {
-        return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.parse(${input}) : null`;
+      return mainPart;
+    },
+    fromJsonTemplate(input, target) {
+      if (isUnsigned) {
+        return `if (typeof ${input} === 'string' && BigInt(${input}) >= BigInt(0)) {
+                    ${target} = BigInt(${input});
+                } else if (typeof ${input} === 'bigint' && ${input} >= BigInt(0)) {
+                    ${target} = ${input}; 
+                } else {
+                    ${target} = ${defaultValue}; 
+                }`;
       }
-      return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.parse(${input}) : {}`;
+      return `if (typeof ${input} === 'string') {
+                ${target} = BigInt(${input});
+            } else if (typeof ${input} === 'bigint') {
+                ${target} = ${input}; 
+            } else {
+                ${target} = ${defaultValue}; 
+            }`;
     },
-    toJsonTemplate(input) {
-      return `JSON.stringify(${input})`;
+    toJsonTemplate(input, target) {
+      if (schema.nullable) {
+        return `if (typeof ${input} === 'bigint') {
+                    ${target} += \`"\${${input}}"\`
+                } else {
+                    ${target} += 'null'; 
+                }`;
+      }
+      return `${target} += \`"\${${input}}"\``;
     },
-    content
+    toQueryStringTemplate(input, target, key) {
+      return `${target}.push(\`${key}=\${${input}}\`)`;
+    },
+    content: ""
   };
 }
-function tsRefFromJtdSchema(nodePath, def, options, additionalOptions) {
-  const key = nodePath.split(".").pop() ?? "";
-  const typeName = pascalCase(def.ref, {
-    normalize: true
+
+function tsRecordFromSchema(schema, context) {
+  const innerType = tsTypeFromSchema(schema.values, {
+    clientName: context.clientName,
+    typePrefix: context.typePrefix,
+    generatedTypes: context.generatedTypes,
+    instancePath: `${context.instancePath}/[value]`,
+    schemaPath: `${context.schemaPath}/values`,
+    discriminatorParent: "",
+    discriminatorKey: "",
+    discriminatorValue: "",
+    versionNumber: context.versionNumber,
+    usedFeatures: context.usedFeatures
   });
+  const typeName = `Record<string, ${innerType.typeName}>`;
+  const defaultValue = schema.nullable ? "null" : "{}";
   return {
-    tsType: typeName,
-    schema: def,
-    fieldTemplate: `${maybeOptionalKey(key, additionalOptions.isOptional)}: ${maybeNullType(typeName, def.nullable)}`,
-    fromJsonTemplate(input) {
-      if (additionalOptions.isOptional) {
-        return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.parse(${input}) : undefined`;
+    typeName: schema.nullable ? `${typeName} | null` : typeName,
+    defaultValue,
+    validationTemplate(input) {
+      const mainPart = `isObject(${input}) && Object.values(${input}).every(
+                (_value) => ${innerType.validationTemplate("_value")},
+            )`;
+      if (schema.nullable) {
+        return `((${mainPart}) || ${input} === null)`;
       }
-      if (def.nullable) {
-        return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.parse(${input}) : null`;
+      return mainPart;
+    },
+    fromJsonTemplate(input, target) {
+      return `if (isObject(${input})) {
+                ${target} = {};
+                for (const [_key, _value] of Object.entries(${input})) {
+                    let ${target}Value: ${innerType.typeName};
+                    if (typeof _value === 'boolean') {
+                        ${target}Value = _value;
+                    } else {
+                        ${target}Value = false;
+                    }
+                    ${target}[_key] = ${target}Value;
+                }
+            } else {
+                ${target} = ${defaultValue}; 
+            }`;
+    },
+    toJsonTemplate(input, target, key) {
+      const countVal = `_${validVarName(key)}PropertyCount`;
+      if (schema.nullable) {
+        return `if (${input} !== null) {
+                    ${target} += '{';
+                    let ${countVal} = 0;
+                    for (const [_key, _value] of Object.entries(${input})) {
+                        if (${countVal} !== 0) {
+                            ${target} += ',';
+                        }
+                        ${target} += \`"\${_key}":\`;
+                        ${innerType.toJsonTemplate("_value", target, "_key")}
+                        ${countVal}++;
+                    }
+                    ${target} += '}';
+                } else {
+                    ${target} += 'null'; 
+                }`;
       }
-      return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.parse(${input}) : {}`;
+      return `${target} += '{'
+            let ${countVal} = 0;
+            for (const [_key, _value] of Object.entries(${input})) {
+                if (${countVal} !== 0) {
+                    ${target} += ',';
+                }
+                ${target} += \`"\${_key}":\`;
+                ${innerType.toJsonTemplate("_value", target, "_key")};
+                ${countVal}++;
+            }
+            ${target} += '}';
+            `;
+    },
+    toQueryStringTemplate(_, __, ___) {
+      return `console.warn('[WARNING] Cannot serialize nested objects to query string. Skipping property at ${context.instancePath}.')`;
     },
-    toJsonTemplate(input) {
-      if (additionalOptions.isOptional) {
-        return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.serialize(${input}) : 'undefined'`;
+    content: innerType.content
+  };
+}
+
+function tsRefFromSchema(schema, context) {
+  const typeName = pascalCase(validVarName(schema.ref), { normalize: true });
+  const prefixedTypeName = `${context.typePrefix}${typeName}`;
+  const defaultValue = schema.nullable ? "null" : `${prefixedTypeName}.new()`;
+  return {
+    typeName: schema.nullable ? `${prefixedTypeName} | null` : prefixedTypeName,
+    defaultValue,
+    validationTemplate(input) {
+      if (schema.nullable) {
+        return `($$${prefixedTypeName}.validate(${input}) || ${input} === null)`;
       }
-      if (def.nullable) {
-        return `typeof ${input} === 'object' && ${input} !== null ? $$${typeName}.serialize(${input}) : 'null'`;
+      return `$$${prefixedTypeName}.validate(${input})`;
+    },
+    fromJsonTemplate(input, target) {
+      return `if (isObject(${input})) {
+                    ${target} = $$${prefixedTypeName}.fromJson(${input});
+                } else {
+                    ${target} = ${defaultValue}; 
+                }`;
+    },
+    toJsonTemplate(input, target, _key) {
+      if (schema.nullable) {
+        return `if (${input} !== null) {
+                    ${target} += $$${prefixedTypeName}.toJsonString(${input});
+                } else {
+                    ${target} += 'null';
+                }`;
       }
-      return `$$${typeName}.serialize(${input})`;
+      return `${target} += $$${prefixedTypeName}.toJsonString(${input});`;
+    },
+    toQueryStringTemplate(_, __, ___) {
+      return `console.warn("[WARNING] Nested objects cannot be serialized to query string. Ignoring property at ${context.instancePath}.");`;
     },
     content: ""
   };
 }
 
-export { createTypescriptClient, getJsDocComment, maybeNullType, maybeOptionalKey, tsAnyFromJtdSchema, tsArrayFromJtdSchema, tsDiscriminatedUnionFromJtdSchema, tsEnumFromJtdSchema, tsHttpRpcFromDefinition, tsObjectFromJtdSchema, tsRecordFromJtdSchema, tsRefFromJtdSchema, tsRpcFromDefinition, tsScalarFromJtdSchema, tsServiceFromDefinition, tsTypeFromJtdSchema, tsWsRpcFromDefinition, typescriptClientGenerator };
+function tsRpcFromDefinition(def, context) {
+  switch (def.transport) {
+    case "http":
+      return httpRpcFromDefinition(def, context);
+    case "ws":
+      return wsRpcFromDefinition(def, context);
+    default:
+      console.warn(
+        `[ts-codegen] Warning: unsupported transport "${def.transport}". Ignoring ${context.instancePath}.`
+      );
+      return "";
+  }
+}
+function httpRpcFromDefinition(def, context) {
+  const key = getRpcKey(context);
+  const params = def.params ? `${context.typePrefix}${pascalCase(validVarName(def.params))}` : void 0;
+  const response = def.response ? `${context.typePrefix}${pascalCase(validVarName(def.response), { normalize: true })}` : void 0;
+  const serializerMethod = def.method === "get" ? "toUrlQueryString" : "toJsonString";
+  if (def.isEventStream) {
+    context.usedFeatures.sse = true;
+    return `    ${key}(${params ? `params: ${params},` : ""} options: SseOptions<${response ?? "undefined"}> = {}): EventSourceController {
+        return arriSseRequest<${response ?? "undefined"}, ${params ?? "undefined"}>(
+            {
+                url: \`\${this._baseUrl}${def.path}\`,
+                method: "${def.method.toLowerCase()}",
+                headers: this._headers,
+                ${params ? "params: params," : ""}
+                responseFromJson: ${response ? `$$${response}.fromJson` : "() => {}"},
+                responseFromString: ${response ? `$$${response}.fromJsonString` : "() => {}"},
+                serializer: ${params ? `$$${params}.${serializerMethod}` : "() => {}"},
+                clientVersion: "${context.versionNumber}",
+            },
+            options,
+        )
+    }`;
+  }
+  return `    async ${key}(${params ? `params: ${params}` : ""}): Promise<${response ?? "undefined"}> {
+        return arriRequest<${response ?? "undefined"}, ${params ?? "undefined"}>({
+            url: \`\${this._baseUrl}${def.path}\`,
+            method: "${def.method.toLowerCase()}",
+            headers: this._headers,
+            ${params ? "params: params," : ""}
+            responseFromJson: ${response ? `$$${response}.fromJson` : "() => {}"},
+            responseFromString: ${response ? `$$${response}.fromJsonString` : "() => {}"},
+            serializer: ${params ? `$$${params}.${serializerMethod}` : "() => {}"},
+            clientVersion: "${context.versionNumber}",
+        });
+    }`;
+}
+function wsRpcFromDefinition(def, context) {
+  context.usedFeatures.ws = true;
+  const key = getRpcKey(context);
+  const params = def.params ? `${context.typePrefix}${pascalCase(validVarName(def.params))}` : void 0;
+  const response = def.response ? `${context.typePrefix}${pascalCase(validVarName(def.response), { normalize: true })}` : void 0;
+  return `    async ${key}(options: WsOptions<${response ?? "undefined"}> = {}): Promise<WsController<${params ?? "undefined"},${response ?? "undefined"}>> {
+        return arriWsRequest<${params ?? "undefined"}, ${response ?? "undefined"}>({
+            url: \`\${this._baseUrl}${def.path}\`,
+            headers: this._headers,
+            responseFromJson: ${response ? `$$${response}.fromJson` : "() => {}"},
+            responseFromString: ${response ? `$$${response}.fromJsonString` : "() => {}"},
+            serializer: ${params ? `$$${params}.toJsonString` : "() => {}"},
+            onOpen: options.onOpen,
+            onClose: options.onClose,
+            onError: options.onError,
+            onConnectionError: options.onConnectionError,
+            onMessage: options.onMessage,
+            clientVersion: "${context.versionNumber}",
+        });
+    }`;
+}
+function getRpcKey(context) {
+  const name = context.instancePath.split(".").pop() ?? "";
+  return validVarName(name);
+}
+
+function tsServiceFromDefinition(def, context) {
+  const key = getServiceKey(context);
+  const serviceName = getServiceName(context);
+  const rpcParts = [];
+  const subServices = [];
+  for (const key2 of Object.keys(def)) {
+    const subDef = def[key2];
+    if (isServiceDefinition(subDef)) {
+      const subService = tsServiceFromDefinition(subDef, {
+        clientName: context.clientName,
+        typePrefix: context.typePrefix,
+        generatedTypes: context.generatedTypes,
+        instancePath: `${context.instancePath}.${key2}`,
+        schemaPath: `${context.instancePath}.${key2}`,
+        discriminatorParent: "",
+        discriminatorKey: "",
+        discriminatorValue: "",
+        versionNumber: context.versionNumber,
+        usedFeatures: context.usedFeatures
+      });
+      if (subService.content) {
+        subServices.push(subService);
+      }
+      continue;
+    }
+    if (isRpcDefinition(subDef)) {
+      const rpc = tsRpcFromDefinition(subDef, {
+        clientName: context.clientName,
+        typePrefix: context.typePrefix,
+        generatedTypes: context.generatedTypes,
+        instancePath: `${context.instancePath}.${key2}`,
+        schemaPath: `${context.schemaPath}.${key2}`,
+        discriminatorParent: "",
+        discriminatorKey: "",
+        discriminatorValue: "",
+        versionNumber: context.versionNumber,
+        usedFeatures: context.usedFeatures
+      });
+      if (rpc) {
+        rpcParts.push(rpc);
+      }
+      continue;
+    }
+    console.warn(
+      `Invalid definition found at procedures.${context.schemaPath}`
+    );
+  }
+  if (subServices.length === 0 && rpcParts.length === 0) {
+    return {
+      key,
+      name: serviceName,
+      content: ""
+    };
+  }
+  return {
+    key,
+    name: serviceName,
+    content: `export class ${serviceName} {
+    private readonly _baseUrl: string;
+    private readonly _headers: HeaderMap | (() => HeaderMap | Promise<HeaderMap>);
+${subServices.map((service) => `    ${service.key}: ${service.name};`).join("\n")}
+    constructor(
+        options: {
+            baseUrl?: string;
+            headers?: HeaderMap | (() => HeaderMap | Promise<HeaderMap>);
+        } = {},
+    ) {
+        this._baseUrl = options.baseUrl ?? "";
+        this._headers = options.headers ?? {};
+${subServices.map((service) => `        this.${service.key} = new ${service.name}(options);`).join("\n")}
+    }
+${rpcParts.map((rpc) => `    ${rpc}`).join("\n")}
+}
+
+${subServices.map((service) => service.content).join("\n")}`
+  };
+}
+function getServiceKey(context) {
+  const name = context.instancePath.split(".").pop() ?? "";
+  return validVarName(name);
+}
+function getServiceName(context) {
+  if (context.instancePath.length === 0) {
+    return context.clientName;
+  }
+  const serviceName = pascalCase(context.instancePath.split(".").join("_"), {
+    normalize: true
+  });
+  return `${context.clientName}${serviceName}Service`;
+}
+
+const typescriptClientGenerator = defineGeneratorPlugin(
+  (options) => ({
+    generator: async (def) => {
+      if (!options.clientName) {
+        throw new Error("Name is requires");
+      }
+      if (!options.outputFile) {
+        throw new Error("No output file specified");
+      }
+      if (Object.keys(def.procedures).length <= 0) {
+        console.warn(
+          `No procedures defined in AppDefinition. Only data models will be outputted.`
+        );
+      }
+      const result = await createTypescriptClient(def, options);
+      writeFileSync(options.outputFile, result);
+    },
+    options
+  })
+);
+async function createTypescriptClient(def, options) {
+  const types = [];
+  const context = {
+    clientName: options.clientName,
+    typePrefix: options.typePrefix ?? "",
+    generatedTypes: [],
+    instancePath: "",
+    schemaPath: "",
+    discriminatorParent: "",
+    discriminatorKey: "",
+    discriminatorValue: "",
+    versionNumber: def.info?.version ?? "",
+    usedFeatures: {
+      sse: false,
+      ws: false
+    }
+  };
+  const serviceDefinitions = unflattenProcedures(def.procedures);
+  const mainService = tsServiceFromDefinition(serviceDefinitions, context);
+  for (const key of Object.keys(def.definitions)) {
+    const typeDef = def.definitions[key];
+    const result2 = tsTypeFromSchema(typeDef, {
+      clientName: context.clientName,
+      typePrefix: context.typePrefix,
+      generatedTypes: context.generatedTypes,
+      instancePath: `/${key}`,
+      schemaPath: `/${key}`,
+      discriminatorParent: "",
+      discriminatorKey: "",
+      discriminatorValue: "",
+      versionNumber: context.versionNumber,
+      usedFeatures: context.usedFeatures
+    });
+    if (result2.content) {
+      types.push(result2.content);
+    }
+  }
+  const imports = `// This file was autogenerated by @arrirpc/codegen-ts. Do not modify directly.
+// For more information visit https://github.com/modiimedia/arri
+
+/* eslint-disable */
+// @ts-nocheck
+import {
+    ArriEnumValidator,
+    ArriModelValidator,
+    arriRequest,
+    ${context.usedFeatures.sse ? "arriSseRequest," : ""}
+    ${context.usedFeatures.ws ? "arriWsRequest," : ""}
+    ${context.usedFeatures.sse ? "type EventSourceController," : ""}
+    INT8_MAX,
+    INT8_MIN,
+    INT16_MAX,
+    INT16_MIN,
+    INT32_MAX,
+    INT32_MIN,
+    INT64_MAX,
+    INT64_MIN,
+    isObject,
+    serializeString,
+    ${context.usedFeatures.sse ? "type SseOptions," : ""}
+    UINT8_MAX,
+    UINT16_MAX,
+    UINT32_MAX,
+    UINT64_MAX,
+    ${context.usedFeatures.ws ? "type WsController," : ""}
+    ${context.usedFeatures.ws ? "type WsOptions," : ""}
+} from "@arrirpc/client";
+
+type HeaderMap = Record<string, string | undefined>;`;
+  if (!mainService.content) {
+    const result2 = `${imports}
+        
+${types.join("\n")}`;
+    return await prettier.format(result2, {
+      ...options.prettierOptions,
+      parser: "typescript"
+    });
+  }
+  const result = `${imports}
+${mainService.content}
+
+${types.join("\n")}`;
+  return await prettier.format(result, {
+    ...options.prettierOptions,
+    parser: "typescript"
+  });
+}
+function tsTypeFromSchema(schema, context) {
+  if (isSchemaFormType(schema)) {
+    switch (schema.type) {
+      case "string":
+        return tsStringFromSchema(schema);
+      case "boolean":
+        return tsBooleanFromSchema(schema);
+      case "timestamp":
+        return tsDateFromSchema(schema);
+      case "float32":
+      case "float64":
+        return tsFloatFromSchema(schema);
+      case "int8":
+        return tsIntFromSchema(schema, "int8");
+      case "uint8":
+        return tsIntFromSchema(schema, "uint8");
+      case "int16":
+        return tsIntFromSchema(schema, "int16");
+      case "uint16":
+        return tsIntFromSchema(schema, "uint16");
+      case "int32":
+        return tsIntFromSchema(schema, "int32");
+      case "uint32":
+        return tsIntFromSchema(schema, "uint32");
+      case "int64":
+        return tsBigIntFromSchema(schema, false);
+      case "uint64":
+        return tsBigIntFromSchema(schema, true);
+    }
+  }
+  if (isSchemaFormEnum(schema)) {
+    return tsEnumFromSchema(schema, context);
+  }
+  if (isSchemaFormProperties(schema)) {
+    return tsObjectFromSchema(schema, context);
+  }
+  if (isSchemaFormElements(schema)) {
+    return tsArrayFromSchema(schema, context);
+  }
+  if (isSchemaFormValues(schema)) {
+    return tsRecordFromSchema(schema, context);
+  }
+  if (isSchemaFormDiscriminator(schema)) {
+    return tsTaggedUnionFromSchema(schema, context);
+  }
+  if (isSchemaFormRef(schema)) {
+    return tsRefFromSchema(schema, context);
+  }
+  return tsAnyFromSchema(schema, context);
+}
+
+export { createTypescriptClient, tsTypeFromSchema, typescriptClientGenerator };