@arrirpc/codegen-ts 0.83.1 → 0.84.0

package/dist/index.cjs

@@ -8,28 +8,9 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 const prettier__default = /*#__PURE__*/_interopDefaultCompat(prettier);
 
-function tsAnyFromSchema(schema, context) {
-  const typeName = "any";
-  const defaultValue = schema.isNullable ? "null" : "undefined";
-  return {
-    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 defaultCloneTemplate(input, target) {
+  return `${target} = ${input};`;
 }
-
 function getJsDocComment(metadata) {
   const descriptionParts = [];
   if (metadata?.description?.length) {
@@ -77,6 +58,29 @@ function getTsTypeName(schema, context) {
   return validVarName(name);
 }
 
+function tsAnyFromSchema(schema, context) {
+  const typeName = "any";
+  const defaultValue = schema.isNullable ? "null" : "undefined";
+  return {
+    typeName,
+    defaultValue,
+    validationTemplate(_) {
+      return "true";
+    },
+    cloneTemplate: defaultCloneTemplate,
+    fromJsonTemplate(input, target) {
+      return `${target} = ${input}`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target} += JSON.stringify(${input})`;
+    },
+    setSearchParamTemplate(_input, _target, _key) {
+      return `console.warn('[WARNING] Cannot serialize any\\'s to query string. Skipping property at ${context.instancePath}.')`;
+    },
+    content: ""
+  };
+}
+
 function tsArrayFromSchema(schema, context) {
   const innerType = tsTypeFromSchema(schema.elements, {
     clientName: context.clientName,
@@ -88,8 +92,9 @@ function tsArrayFromSchema(schema, context) {
     discriminatorKey: "",
     discriminatorValue: "",
     versionNumber: context.versionNumber,
-    usedFeatures: context.usedFeatures,
-    rpcGenerators: context.rpcGenerators
+    useRpcTypes: context.useRpcTypes,
+    rpcGenerators: context.rpcGenerators,
+    features: context.features
   });
   const typeName = `(${innerType.typeName})[]`;
   const defaultValue = schema.isNullable ? "null" : "[]";
@@ -107,6 +112,22 @@ function tsArrayFromSchema(schema, context) {
       }
       return mainPart;
     },
+    cloneTemplate(input, target) {
+      const main = `${target} = [];
+            for (const ${target}El of ${input}) {
+                let ${target}ElValue: ${innerType.typeName};
+                ${innerType.cloneTemplate(`${target}El`, `${target}ElValue`)}
+                ${target}.push(${target}ElValue);
+            }`;
+      if (schema.isNullable) {
+        return `if (${input} !== null) {
+                    ${main}
+                } else {
+                    ${target} = null;
+                }`;
+      }
+      return main;
+    },
     fromJsonTemplate(input, target) {
       return `if (Array.isArray(${input})) {
                 ${target} = [];
@@ -143,7 +164,7 @@ function tsArrayFromSchema(schema, context) {
             }
             ${target} += ']';`;
     },
-    toQueryStringTemplate(_input, _target, _key) {
+    setSearchParamTemplate(_input, _target, _key) {
       return `console.warn('[WARNING] Cannot serialize arrays to query string. Skipping property at ${context.instancePath}.')`;
     },
     content: innerType.content
@@ -153,34 +174,44 @@ function tsArrayFromSchema(schema, context) {
 function tsObjectFromSchema(schema, context) {
   const typeName = getTsTypeName(schema, context);
   const prefixedTypeName = `${context.typePrefix}${typeName}`;
-  const defaultValue = schema.isNullable ? "null" : `$$${prefixedTypeName}.new()`;
+  const defaultValue = schema.isNullable ? "null" : `${prefixedTypeName}New()`;
   const result = {
     typeName: schema.isNullable ? `${prefixedTypeName} | null` : prefixedTypeName,
     defaultValue,
     validationTemplate(input) {
       if (schema.isNullable) {
-        return `($$${prefixedTypeName}.validate(${input}) || ${input} === null)`;
+        return `(${prefixedTypeName}Validate(${input}) || ${input} === null)`;
       }
-      return `$$${prefixedTypeName}.validate(${input})`;
+      return `${prefixedTypeName}Validate(${input})`;
     },
     fromJsonTemplate(input, target) {
       return `if (isObject(${input})) {
-                ${target} = $$${prefixedTypeName}.fromJson(${input});
+                ${target} = ${prefixedTypeName}FromJson(${input});
             } else {
                 ${target} = ${defaultValue}; 
             }`;
     },
+    cloneTemplate(input, target) {
+      if (schema.isNullable) {
+        return `if (${input} !== null) {
+                    ${target} = ${prefixedTypeName}Clone(${input});
+                } else {
+                    ${target} = null;    
+                }`;
+      }
+      return `${target} = ${prefixedTypeName}Clone(${input});`;
+    },
     toJsonTemplate(input, target) {
       if (schema.isNullable) {
         return `if (${input} !== null) {
-                    ${target} += $$${prefixedTypeName}.toJsonString(${input}); 
+                    ${target} += ${prefixedTypeName}ToJsonString(${input}); 
                 } else {
                     ${target} += 'null';
                 }`;
       }
-      return `${target} += $$${prefixedTypeName}.toJsonString(${input});`;
+      return `${target} += ${prefixedTypeName}ToJsonString(${input});`;
     },
-    toQueryStringTemplate(_input, _target) {
+    setSearchParamTemplate(_input, _target) {
       return `console.warn('[WARNING] Cannot serialize nested objects to query string. Skipping property at ${context.instancePath}.')`;
     },
     content: ""
@@ -193,8 +224,9 @@ function tsObjectFromSchema(schema, context) {
   const fromJsonParts = [];
   const constructionParts = [];
   const toJsonParts = [];
-  const toQueryParts = [];
+  const setSearchParamParts = [];
   const validationParts = ["isObject(input)"];
+  const cloneParts = [];
   const subContentParts = [];
   let hasKey = false;
   if (context.discriminatorParent && context.discriminatorValue && context.discriminatorKey) {
@@ -205,12 +237,13 @@ function tsObjectFromSchema(schema, context) {
     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}');`
+    setSearchParamParts.push(
+      `params.set('${context.discriminatorKey}', '${context.discriminatorValue}');`
     );
     validationParts.push(
       `input.${key} === '${context.discriminatorValue}'`
     );
+    cloneParts.push(`const _${key} = "${context.discriminatorValue}"`);
     newParts.push(`${key}: "${context.discriminatorValue}",`);
     constructionParts.push(`${key}: _${key},`);
   }
@@ -226,8 +259,9 @@ function tsObjectFromSchema(schema, context) {
       discriminatorKey: "",
       discriminatorValue: "",
       versionNumber: context.versionNumber,
-      usedFeatures: context.usedFeatures,
-      rpcGenerators: context.rpcGenerators
+      useRpcTypes: context.useRpcTypes,
+      rpcGenerators: context.rpcGenerators,
+      features: context.features
     });
     if (prop.content) subContentParts.push(prop.content);
     const fieldName = validVarName(codegenUtils.camelCase(key, { normalize: true }));
@@ -246,11 +280,13 @@ function tsObjectFromSchema(schema, context) {
     toJsonParts.push(
       prop.toJsonTemplate(`input.${fieldName}`, "json", key)
     );
-    toQueryParts.push(
-      prop.toQueryStringTemplate(`input.${fieldName}`, "queryParts", key)
+    setSearchParamParts.push(
+      prop.setSearchParamTemplate(`input.${fieldName}`, "params", key)
     );
     const validationPart = prop.validationTemplate(`input.${fieldName}`);
     validationParts.push(validationPart);
+    cloneParts.push(`let ${tempKey}: ${prop.typeName}`);
+    cloneParts.push(prop.cloneTemplate(`input.${fieldName}`, tempKey));
     constructionParts.push(`${fieldName}: ${tempKey},`);
     hasKey = true;
   }
@@ -269,8 +305,9 @@ function tsObjectFromSchema(schema, context) {
       discriminatorKey: "",
       discriminatorValue: "",
       versionNumber: context.versionNumber,
-      usedFeatures: context.usedFeatures,
-      rpcGenerators: context.rpcGenerators
+      useRpcTypes: context.useRpcTypes,
+      rpcGenerators: context.rpcGenerators,
+      features: context.features
     });
     if (prop.content) subContentParts.push(prop.content);
     const fieldName = validVarName(codegenUtils.camelCase(key, { normalize: true }));
@@ -295,51 +332,89 @@ function tsObjectFromSchema(schema, context) {
             _hasKey = true;
         }`);
     }
-    toQueryParts.push(`if (typeof input.${fieldName} !== 'undefined') {
-            ${prop.toQueryStringTemplate(`input.${fieldName}`, "queryParts", key)}    
+    setSearchParamParts.push(`if (typeof input.${fieldName} !== 'undefined') {
+            ${prop.setSearchParamTemplate(`input.${fieldName}`, "params", key)}    
         }`);
     const validationPart = prop.validationTemplate(`input.${fieldName}`);
     validationParts.push(
       `((${validationPart}) || typeof input.${fieldName} === 'undefined')`
     );
+    cloneParts.push(`let ${tempKey}: ${prop.typeName} | undefined;`);
+    const clonePart = prop.cloneTemplate(`input.${fieldName}`, tempKey);
+    cloneParts.push(`if (typeof input.${fieldName} !== 'undefined') {
+        ${clonePart}
+    }`);
     constructionParts.push(`${fieldName}: ${tempKey},`);
   }
   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("&");
+}`;
+  result.content += `
+export function ${prefixedTypeName}New(): ${prefixedTypeName} {
+    return {
+${newParts.map((part) => `        ${part}`).join("\n")}        
+    };
+}`;
+  if (context.features.validateFn) {
+    result.content += `
+export function ${prefixedTypeName}Validate(input: unknown): input is ${prefixedTypeName} {
+    return (
+${validationParts.map((part) => `        ${part}`).join("&& \n")}
+    )
+}`;
+  }
+  if (context.features.cloneFn) {
+    result.content += `
+export function ${prefixedTypeName}Clone(input: ${prefixedTypeName}): ${prefixedTypeName} {
+${cloneParts.map((part) => `        ${part}`).join("\n")}
+    return {
+${constructionParts.map((part) => `        ${part}`).join("\n")}
     }
+}`;
+  }
+  result.content += `
+export function ${prefixedTypeName}FromJson(input: Record<string, unknown>): ${prefixedTypeName} {
+${fromJsonParts.map((part) => `    ${part}`).join("\n")}
+    return {
+${constructionParts.map((part) => `        ${part}`).join("\n")}
+    }
+}`;
+  result.content += `
+export function ${prefixedTypeName}FromJsonString(input: string): ${prefixedTypeName} {
+    return ${prefixedTypeName}FromJson(JSON.parse(input));
+}`;
+  result.content += `
+export function ${prefixedTypeName}ToJsonString(input: ${prefixedTypeName}): string {
+    let json = "{";
+${toJsonParts.map((part) => `    ${part}`).join("\n")}
+    json += "}";
+    return json;
+}`;
+  result.content += `
+export function ${prefixedTypeName}ToUrlSearchParams(input: ${prefixedTypeName}): URLSearchParams {
+    const params = new URLSearchParams();
+    ${setSearchParamParts.map((part) => `        ${part}`).join("\n")}
+    return params;
+}`;
+  result.content += `
+export function ${prefixedTypeName}ToUrlSearchParamsString(input: ${prefixedTypeName}): string {
+    return ${prefixedTypeName}ToUrlSearchParams(input).toString();
 }
-    
+`;
+  if (context.features.validatorObj) {
+    result.content += `
+${context.discriminatorParent && context.discriminatorValue ? "" : "export "}const $$${prefixedTypeName}: ${context.clientName}Validator<${prefixedTypeName}> = {
+    new: ${prefixedTypeName}New,
+    ${context.features.validateFn ? `validate: ${prefixedTypeName}Validate,` : ""} 
+    ${context.features.cloneFn ? `clone: ${prefixedTypeName}Clone,` : ""}
+    fromJson: ${prefixedTypeName}FromJson,
+    fromJsonString: ${prefixedTypeName}FromJsonString,
+    toJsonString: ${prefixedTypeName}ToJsonString,
+    toUrlSearchParams: ${prefixedTypeName}ToUrlSearchParams,
+    toUrlSearchParamsString: ${prefixedTypeName}ToUrlSearchParamsString,
+}`;
+  }
+  result.content += `  
 ${subContentParts.join("\n")}`;
   context.generatedTypes.push(typeName);
   return result;
@@ -348,20 +423,30 @@ ${subContentParts.join("\n")}`;
 function tsTaggedUnionFromSchema(schema, context) {
   const typeName = getTsTypeName(schema, context);
   const prefixedTypeName = `${context.typePrefix}${typeName}`;
-  const defaultValue = schema.isNullable ? "null" : `$$${prefixedTypeName}.new()`;
+  const defaultValue = schema.isNullable ? "null" : `${prefixedTypeName}New()`;
   const result = {
     typeName: schema.isNullable ? `${prefixedTypeName} | null` : prefixedTypeName,
     defaultValue,
     validationTemplate(input) {
-      const mainPart = `$$${prefixedTypeName}.validate(${input})`;
+      const mainPart = `${prefixedTypeName}Validate(${input})`;
       if (schema.isNullable) {
         return `(${mainPart} || ${input} === null)`;
       }
       return mainPart;
     },
+    cloneTemplate(input, target) {
+      if (schema.isNullable) {
+        return `if (${input} !== null) {
+                    ${target} = ${prefixedTypeName}Clone(${input});
+                } else {
+                    ${target} = null;    
+                }`;
+      }
+      return `${target} = ${prefixedTypeName}Clone(${input});`;
+    },
     fromJsonTemplate(input, target) {
       return `if (isObject(${input})) {
-                ${target} = $$${prefixedTypeName}.fromJson(${input});
+                ${target} = ${prefixedTypeName}FromJson(${input});
             } else {
                 ${target} = ${defaultValue}; 
             }`;
@@ -369,14 +454,14 @@ function tsTaggedUnionFromSchema(schema, context) {
     toJsonTemplate(input, target, _key) {
       if (schema.isNullable) {
         return `if (${input} != null) {
-                    ${target} += $$${prefixedTypeName}.toJsonString(${input});
+                    ${target} += ${prefixedTypeName}ToJsonString(${input});
                 } else {
                     ${target} += 'null'; 
                 }`;
       }
-      return `${target} += $$${prefixedTypeName}.toJsonString(${input});`;
+      return `${target} += ${prefixedTypeName}ToJsonString(${input});`;
     },
-    toQueryStringTemplate(_, __, ___) {
+    setSearchParamTemplate(_, __, ___) {
       return `console.warn('[WARNING] Cannot serialize nested objects to query string. Skipping property at ${context.instancePath}.');`;
     },
     content: ""
@@ -396,66 +481,104 @@ function tsTaggedUnionFromSchema(schema, context) {
       discriminatorKey,
       discriminatorValue: key,
       versionNumber: context.versionNumber,
-      usedFeatures: context.usedFeatures,
-      rpcGenerators: context.rpcGenerators
+      useRpcTypes: context.useRpcTypes,
+      rpcGenerators: context.rpcGenerators,
+      features: context.features
     });
     subTypes.push({ value: key, data: subType });
   }
-  result.content = `${getJsDocComment(schema.metadata)}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') {
+  result.content = `${getJsDocComment(schema.metadata)}export type ${prefixedTypeName} = ${subTypes.map((type) => type.data.typeName).join(" |")};`;
+  result.content += `
+export function ${prefixedTypeName}New(): ${prefixedTypeName} {
+    return ${subTypes[0].data.typeName}New();
+}`;
+  if (context.features.validateFn) {
+    result.content += `
+export function ${prefixedTypeName}Validate(input: unknown): 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;
-        }
-        switch (input.${discriminatorKey}) {
+    }
+}`;
+  }
+  if (context.features.cloneFn) {
+    result.content += `
+export function ${prefixedTypeName}Clone(input: ${prefixedTypeName}): ${prefixedTypeName} {
+    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}) {
+      (type) => `        case "${type.value}":
+            return ${type.data.typeName}Clone(input);`
+    ).join("\n")}
+        default:
+            throw new Error('Unimplemented');
+    }
+}`;
+  }
+  result.content += `
+export function ${prefixedTypeName}FromJson(input: Record<string, unknown>): ${prefixedTypeName} {
+    switch (input.${discriminatorKey}) {
 ${subTypes.map(
-    (type) => `            case "${type.value}":
-                return $$${type.data.typeName}.fromJson(input);`
+    (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}) {
+        default:
+            return ${subTypes[0].data.typeName}New();
+    }
+}`;
+  result.content += `
+export function ${prefixedTypeName}FromJsonString(input: string): ${prefixedTypeName} {
+    return ${prefixedTypeName}FromJson(JSON.parse(input));
+}`;
+  result.content += `
+export function ${prefixedTypeName}ToJsonString(input: ${prefixedTypeName}): string {
+    switch (input.${discriminatorKey}) {
 ${subTypes.map(
-    (type) => `            case "${type.value}":
-                return $$${type.data.typeName}.toJsonString(input);`
+    (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}) {
+        default:
+            throw new Error(\`Unhandled case "\${(input as any).${discriminatorKey}}"\`);
+    }
+}`;
+  result.content += `
+export function ${prefixedTypeName}ToUrlSearchParams(input: ${prefixedTypeName}): URLSearchParams {
+    switch (input.${discriminatorKey}) {
 ${subTypes.map(
-    (type) => `            case "${type.value}":
-                return $$${type.data.typeName}.toUrlQueryString(input);`
+    (type) => `        case "${type.value}":
+            return ${type.data.typeName}ToUrlSearchParams(input);`
   ).join("\n")}
-            default:
-                throw new Error('Unhandled case');
-        }
+        default:
+            throw new Error('Unhandled case');
     }
-}
+}`;
+  result.content += `
+export function ${prefixedTypeName}ToUrlSearchParamsString(input: ${prefixedTypeName}): string {
+    return ${prefixedTypeName}ToUrlSearchParams(input).toString();
+}`;
+  if (context.features.validatorObj) {
+    result.content += `
+export const $$${prefixedTypeName}: ${context.clientName}Validator<${prefixedTypeName}> = {
+    new: ${prefixedTypeName}New,
+    ${context.features.validateFn ? `validate: ${prefixedTypeName}Validate,` : ""}
+    ${context.features.cloneFn ? `clone: ${prefixedTypeName}Clone,` : ""}
+    fromJson: ${prefixedTypeName}FromJson,
+    fromJsonString: ${prefixedTypeName}FromJsonString,
+    toJsonString: ${prefixedTypeName}ToJsonString,
+    toUrlSearchParams: ${prefixedTypeName}ToUrlSearchParams,
+    toUrlSearchParamsString: ${prefixedTypeName}ToUrlSearchParamsString,
+}`;
+  }
+  result.content += `
 ${subTypes.map((type) => type.data.content).join("\n")}
 `;
   context.generatedTypes.push(typeName);
@@ -470,19 +593,20 @@ function tsEnumFromSchema(schema, context) {
   const enumName = getTsTypeName(schema, context);
   const prefixedEnumName = `${context.typePrefix}${enumName}`;
   const typeName = schema.isNullable ? `${prefixedEnumName} | null` : prefixedEnumName;
-  const defaultValue = schema.isNullable ? "null" : `$$${prefixedEnumName}.new()`;
+  const defaultValue = schema.isNullable ? "null" : `${prefixedEnumName}New()`;
   const result = {
     typeName,
     defaultValue,
     validationTemplate(input) {
       if (schema.isNullable) {
-        return `($$${prefixedEnumName}.validate(${input}) || ${input} === null)`;
+        return `(${prefixedEnumName}Validate(${input}) || ${input} === null)`;
       }
-      return `$$${prefixedEnumName}.validate(${input})`;
+      return `${prefixedEnumName}Validate(${input})`;
     },
+    cloneTemplate: defaultCloneTemplate,
     fromJsonTemplate(input, target) {
       return `if (typeof ${input} === 'string') {
-                ${target} = $$${prefixedEnumName}.fromSerialValue(${input});
+                ${target} = ${prefixedEnumName}FromSerialValue(${input});
             } else {
                 ${target} = ${defaultValue}; 
             }`;
@@ -497,8 +621,11 @@ function tsEnumFromSchema(schema, context) {
       }
       return `${target} += \`"\${${input}}"\``;
     },
-    toQueryStringTemplate(input, target, key) {
-      return `${target}.push(\`${key}=\${${input}}\`)`;
+    setSearchParamTemplate(input, target, key) {
+      if (schema.isNullable) {
+        return `${target}.set('${key}', \`\${${input}}\`);`;
+      }
+      return `${target}.set('${key}', ${input})`;
     },
     content: ""
   };
@@ -506,7 +633,7 @@ function tsEnumFromSchema(schema, context) {
     return result;
   }
   const name = `${context.typePrefix}${enumName}`;
-  const valuesName = `$$${name}Values`;
+  const valuesName = `${name}Values`;
   result.content = `${getJsDocComment(schema.metadata)}export type ${name} = ${schema.enum.map((val) => `'${val}'`).join(" | ")};
 export const ${name} = {
 ${schema.enum.map((val) => {
@@ -516,32 +643,39 @@ ${schema.enum.map((val) => {
     return str;
   }).join("\n")}
 } as const;
-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]}";
+export const ${valuesName} = [${schema.enum.map((val) => `'${val}'`).join(", ")}] as const;`;
+  result.content += `
+export function ${name}New(): ${name} {
+    return ${valuesName}[0];
+}`;
+  if (context.features.validateFn) {
+    result.content += `
+export function ${name}Validate(input: unknown): input is ${name} {
+    return typeof input === 'string' && ${valuesName}.includes(input as any);
+}`;
+  }
+  result.content += `
+export function ${name}FromSerialValue(input: string): ${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]}";
+}`;
+  if (context.features.validatorObj) {
+    result.content += `
+export const $$${name}: ${context.clientName}EnumValidator<${name} > = {
+    new: ${name}New,
+    ${context.features.validateFn ? `validate: ${name}Validate,` : ""} 
+    values: ${valuesName},
+    fromSerialValue: ${name}FromSerialValue,
+}`;
+  }
   context.generatedTypes.push(enumName);
   return result;
 }
@@ -558,6 +692,7 @@ function tsStringFromSchema(schema, _context) {
       }
       return `typeof ${input} === 'string'`;
     },
+    cloneTemplate: defaultCloneTemplate,
     fromJsonTemplate(input, target) {
       if (schema.isNullable) {
         return `${target} = parseNullableString(${input});`;
@@ -574,8 +709,11 @@ function tsStringFromSchema(schema, _context) {
       }
       return `${target} += serializeString(${input});`;
     },
-    toQueryStringTemplate(input, target, key) {
-      return `${target}.push(\`${key}=\${${input}}\`);`;
+    setSearchParamTemplate(input, target, key) {
+      if (schema.isNullable) {
+        return `${target}.set('${key}', \`\${${input}}\`);`;
+      }
+      return `${target}.set('${key}', ${input});`;
     },
     content: ""
   };
@@ -592,6 +730,7 @@ function tsBooleanFromSchema(schema, _context) {
       }
       return `typeof ${input} === 'boolean'`;
     },
+    cloneTemplate: defaultCloneTemplate,
     fromJsonTemplate(input, target) {
       if (schema.isNullable) {
         return `${target} = parseNullableBoolean(${input});`;
@@ -601,8 +740,8 @@ function tsBooleanFromSchema(schema, _context) {
     toJsonTemplate(input, target) {
       return `${target} += \`\${${input}}\`;`;
     },
-    toQueryStringTemplate(input, target, key) {
-      return `${target}.push(\`${key}=\${${input}}\`);`;
+    setSearchParamTemplate(input, target, key) {
+      return `${target}.set('${key}', \`\${${input}}\`);`;
     },
     content: ""
   };
@@ -619,6 +758,16 @@ function tsDateFromSchema(schema, _context) {
       }
       return `${input} instanceof Date`;
     },
+    cloneTemplate(input, target) {
+      if (schema.isNullable) {
+        return `if (${input} !== null) {
+                    ${target} = new Date(${input}.getTime());
+                } else {
+                    ${target} = null;    
+                }`;
+      }
+      return `${target} = new Date(${input}.getTime());`;
+    },
     fromJsonTemplate(input, target) {
       if (schema.isNullable) {
         return `${target} = parseNullableTimestamp(${input});`;
@@ -635,11 +784,11 @@ function tsDateFromSchema(schema, _context) {
       }
       return `${target} += \`"\${${input}.toISOString()}"\``;
     },
-    toQueryStringTemplate(input, target, key) {
+    setSearchParamTemplate(input, target, key) {
       if (schema.isNullable) {
-        return `${target}.push(\`${key}=\${${input}?.toISOString()}\`)`;
+        return `${target}.set('${key}', \`\${${input}?.toISOString()}\`);`;
       }
-      return `${target}.push(\`${key}=\${${input}.toISOString()}\`)`;
+      return `${target}.set('${key}', ${input}.toISOString());`;
     },
     content: ""
   };
@@ -656,6 +805,7 @@ function tsFloatFromSchema(schema, _context) {
       }
       return `typeof ${input} === 'number'`;
     },
+    cloneTemplate: defaultCloneTemplate,
     fromJsonTemplate(input, target) {
       if (schema.isNullable) {
         return `${target} = parseNullableNumberFloat(${input});`;
@@ -665,8 +815,8 @@ function tsFloatFromSchema(schema, _context) {
     toJsonTemplate(input, target) {
       return `${target} += \`\${${input}}\``;
     },
-    toQueryStringTemplate(input, target, key) {
-      return `${target}.push(\`${key}=\${${input}}\`)`;
+    setSearchParamTemplate(input, target, key) {
+      return `${target}.set('${key}', \`\${${input}}\`);`;
     },
     content: ""
   };
@@ -712,6 +862,7 @@ function tsIntFromSchema(schema, intType, _context) {
       }
       return mainPart;
     },
+    cloneTemplate: defaultCloneTemplate,
     fromJsonTemplate(input, target) {
       if (schema.isNullable) {
         return `${target} = parseNullableNumberInt(${input}, ${min}, ${max});`;
@@ -721,8 +872,8 @@ function tsIntFromSchema(schema, intType, _context) {
     toJsonTemplate(input, target) {
       return `${target} += \`\${${input}}\``;
     },
-    toQueryStringTemplate(input, target, key) {
-      return `${target}.push(\`${key}=\${${input}}\`)`;
+    setSearchParamTemplate(input, target, key) {
+      return `${target}.set('${key}', \`\${${input}}\`);`;
     },
     content: ""
   };
@@ -740,6 +891,7 @@ function tsBigIntFromSchema(schema, isUnsigned, _context) {
       }
       return mainPart;
     },
+    cloneTemplate: defaultCloneTemplate,
     fromJsonTemplate(input, target) {
       if (isUnsigned) {
         if (schema.isNullable) {
@@ -762,8 +914,8 @@ function tsBigIntFromSchema(schema, isUnsigned, _context) {
       }
       return `${target} += \`"\${${input}}"\``;
     },
-    toQueryStringTemplate(input, target, key) {
-      return `${target}.push(\`${key}=\${${input}}\`)`;
+    setSearchParamTemplate(input, target, key) {
+      return `${target}.set('${key}', \`\${${input}}\`);`;
     },
     content: ""
   };
@@ -780,8 +932,9 @@ function tsRecordFromSchema(schema, context) {
     discriminatorKey: "",
     discriminatorValue: "",
     versionNumber: context.versionNumber,
-    usedFeatures: context.usedFeatures,
-    rpcGenerators: context.rpcGenerators
+    useRpcTypes: context.useRpcTypes,
+    rpcGenerators: context.rpcGenerators,
+    features: context.features
   });
   const typeName = `Record<string, ${innerType.typeName}>`;
   const defaultValue = schema.isNullable ? "null" : "{}";
@@ -797,6 +950,22 @@ function tsRecordFromSchema(schema, context) {
       }
       return mainPart;
     },
+    cloneTemplate(input, target) {
+      const main = `${target} = {};
+            for (const [_key, _value] of Object.entries(${input})) {
+                let ${target}Value: ${innerType.typeName};
+                ${innerType.cloneTemplate("_value", `${target}Value`)}
+                ${target}[_key] = ${target}Value;
+            }`;
+      if (schema.isNullable) {
+        return `if (${input} !== null) {
+                    ${main}
+                } else {
+                    ${target} = null;    
+                }`;
+      }
+      return main;
+    },
     fromJsonTemplate(input, target) {
       return `if (isObject(${input})) {
                 ${target} = {};
@@ -841,7 +1010,7 @@ function tsRecordFromSchema(schema, context) {
             ${target} += '}';
             `;
     },
-    toQueryStringTemplate(_, __, ___) {
+    setSearchParamTemplate(_, __, ___) {
       return `console.warn('[WARNING] Cannot serialize nested objects to query string. Skipping property at ${context.instancePath}.')`;
     },
     content: innerType.content
@@ -851,19 +1020,29 @@ function tsRecordFromSchema(schema, context) {
 function tsRefFromSchema(schema, context) {
   const typeName = codegenUtils.pascalCase(validVarName(schema.ref), { normalize: true });
   const prefixedTypeName = `${context.typePrefix}${typeName}`;
-  const defaultValue = schema.isNullable ? "null" : `${prefixedTypeName}.new()`;
+  const defaultValue = schema.isNullable ? "null" : `${prefixedTypeName}New()`;
   return {
     typeName: schema.isNullable ? `${prefixedTypeName} | null` : prefixedTypeName,
     defaultValue,
     validationTemplate(input) {
       if (schema.isNullable) {
-        return `($$${prefixedTypeName}.validate(${input}) || ${input} === null)`;
+        return `(${prefixedTypeName}Validate(${input}) || ${input} === null)`;
+      }
+      return `${prefixedTypeName}Validate(${input})`;
+    },
+    cloneTemplate(input, target) {
+      if (schema.isNullable) {
+        return `if (${input} !== null) {
+                    ${target} = ${prefixedTypeName}Clone(${input});
+                } else {
+                    ${target} = null;    
+                }`;
       }
-      return `$$${prefixedTypeName}.validate(${input})`;
+      return `${target} = ${prefixedTypeName}Clone(${input});`;
     },
     fromJsonTemplate(input, target) {
       return `if (isObject(${input})) {
-                    ${target} = $$${prefixedTypeName}.fromJson(${input});
+                    ${target} = ${prefixedTypeName}FromJson(${input});
                 } else {
                     ${target} = ${defaultValue}; 
                 }`;
@@ -871,14 +1050,14 @@ function tsRefFromSchema(schema, context) {
     toJsonTemplate(input, target, _key) {
       if (schema.isNullable) {
         return `if (${input} !== null) {
-                    ${target} += $$${prefixedTypeName}.toJsonString(${input});
+                    ${target} += ${prefixedTypeName}ToJsonString(${input});
                 } else {
                     ${target} += 'null';
                 }`;
       }
-      return `${target} += $$${prefixedTypeName}.toJsonString(${input});`;
+      return `${target} += ${prefixedTypeName}ToJsonString(${input});`;
     },
-    toQueryStringTemplate(_, __, ___) {
+    setSearchParamTemplate(_, __, ___) {
       return `console.warn('[WARNING] Nested objects cannot be serialized to query string. Ignoring property at ${context.instancePath}.');`;
     },
     content: ""
@@ -907,9 +1086,9 @@ function httpRpcFromDefinition(def, context) {
   const key = getRpcKey(context);
   const params = def.params ? `${context.typePrefix}${codegenUtils.pascalCase(validVarName(def.params))}` : void 0;
   const response = def.response ? `${context.typePrefix}${codegenUtils.pascalCase(validVarName(def.response), { normalize: true })}` : void 0;
-  const serializerMethod = def.method === "get" ? "toUrlQueryString" : "toJsonString";
+  const serializerMethod = def.method === "get" ? "ToUrlSearchParamsString" : "ToJsonString";
   if (def.isEventStream) {
-    context.usedFeatures.sse = true;
+    context.useRpcTypes.sse = true;
     return `${getJsDocComment({
       description: def.description,
       isDeprecated: def.isDeprecated
@@ -922,9 +1101,9 @@ function httpRpcFromDefinition(def, context) {
                 headers: this._headers,
                 onError: this._onError,
                 ${params ? "params: params," : ""}
-                responseFromJson: ${response ? `$$${response}.fromJson` : "() => {}"},
-                responseFromString: ${response ? `$$${response}.fromJsonString` : "() => {}"},
-                serializer: ${params ? `$$${params}.${serializerMethod}` : "() => {}"},
+                responseFromJson: ${response ? `${response}FromJson` : "() => {}"},
+                responseFromString: ${response ? `${response}FromJsonString` : "() => {}"},
+                serializer: ${params ? `${params}${serializerMethod}` : "() => {}"},
                 clientVersion: "${context.versionNumber}",
             },
             options,
@@ -942,16 +1121,16 @@ function httpRpcFromDefinition(def, context) {
             headers: this._headers,
             onError: this._onError,
             ${params ? "params: params," : ""}
-            responseFromJson: ${response ? `$$${response}.fromJson` : "() => {}"},
-            responseFromString: ${response ? `$$${response}.fromJsonString` : "() => {}"},
-            serializer: ${params ? `$$${params}.${serializerMethod}` : "() => {}"},
+            responseFromJson: ${response ? `${response}FromJson` : "() => {}"},
+            responseFromString: ${response ? `${response}FromJsonString` : "() => {}"},
+            serializer: ${params ? `${params}${serializerMethod}` : "() => {}"},
             clientVersion: "${context.versionNumber}",
             options: options ?? this._options,
         });
     }`;
 }
 function wsRpcFromDefinition(def, context) {
-  context.usedFeatures.ws = true;
+  context.useRpcTypes.ws = true;
   const key = getRpcKey(context);
   const params = def.params ? `${context.typePrefix}${codegenUtils.pascalCase(validVarName(def.params))}` : void 0;
   const response = def.response ? `${context.typePrefix}${codegenUtils.pascalCase(validVarName(def.response), { normalize: true })}` : void 0;
@@ -959,19 +1138,7 @@ function wsRpcFromDefinition(def, context) {
     description: def.description,
     isDeprecated: def.isDeprecated
   })}    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}",
-        });
+        throw new Error('not implemented');
     }`;
 }
 function getRpcKey(context) {
@@ -994,8 +1161,9 @@ function tsServiceFromDefinition(def, context) {
         instancePath: `${context.instancePath}.${key2}`,
         schemaPath: `${context.instancePath}.${key2}`,
         versionNumber: context.versionNumber,
-        usedFeatures: context.usedFeatures,
-        rpcGenerators: context.rpcGenerators
+        useRpcTypes: context.useRpcTypes,
+        rpcGenerators: context.rpcGenerators,
+        features: context.features
       });
       if (subService.content) {
         subServices.push(subService);
@@ -1013,8 +1181,9 @@ function tsServiceFromDefinition(def, context) {
         discriminatorKey: "",
         discriminatorValue: "",
         versionNumber: context.versionNumber,
-        usedFeatures: context.usedFeatures,
-        rpcGenerators: context.rpcGenerators
+        useRpcTypes: context.useRpcTypes,
+        rpcGenerators: context.rpcGenerators,
+        features: context.features
       });
       if (rpc) {
         rpcParts.push(rpc);
@@ -1109,11 +1278,16 @@ async function createTypescriptClient(def, options) {
     instancePath: "",
     schemaPath: "",
     versionNumber: def.info?.version ?? "",
-    usedFeatures: {
+    useRpcTypes: {
       sse: false,
       ws: false
     },
-    rpcGenerators: options.rpcGenerators ?? {}
+    rpcGenerators: options.rpcGenerators ?? {},
+    features: {
+      validateFn: options.features?.validateFn ?? false,
+      cloneFn: options.features?.cloneFn ?? false,
+      validatorObj: options.features?.validatorObj ?? true
+    }
   };
   const serviceDefinitions = codegenUtils.unflattenProcedures(
     def.procedures,
@@ -1132,13 +1306,37 @@ async function createTypescriptClient(def, options) {
       discriminatorKey: "",
       discriminatorValue: "",
       versionNumber: context.versionNumber,
-      usedFeatures: context.usedFeatures,
-      rpcGenerators: context.rpcGenerators
+      useRpcTypes: context.useRpcTypes,
+      rpcGenerators: context.rpcGenerators,
+      features: context.features
     });
     if (result2.content) {
       types.push(result2.content);
     }
   }
+  let validatorStr = "";
+  if (context.features.validatorObj) {
+    const modelFeatures = [];
+    const enumFeatures = [];
+    modelFeatures.push("new");
+    enumFeatures.push("new");
+    if (context.features.validateFn) {
+      modelFeatures.push("validate");
+      enumFeatures.push("validate");
+    }
+    if (context.features.cloneFn) {
+      modelFeatures.push("clone");
+    }
+    modelFeatures.push("fromJson");
+    modelFeatures.push("fromJsonString");
+    modelFeatures.push("toJsonString");
+    modelFeatures.push("toUrlSearchParams");
+    modelFeatures.push("toUrlSearchParamsString");
+    enumFeatures.push("values");
+    enumFeatures.push("fromSerialValue");
+    validatorStr = `export type ${context.clientName}Validator<T> = ArriModelValidator<T, ${modelFeatures.map((feat) => `'${feat}'`).join(" | ")}>;
+export type ExampleClientEnumValidator<T> = ArriEnumValidator<T, ${enumFeatures.map((feat) => `'${feat}'`).join(" | ")}>;`;
+  }
   const imports = `// This file was autogenerated by @arrirpc/codegen-ts. Do not modify directly.
 // For more information visit https://github.com/modiimedia/arri
 
@@ -1149,9 +1347,8 @@ import {
     ArriModelValidator,
     type ArriRequestOptions,
     arriRequest,
-    ${context.usedFeatures.sse ? "arriSseRequest," : ""}
-    ${context.usedFeatures.ws ? "arriWsRequest," : ""}
-    ${context.usedFeatures.sse ? "type EventSourceController," : ""}
+    ${context.useRpcTypes.sse ? "arriSseRequest," : ""}
+    ${context.useRpcTypes.sse ? "type EventSourceController," : ""}
     INT8_MAX,
     INT8_MIN,
     INT16_MAX,
@@ -1163,7 +1360,6 @@ import {
     isObject,
     parseString,
     parseBoolean,
-    parseNumber,
     parseTimestamp,
     parseNumberInt,
     parseNumberBigInt,
@@ -1177,7 +1373,7 @@ import {
     parseNullableNumberBigInt,
     parseNullableNumberUnsignedBigInt,
     serializeString,
-    ${context.usedFeatures.sse ? "type SseOptions," : ""}
+    ${context.useRpcTypes.sse ? "type SseOptions," : ""}
     UINT8_MAX,
     UINT16_MAX,
     UINT32_MAX,
@@ -1185,11 +1381,12 @@ import {
     type Fetch,
     type $Fetch,
     createFetch,
-    ${context.usedFeatures.ws ? "type WsController," : ""}
-    ${context.usedFeatures.ws ? "type WsOptions," : ""}
+    ${context.useRpcTypes.ws ? "type WsController," : ""}
+    ${context.useRpcTypes.ws ? "type WsOptions," : ""}
 } from "@arrirpc/client";
 
-type HeaderMap = Record<string, string | undefined>;`;
+type HeaderMap = Record<string, string | undefined>;
+${validatorStr}`;
   if (!mainService.content) {
     const result2 = `${imports}
         
@@ -1260,6 +1457,7 @@ function tsTypeFromSchema(schema, context) {
 }
 
 exports.createTypescriptClient = createTypescriptClient;
+exports.defaultCloneTemplate = defaultCloneTemplate;
 exports.defineRpcGenerator = defineRpcGenerator;
 exports.getJsDocComment = getJsDocComment;
 exports.getRpcKey = getRpcKey;