@arrirpc/codegen-rust 0.52.0

package/dist/index.cjs

@@ -0,0 +1,1988 @@
+'use strict';
+
+const node_child_process = require('node:child_process');
+const fs = require('node:fs');
+const codegenUtils = require('@arrirpc/codegen-utils');
+const path = require('pathe');
+const assert = require('assert');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const assert__default = /*#__PURE__*/_interopDefaultCompat(assert);
+
+const reservedKeywords = [
+  "as",
+  "break",
+  "const",
+  "continue",
+  "crate",
+  "else",
+  "enum",
+  "extern",
+  "false",
+  "fn",
+  "for",
+  "if",
+  "impl",
+  "in",
+  "let",
+  "loop",
+  "match",
+  "mod",
+  "move",
+  "mut",
+  "pub",
+  "ref",
+  "return",
+  "self",
+  "Self",
+  "static",
+  "struct",
+  "super",
+  "trait",
+  "true",
+  "type",
+  "unsafe",
+  "use",
+  "where",
+  "while",
+  "async",
+  "await",
+  "dyn",
+  "abstract",
+  "become",
+  "box",
+  "do",
+  "final",
+  "macro",
+  "override",
+  "priv",
+  "typeof",
+  "unsized",
+  "virtual",
+  "yield",
+  "try",
+  "macro_rules",
+  "union",
+  "'static",
+  "dyn"
+];
+const illegalChars = `.!@#$%^&*()-+=\\][{}'";?`;
+const numberChars = "0123456789";
+function validRustIdentifier(key) {
+  const output = codegenUtils.removeDisallowedChars(codegenUtils.snakeCase(key), illegalChars);
+  if (numberChars.includes(output.charAt(0))) {
+    return `r#_${output}`;
+  }
+  if (reservedKeywords.includes(output)) {
+    return `r#${output}`;
+  }
+  return output;
+}
+function validRustName(name) {
+  const output = codegenUtils.removeDisallowedChars(
+    codegenUtils.pascalCase(name, { normalize: true }),
+    illegalChars
+  );
+  if (numberChars.includes(output.charAt(0))) {
+    return `r#_${output}`;
+  }
+  if (reservedKeywords.includes(output)) {
+    return `r#${output}`;
+  }
+  return output;
+}
+path__default.resolve(__dirname, "../.temp");
+function outputIsOptionType(schema, context) {
+  return schema.nullable === true || context.isOptional === true;
+}
+function getTypeName(schema, context) {
+  if (schema.metadata?.id) {
+    return validRustName(schema.metadata.id);
+  }
+  if (context.discriminatorKey && context.discriminatorValue) {
+    const parts = context.instancePath.split("/");
+    const name = validRustName(
+      `${parts.join("_")}_${context.discriminatorValue}`
+    );
+    return name;
+  }
+  return validRustName(context.instancePath.split("/").join("_"));
+}
+function formatDescriptionComment(description, leading = "") {
+  return description.split("\n").map((line) => `${leading}/// ${line}`).join("\n");
+}
+
+function rustAnyFromSchema(schema, context) {
+  return {
+    typeName: context.isOptional ? `Option<serde_json::Value>` : "serde_json::Value",
+    defaultValue: context.isOptional ? `None` : `serde_json::Value::Null`,
+    isNullable: false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                            Some(${innerKey}) => Some(${innerKey}.to_owned()),
+                            _ => None,
+                        }`;
+      }
+      return `match ${input} {
+                        Some(${innerKey}) => ${innerKey}.to_owned(),
+                        _ => serde_json::Value::Null,
+                    }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(
+                        serde_json::to_string(${input})
+                            .unwrap_or("null".to_string())
+                            .as_str(),
+                    )`;
+    },
+    toQueryStringTemplate() {
+      return `println!("[WARNING] cannot serialize any's to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+}
+
+function rustArrayFromSchema(schema, context) {
+  const innerType = rustTypeFromSchema(schema.elements, {
+    instancePath: `${context.instancePath}/element`,
+    schemaPath: `${context.schemaPath}/elements`,
+    clientVersion: context.clientVersion,
+    clientName: context.clientName,
+    typeNamePrefix: context.typeNamePrefix,
+    generatedTypes: context.generatedTypes
+  });
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? `Option<Vec<${innerType.typeName}>>` : `Vec<${innerType.typeName}>`;
+  const defaultValue = isOptionType ? `None` : `Vec::new()`;
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::Array(${innerKey})) => {
+                        let mut ${innerKey}_result: Vec<${innerType.typeName}> = Vec::new();
+                        for ${innerKey}_element in ${innerKey} {
+                            ${innerKey}_result.push(${innerType.fromJsonTemplate(`Some(${innerKey}_element)`, `${innerKey}_element`)});
+                        }
+                        Some(${innerKey}_result)
+                    }
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::Array(${innerKey})) => {
+                    let mut ${innerKey}_result: Vec<${innerType.typeName}> = Vec::new();
+                    for ${innerKey}_element in ${innerKey} {
+                        ${innerKey}_result.push(${innerType.fromJsonTemplate(`Some(${innerKey}_element)`, `${innerKey}_element`)});
+                    }
+                    ${innerKey}_result
+                }
+                _ => Vec::new(),
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      let innerTypeToJson = innerType.toJsonTemplate(`_element_`, target);
+      if (innerType.isNullable) {
+        innerTypeToJson = `match _element_ {
+                    Some(_element_val_) => {
+                        ${innerType.toJsonTemplate(`_element_val_`, target)};
+                    },
+                    _ => {
+                        ${target}.push_str("null");
+                    }
+                }`;
+      }
+      return `${target}.push('[');
+            for (_index_, _element_) in ${input}.iter().enumerate() {
+                if _index_ != 0 {
+                    ${target}.push(',');
+                }
+                ${innerTypeToJson};
+            }
+            ${target}.push(']')`;
+    },
+    toQueryStringTemplate() {
+      return `println!("[WARNING] cannot serialize arrays to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: innerType.content
+  };
+}
+
+function rustTaggedUnionFromSchema(schema, context) {
+  const enumName = `${context.typeNamePrefix}${getTypeName(schema, context)}`;
+  const isOptionType = outputIsOptionType(schema, context);
+  const defaultValue = isOptionType ? "None" : `${enumName}::new()`;
+  const result = {
+    typeName: isOptionType ? `Option<${enumName}>` : enumName,
+    defaultValue,
+    isNullable: isOptionType,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(${innerKey}) => match ${innerKey} {
+                        serde_json::Value::Object(_) => {
+                            Some(${enumName}::from_json(${innerKey}.to_owned()))
+                        }
+                        _ => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(${innerKey}) => match ${innerKey} {
+                    serde_json::Value::Object(_) => {
+                        ${enumName}::from_json(${innerKey}.to_owned())
+                    }
+                    _ => ${enumName}::new(),
+                },
+                _ => ${enumName}::new(),
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_json_string().as_str())`;
+    },
+    toQueryStringTemplate() {
+      return `println!("[WARNING] cannot serialize nested objects to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+  if (context.generatedTypes.includes(enumName)) {
+    return result;
+  }
+  const discriminatorKey = schema.discriminator;
+  const discriminatorValues = Object.keys(schema.mapping);
+  if (discriminatorValues.length === 0)
+    throw new Error(
+      `Discriminator schemas must have at least one subtype. Issue at ${context.schemaPath}.`
+    );
+  const subTypes = [];
+  const subTypeContent = [];
+  const discriminatorKeyProperty = validRustIdentifier(discriminatorKey);
+  const fromJsonParts = [];
+  for (const discriminatorValue of discriminatorValues) {
+    const subTypeName = validRustName(discriminatorValue);
+    const subSchema = schema.mapping[discriminatorValue];
+    const subType = {
+      name: subTypeName,
+      properties: [],
+      toJsonParts: [],
+      toQueryParts: [],
+      isDeprecated: subSchema.metadata?.isDeprecated ?? false,
+      description: subSchema.metadata?.description ?? ""
+    };
+    fromJsonParts.push(`"${discriminatorValue}" => {`);
+    subType.toJsonParts.push(
+      `		_json_output_.push_str("\\"${discriminatorKey}\\":\\"${discriminatorValue}\\"");`
+    );
+    subType.toQueryParts.push(
+      `_query_parts_.push(format!("${discriminatorKey}=${discriminatorValue}"));`
+    );
+    for (const key of Object.keys(subSchema.properties)) {
+      const keySchema = subSchema.properties[key];
+      const keyType = rustTypeFromSchema(keySchema, {
+        clientVersion: context.clientVersion,
+        clientName: context.clientName,
+        typeNamePrefix: context.typeNamePrefix,
+        instancePath: `${context.instancePath}/${key}`,
+        schemaPath: `${context.schemaPath}/mapping/${key}`,
+        generatedTypes: context.generatedTypes,
+        discriminatorKey,
+        discriminatorValue
+      });
+      if (keyType.content)
+        subTypeContent.push(keyType.content);
+      const keyName = validRustIdentifier(key);
+      subType.properties.push({
+        name: keyName,
+        defaultValue: keyType.defaultValue,
+        typeName: keyType.typeName,
+        isDeprecated: keySchema.metadata?.isDeprecated ?? false,
+        description: keySchema.metadata?.description ?? ""
+      });
+      fromJsonParts.push(
+        `let ${keyName} = ${keyType.fromJsonTemplate(`_val_.get("${key}")`, key)};`
+      );
+      subType.toJsonParts.push(
+        `		_json_output_.push_str(",\\"${key}\\":");`
+      );
+      if (keyType.isNullable) {
+        const innerKey = validRustIdentifier(`${key}_val`);
+        subType.toJsonParts.push(`match ${keyName} {
+                    Some(${innerKey}) => {
+                        ${keyType.toJsonTemplate(innerKey, "_json_output_")};
+                    }
+                    _ => {
+                        _json_output_.push_str("null");
+                    }
+                };`);
+      } else {
+        subType.toJsonParts.push(
+          `${keyType.toJsonTemplate(keyName, "_json_output_")};`
+        );
+      }
+      subType.toQueryParts.push(
+        `${keyType.toQueryStringTemplate(keyName, key, "_query_parts_")};`
+      );
+    }
+    for (const key of Object.keys(subSchema.optionalProperties ?? {})) {
+      const keySchema = subSchema.optionalProperties[key];
+      const keyType = rustTypeFromSchema(keySchema, {
+        clientVersion: context.clientVersion,
+        clientName: context.clientName,
+        typeNamePrefix: context.typeNamePrefix,
+        instancePath: `${context.instancePath}/key`,
+        schemaPath: `${context.schemaPath}/mapping/${key}`,
+        generatedTypes: context.generatedTypes,
+        discriminatorKey,
+        discriminatorValue
+      });
+      if (keyType.content)
+        subTypeContent.push(keyType.content);
+      const keyName = validRustIdentifier(key);
+      subType.properties.push({
+        name: keyName,
+        defaultValue: keyType.defaultValue,
+        typeName: keyType.typeName,
+        isDeprecated: keySchema.metadata?.isDeprecated ?? false,
+        description: keySchema.metadata?.description ?? ""
+      });
+      fromJsonParts.push(
+        `let ${keyName} = ${keyType.fromJsonTemplate(`_val_.get("${key}")`, key)};`
+      );
+      subType.toJsonParts.push(
+        `		_json_output_.push_str(",\\"${key}\\":");`
+      );
+      if (keyType.isNullable) {
+        const innerKey = validRustIdentifier(`${key}_val`);
+        subType.toJsonParts.push(`match ${keyName} {
+                    Some(${innerKey}) => {
+                        ${keyType.toJsonTemplate(innerKey, "_json_output_")};
+                    }
+                    _ => {
+                        _json_output_.push_str("null");
+                    }
+                };`);
+      } else {
+        subType.toJsonParts.push(
+          `${keyType.toJsonTemplate(keyName, "_json_output_")};`
+        );
+      }
+    }
+    fromJsonParts.push(`Self::${subTypeName} {
+            ${subType.properties.map((prop) => `${prop.name},`).join("\n")}    
+        }`);
+    fromJsonParts.push(`}`);
+    subTypes.push(subType);
+  }
+  let leading = "";
+  if (schema.metadata?.description) {
+    leading += formatDescriptionComment(schema.metadata.description);
+    leading += "\n";
+  }
+  if (schema.metadata?.isDeprecated) {
+    leading += "#[deprecated]\n";
+  }
+  result.content = `${leading}#[derive(Clone, Debug, PartialEq)]
+pub enum ${enumName} {
+    ${subTypes.map((type) => {
+    let leading2 = "";
+    if (type.description) {
+      leading2 += formatDescriptionComment(type.description);
+      leading2 += "\n";
+    }
+    if (type.isDeprecated) {
+      leading2 += "#[deprecated]\n";
+    }
+    return `${leading2}${type.name} {
+        ${type.properties.map((prop) => {
+      let leading3 = "";
+      if (prop.description) {
+        leading3 += formatDescriptionComment(prop.description);
+        leading3 += "\n";
+      }
+      if (prop.isDeprecated) {
+        leading3 += "#[deprecated]\n";
+      }
+      return `${leading3}${prop.name}: ${prop.typeName},`;
+    }).join("\n")}
+    },`;
+  }).join("\n")}
+}
+
+impl ArriModel for ${enumName} {
+    fn new() -> Self {
+        Self::${subTypes[0].name} {
+            ${subTypes[0]?.properties.map((prop) => `${prop.name}: ${prop.defaultValue},`).join("\n")}
+        }
+    }
+
+    fn from_json(input: serde_json::Value) -> Self {
+        match input {
+            serde_json::Value::Object(_val_) => {
+                let ${discriminatorKeyProperty} = match _val_.get("${discriminatorKey}") {
+                    Some(serde_json::Value::String(${discriminatorKeyProperty}_val)) => ${discriminatorKeyProperty}_val.to_owned(),
+                    _ => "".to_string(),
+                };
+                match ${discriminatorKeyProperty}.as_str() {
+                    ${fromJsonParts.join("\n")}
+                    _ => Self::new(),
+                }
+            }
+            _ => Self::new(),
+        }
+    }
+
+    fn from_json_string(input: String) -> Self {
+        match serde_json::from_str(input.as_str()) {
+            Ok(val) => Self::from_json(val),
+            _ => Self::new(),
+        }
+    }
+
+    fn to_json_string(&self) -> String {
+        let mut _json_output_ = "{".to_string();
+        match &self {
+            ${subTypes.map(
+    (type) => `Self::${type.name} { ${type.properties.map((prop) => `${prop.name},`).join("\n")}} => {
+                ${type.toJsonParts.join("\n")}    
+            }`
+  )}
+        }
+        _json_output_.push('}');
+        _json_output_
+    }
+
+    fn to_query_params_string(&self) -> String {
+        let mut _query_parts_: Vec<String> = Vec::new();
+        match &self {
+            ${subTypes.map(
+    (type) => `Self::${type.name} { ${type.properties.map((prop) => `${prop.name},`).join("\n")}} => {
+                ${type.toQueryParts.join("\n")}
+            }`
+  )}
+        }
+        _query_parts_.join("&")
+    }
+}
+
+${subTypeContent.join("\n\n")}`;
+  context.generatedTypes.push(enumName);
+  return result;
+}
+
+function rustEnumFromSchema(schema, context) {
+  const enumName = `${context.typeNamePrefix}${getTypeName(schema, context)}`;
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? `Option<${enumName}>` : enumName;
+  const defaultValue = isOptionType ? "None" : `${enumName}::default()`;
+  const result = {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::String(${innerKey})) => {
+                        Some(${enumName}::from_string(${innerKey}.to_owned()))
+                    }
+                    _ => None, 
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::String(${innerKey})) => {
+                    ${enumName}::from_string(${innerKey}.to_owned())
+                }
+                _ => ${enumName}::default(),
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(format!("\\"{}\\"", ${input}.serial_value()).as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}.serial_value()));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}.serial_value()));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}.serial_value()))`;
+    },
+    content: ""
+  };
+  if (context.generatedTypes.includes(enumName)) {
+    return result;
+  }
+  let defaultEnumValue = "";
+  const initializationParts = [];
+  const fromStringParts = [];
+  const serialValueParts = [];
+  for (let i = 0; i < schema.enum.length; i++) {
+    const val = schema.enum[i];
+    const valName = validRustName(val);
+    if (i === 0) {
+      defaultEnumValue = valName;
+    }
+    initializationParts.push(`	${valName},`);
+    fromStringParts.push(`			"${val}" => Self::${valName},`);
+    serialValueParts.push(
+      `			${enumName}::${valName} => "${val}".to_string(),`
+    );
+  }
+  let leading = "";
+  if (schema.metadata?.description) {
+    leading += `${formatDescriptionComment(schema.metadata.description)}
+`;
+  }
+  if (schema.metadata?.isDeprecated) {
+    leading += `#[deprecated]
+`;
+  }
+  result.content = `${leading}#[derive(Clone, Debug, PartialEq)]
+pub enum ${enumName} {
+${initializationParts.join("\n")}
+}
+
+impl ArriEnum for ${enumName} {
+    fn default() -> Self {
+        ${enumName}::${defaultEnumValue}
+    }
+    fn from_string(input: String) -> Self {
+        match input.as_str() {
+${fromStringParts.join("\n")}
+            _ => Self::default(),
+        }
+    }
+    fn serial_value(&self) -> String {
+        match &self {
+${serialValueParts.join("\n")}
+        }
+    }
+}`;
+  context.generatedTypes.push(enumName);
+  return result;
+}
+
+function rustObjectFromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const structName = `${context.typeNamePrefix}${getTypeName(schema, context)}`;
+  const typeName = isOptionType ? `Option<${structName}>` : structName;
+  const defaultValue = isOptionType ? `None` : `${structName}::new()`;
+  const result = {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(${innerKey}) => match ${innerKey} {
+                        serde_json::Value::Object(_) => {
+                            Some(${structName}::from_json(${innerKey}.to_owned()))
+                        }
+                        _ => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(${innerKey}) => ${structName}::from_json(${innerKey}.to_owned()),
+                _ => ${structName}::new(),
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_json_string().as_str())`;
+    },
+    toQueryStringTemplate() {
+      return `println!("[WARNING] cannot serialize nested objects to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+  if (context.generatedTypes.includes(structName)) {
+    return result;
+  }
+  const fieldNames = [];
+  const fieldDeclarationParts = [];
+  const defaultParts = [];
+  const fromJsonParts = [];
+  const toJsonParts = [];
+  const toQueryParamParams = [];
+  const subContent = [];
+  const requiredKeys = Object.keys(schema.properties);
+  const optionalKeys = Object.keys(schema.optionalProperties ?? {});
+  const hasKeys = requiredKeys.length > 0;
+  for (let i = 0; i < requiredKeys.length; i++) {
+    const key = requiredKeys[i];
+    const prop = schema.properties[key];
+    const innerType = rustTypeFromSchema(prop, {
+      clientVersion: context.clientVersion,
+      clientName: context.clientName,
+      typeNamePrefix: context.typeNamePrefix,
+      instancePath: `/${structName}/${key}`,
+      schemaPath: `${context.schemaPath}/properties/${key}`,
+      generatedTypes: context.generatedTypes
+    });
+    if (innerType.content) {
+      subContent.push(innerType.content);
+    }
+    const fieldName = validRustIdentifier(key);
+    fieldNames.push(fieldName);
+    let leading2 = "";
+    if (prop.metadata?.description) {
+      leading2 += formatDescriptionComment(prop.metadata.description);
+      leading2 += "\n";
+    }
+    if (prop.metadata?.isDeprecated) {
+      leading2 += `	#[deprecated]
+`;
+    }
+    fieldDeclarationParts.push(
+      `${leading2}	pub ${fieldName}: ${innerType.typeName}`
+    );
+    defaultParts.push(`			${fieldName}: ${innerType.defaultValue}`);
+    fromJsonParts.push(
+      `				let ${fieldName} = ${innerType.fromJsonTemplate(`_val_.get("${key}")`, key)};`
+    );
+    if (i === 0) {
+      toJsonParts.push(`		_json_output_.push_str("\\"${key}\\":");`);
+    } else {
+      toJsonParts.push(`		_json_output_.push_str(",\\"${key}\\":");`);
+    }
+    if (innerType.isNullable) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      toJsonParts.push(`		match &self.${fieldName} {
+                Some(${innerKey}) => {
+                    ${innerType.toJsonTemplate(innerKey, "_json_output_")};
+                }
+                _ => {
+                    _json_output_.push_str("null");
+                }
+            };`);
+    } else {
+      const leading3 = codegenUtils.isSchemaFormElements(prop) || codegenUtils.isSchemaFormValues(prop) ? "" : "&";
+      toJsonParts.push(
+        `		${innerType.toJsonTemplate(`${leading3}self.${fieldName}`, "_json_output_")};`
+      );
+    }
+    toQueryParamParams.push(
+      `		${innerType.toQueryStringTemplate(`&self.${fieldName}`, key, "_query_parts_")};`
+    );
+  }
+  for (let i = 0; i < optionalKeys.length; i++) {
+    const key = optionalKeys[i];
+    const prop = schema.optionalProperties[key];
+    const innerType = rustTypeFromSchema(prop, {
+      clientVersion: context.clientVersion,
+      clientName: context.clientName,
+      typeNamePrefix: context.typeNamePrefix,
+      instancePath: `/${structName}/${key}`,
+      schemaPath: `${context.schemaPath}/optionalProperties/${key}`,
+      generatedTypes: context.generatedTypes,
+      isOptional: true
+    });
+    if (innerType.content) {
+      subContent.push(innerType.content);
+    }
+    const fieldName = validRustIdentifier(key);
+    fieldNames.push(fieldName);
+    let leading2 = prop.metadata?.description ? `${prop.metadata.description.split("\n").map((line) => `	/// ${line}`).join("\n")}
+` : "";
+    if (prop.metadata?.isDeprecated) {
+      leading2 += `	#[deprecated]
+`;
+    }
+    fieldDeclarationParts.push(
+      `${leading2}	pub ${fieldName}: ${innerType.typeName}`
+    );
+    defaultParts.push(`			${fieldName}: ${innerType.defaultValue}`);
+    fromJsonParts.push(
+      `				let ${fieldName} = ${innerType.fromJsonTemplate(`_val_.get("${key}")`, key)};`
+    );
+    if (hasKeys) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      toJsonParts.push(`match &self.${fieldName} {
+                Some(${innerKey}) => {
+                    _json_output_.push_str(",\\"${key}\\":");
+                    ${innerType.toJsonTemplate(innerKey, "_json_output_")}
+                },
+                _ => {}
+            };`);
+    } else {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      toJsonParts.push(`		match &self.${fieldName} {
+                Some(${innerKey}) => {
+                    ${i !== 0 ? `if _has_keys_ {
+                        _json_output_.push(',');
+                    }` : ""}
+                    _json_output_.push_str("\\"${key}\\":");
+                    ${innerType.toJsonTemplate(innerKey, "_json_output_")};
+                    ${i !== optionalKeys.length - 1 ? "_has_keys_ = true;" : ""}
+                }
+                _ => {}
+            };`);
+    }
+    toQueryParamParams.push(
+      `				${innerType.toQueryStringTemplate(`&self.${fieldName}`, key, "_query_parts_")};`
+    );
+  }
+  context.generatedTypes.push(structName);
+  let selfDeclaration = `Self {
+        ${fieldNames.join(",\n				")},
+    }`;
+  if (fieldNames.length < 4) {
+    selfDeclaration = `Self { ${fieldNames.join(", ")} }`;
+  }
+  let leading = "";
+  if (schema.metadata?.description) {
+    leading += `${schema.metadata.description.split("\n").map((line) => `/// ${line}`).join("\n")}
+`;
+  }
+  if (schema.metadata?.isDeprecated) {
+    leading += `#[deprecated]
+`;
+  }
+  result.content = `${leading}#[derive(Clone, Debug, PartialEq)]
+pub struct ${structName} {
+${fieldDeclarationParts.join(",\n")},
+}
+
+impl ArriModel for ${structName} {
+    fn new() -> Self {
+        Self {
+${defaultParts.join(",\n")},
+        }
+    }
+    fn from_json(input: serde_json::Value) -> Self {
+        match input {
+            serde_json::Value::Object(_val_) => {
+${fromJsonParts.join("\n")}
+                ${selfDeclaration}
+            }
+            _ => Self::new(),
+        }
+    }
+    fn from_json_string(input: String) -> Self {
+        match serde_json::from_str(input.as_str()) {
+            Ok(val) => Self::from_json(val),
+            _ => Self::new(),
+        }   
+    }
+    fn to_json_string(&self) -> String {
+        let mut _json_output_ = "{".to_string();
+        ${!hasKeys ? `let mut _has_keys_ = false;` : ""}
+${toJsonParts.join("\n")}
+        _json_output_.push('}');
+        _json_output_
+    }
+    fn to_query_params_string(&self) -> String {
+        let mut _query_parts_: Vec<String> = Vec::new();
+${toQueryParamParams.join("\n")}
+        _query_parts_.join("&")
+    }
+}
+
+${subContent.join("\n\n")}`;
+  return result;
+}
+
+function rustStringFromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const defaultValue = isOptionType ? "None" : '"".to_string()';
+  const typeName = isOptionType ? "Option<String>" : "String";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::String(${innerKey})) => Some(${innerKey}.to_owned()),
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::String(${innerKey})) => ${innerKey}.to_owned(),
+                _ => "".to_string(),
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(serialize_string(${input}).as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+function rustBooleanFromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const defaultValue = isOptionType ? "None" : "false";
+  const typeName = isOptionType ? "Option<bool>" : "bool";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::Bool(${innerKey})) => Some(${innerKey}.to_owned()),
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::Bool(${innerKey})) => ${innerKey}.to_owned(),
+                _ => false,
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_string().as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+function rustTimestampFromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? "Option<DateTime<FixedOffset>>" : "DateTime<FixedOffset>";
+  const defaultValue = isOptionType ? "None" : "DateTime::default()";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::String(${innerKey})) => {
+                        match DateTime::<FixedOffset>::parse_from_rfc3339(${innerKey}) {
+                            Ok(${innerKey}_result) => Some(${innerKey}_result),
+                            Err(_) => None,
+                        }
+                    }
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::String(${innerKey})) => {
+                    DateTime::<FixedOffset>::parse_from_rfc3339(${innerKey})
+                        .unwrap_or(DateTime::default())
+                }
+                _ => DateTime::default(),
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(serialize_date_time(${input}, true).as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!(
+                            "${key}={}",
+                            serialize_date_time(${innerKey}, false)
+                        ));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!(
+                            "${key}={}",
+                            serialize_date_time(${innerKey}, false)
+                        ));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!(
+                "${key}={}",
+                serialize_date_time(${input}, false)
+            ))`;
+    },
+    content: ""
+  };
+}
+function rustF32FromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? `Option<f32>` : "f32";
+  const defaultValue = isOptionType ? `None` : "0.0";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::Number(${innerKey})) => match ${innerKey}.as_f64() {
+                        Some(${innerKey}_result) => Some(${innerKey}_result as f32),
+                        _ => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::Number(${innerKey})) => {
+                    ${innerKey}.as_f64().unwrap_or(0.0) as f32
+                }
+                _ => 0.0,
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_string().as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+function rustF64FromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? `Option<f64>` : "f64";
+  const defaultValue = isOptionType ? `None` : "0.0";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::Number(${innerKey})) => match ${innerKey}.as_f64() {
+                        Some(${innerKey}_result) => Some(${innerKey}_result),
+                        _ => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::Number(${innerKey})) => {
+                    ${innerKey}.as_f64().unwrap_or(0.0)
+                }
+                _ => 0.0,
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_string().as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+function rustI8FromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? `Option<i8>` : "i8";
+  const defaultValue = isOptionType ? `None` : "0";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::Number(${innerKey})) => match ${innerKey}.as_i64() {
+                        Some(${innerKey}_result) => match i8::try_from(${innerKey}_result) {
+                            Ok(${innerKey}_result_val) => Some(${innerKey}_result_val),
+                            Err(_) => None,
+                        },
+                        _ => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::Number(${innerKey})) => {
+                    i8::try_from(${innerKey}.as_i64().unwrap_or(0)).unwrap_or(0)
+                }
+                _ => 0,
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_string().as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+function rustU8FromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? "Option<u8>" : "u8";
+  const defaultValue = isOptionType ? "None" : "0";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::Number(${innerKey})) => match ${innerKey}.as_u64() {
+                        Some(${innerKey}_result) => match u8::try_from(${innerKey}_result) {
+                            Ok(${innerKey}_result_val) => Some(${innerKey}_result_val),
+                            Err(_) => None,
+                        },
+                        _ => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::Number(${innerKey})) => {
+                    u8::try_from(${innerKey}.as_u64().unwrap_or(0)).unwrap_or(0)
+                }
+                _ => 0,
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_string().as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+function rustI16FromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? "Option<i16>" : "i16";
+  const defaultValue = isOptionType ? "None" : "0";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::Number(${innerKey})) => match ${innerKey}.as_i64() {
+                        Some(${innerKey}_result) => match i16::try_from(${innerKey}_result) {
+                            Ok(${innerKey}_result_val) => Some(${innerKey}_result_val),
+                            Err(_) => None,
+                        },
+                        _ => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::Number(${innerKey})) => {
+                    i16::try_from(${innerKey}.as_i64().unwrap_or(0)).unwrap_or(0)
+                }
+                _ => 0,
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_string().as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+function rustU16FromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? "Option<u16>" : "u16";
+  const defaultValue = isOptionType ? "None" : "0";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::Number(${innerKey})) => match ${innerKey}.as_u64() {
+                        Some(${innerKey}_result) => match u16::try_from(${innerKey}_result) {
+                            Ok(${innerKey}_result_val) => Some(${innerKey}_result_val),
+                            Err(_) => None,
+                        },
+                        _ => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::Number(${innerKey})) => {
+                    u16::try_from(${innerKey}.as_u64().unwrap_or(0)).unwrap_or(0)
+                }
+                _ => 0,
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_string().as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+function rustI32FromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? "Option<i32>" : "i32";
+  const defaultValue = isOptionType ? "None" : "0";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::Number(${innerKey})) => match ${innerKey}.as_i64() {
+                        Some(${innerKey}_result) => match i32::try_from(${innerKey}_result) {
+                            Ok(${innerKey}_result_val) => Some(${innerKey}_result_val),
+                            Err(_) => None,
+                        },
+                        _ => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::Number(${innerKey})) => {
+                    i32::try_from(${innerKey}.as_i64().unwrap_or(0)).unwrap_or(0)
+                }
+                _ => 0,
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_string().as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+function rustU32FromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? "Option<u32>" : "u32";
+  const defaultValue = isOptionType ? "None" : "0";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::Number(${innerKey})) => match ${innerKey}.as_u64() {
+                        Some(${innerKey}_result) => match u32::try_from(${innerKey}_result) {
+                            Ok(${innerKey}_result_val) => Some(${innerKey}_result_val),
+                            Err(_) => None,
+                        },
+                        _ => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::Number(${innerKey})) => {
+                    u32::try_from(${innerKey}.as_u64().unwrap_or(0)).unwrap_or(0)
+                }
+                _ => 0,
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_string().as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+function rustI64FromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? "Option<i64>" : "i64";
+  const defaultValue = isOptionType ? "None" : "0";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::String(${innerKey})) => match ${innerKey}.parse::<i64>() {
+                        Ok(${innerKey}_result) => Some(${innerKey}_result),
+                        Err(_) => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::String(${innerKey})) => {
+                    ${innerKey}.parse::<i64>().unwrap_or(0)
+                }
+                _ => 0,
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(format!("\\"{}\\"", ${input}).as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+function rustU64FromSchema(schema, context) {
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? "Option<u64>" : "u64";
+  const defaultValue = isOptionType ? "None" : "0";
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::String(${innerKey})) => match ${innerKey}.parse::<u64>() {
+                        Ok(${innerKey}_result) => Some(${innerKey}_result),
+                        Err(_) => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::String(${innerKey})) => {
+                    ${innerKey}.parse::<u64>().unwrap_or(0)
+                }
+                _ => 0,
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(format!("\\"{}\\"", ${input}).as_str())`;
+    },
+    toQueryStringTemplate(input, key, target) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (context.isOptional) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {}
+                }`;
+      }
+      if (schema.nullable) {
+        return `match ${input} {
+                    Some(${innerKey}) => {
+                        ${target}.push(format!("${key}={}", ${innerKey}));
+                    }
+                    _ => {
+                        ${target}.push("${key}=null".to_string());
+                    }
+                }`;
+      }
+      return `${target}.push(format!("${key}={}", ${input}))`;
+    },
+    content: ""
+  };
+}
+
+function rustRpcFromSchema(schema, context) {
+  switch (schema.transport) {
+    case "http":
+      return rustHttpRpcFromSchema(schema, context);
+    case "ws":
+      return rustWsRpcFromSchema(schema, context);
+    default:
+      console.warn(
+        `[rust-codegen] Unknown transport type "${schema.transport}". Skipping ${context.instancePath}.`
+      );
+      return "";
+  }
+}
+function rustHttpRpcFromSchema(schema, context) {
+  if (schema.isEventStream) {
+    console.warn(
+      `[rust-codegen] SSE is not supported at this time. Skipping ${context.instancePath}.`
+    );
+    return "";
+  }
+  const functionName = getFunctionName(context.instancePath);
+  const params = schema.params ? validRustName(schema.params) : void 0;
+  const response = schema.response ? validRustName(schema.response) : void 0;
+  let leading = "";
+  if (schema.description) {
+    leading += formatDescriptionComment(schema.description);
+    leading += "\n";
+  }
+  if (schema.isDeprecated) {
+    leading += "#[deprecated]\n";
+  }
+  return `${leading}pub async fn ${functionName} (
+        self: &Self,
+        ${params ? `params: ${context.typeNamePrefix}${params},` : ""}
+    ) -> Result<${context.typeNamePrefix}${response ?? "()"}, ArriServerError> {
+        parsed_arri_request(
+            ArriParsedRequestOptions {
+                http_client: &self.config.http_client,
+                url: format!("{}${schema.path}", &self.config.base_url),
+                method: reqwest::Method::${schema.method.toUpperCase()},
+                headers: self.config.headers,
+                client_version: "${context.clientVersion}".to_string(),
+            },
+            ${params ? `Some(params)` : "None::<EmptyArriModel>"},
+            |body| ${response ? `return ${context.typeNamePrefix}${response}::from_json_string(body)` : "{}"},
+        )
+        .await
+    }`;
+}
+function rustWsRpcFromSchema(schema, context) {
+  console.warn(
+    `[rust-codegen] WS RPCs are not supported at this time. Skipping ${context.instancePath}.`
+  );
+  return "";
+}
+function getFunctionName(instancePath) {
+  assert__default(instancePath.length > 0);
+  const name = instancePath.split(".").pop() ?? "";
+  return validRustIdentifier(name);
+}
+function getServiceName(instancePath, context) {
+  assert__default(instancePath.length > 0);
+  const name = instancePath.split(".").join("_");
+  return validRustName(`${context.clientName}_${name}_Service`);
+}
+function rustServiceFromSchema(schema, context) {
+  const serviceName = getServiceName(context.instancePath, context);
+  const subServices = [];
+  const subServiceContent = [];
+  const rpcParts = [];
+  for (const key of Object.keys(schema)) {
+    const subSchema = schema[key];
+    if (codegenUtils.isServiceDefinition(subSchema)) {
+      const subService = rustServiceFromSchema(subSchema, {
+        clientVersion: context.clientVersion,
+        clientName: context.clientName,
+        typeNamePrefix: context.typeNamePrefix,
+        instancePath: `${context.instancePath}.${key}`,
+        schemaPath: `${context.schemaPath}.${key}`,
+        generatedTypes: context.generatedTypes
+      });
+      if (subService.content) {
+        subServices.push({
+          key: validRustIdentifier(key),
+          name: subService.name
+        });
+      }
+      continue;
+    }
+    if (codegenUtils.isRpcDefinition(subSchema)) {
+      const rpc = rustRpcFromSchema(subSchema, {
+        clientVersion: context.clientVersion,
+        clientName: context.clientName,
+        typeNamePrefix: context.typeNamePrefix,
+        instancePath: `${context.instancePath}.${key}`,
+        schemaPath: `${context.schemaPath}.${key}`,
+        generatedTypes: context.generatedTypes
+      });
+      if (rpc) {
+        rpcParts.push(rpc);
+      }
+      continue;
+    }
+    throw new Error(
+      `[rust-codegen] Invalid schema at /procedures/${context.instancePath}.`
+    );
+  }
+  return {
+    name: serviceName,
+    content: `pub struct ${serviceName}<'a> {
+    config: &'a ArriClientConfig,
+${subServices.map((service) => `    pub ${service.key}: ${service.name}<'a>,`).join("\n")}
+}
+
+impl<'a> ArriClientService<'a> for ${serviceName}<'a> {
+    fn create(config: &'a ArriClientConfig) -> Self {
+        Self {
+            config: &config,
+${subServices.map((service) => `            ${service.key}: ${service.name}::create(config),`).join("\n")}
+        }
+    }
+}
+
+impl ${serviceName}<'_> {
+${rpcParts.join("\n")}
+}
+
+${subServiceContent.join("\n\n")}
+`
+  };
+}
+
+function rustRecordFromSchema(schema, context) {
+  const innerType = rustTypeFromSchema(schema.values, {
+    clientVersion: context.clientVersion,
+    clientName: context.clientName,
+    typeNamePrefix: context.typeNamePrefix,
+    instancePath: `${context.instancePath}/value`,
+    schemaPath: `${context.schemaPath}/values`,
+    generatedTypes: context.generatedTypes
+  });
+  const isOptionType = outputIsOptionType(schema, context);
+  const typeName = isOptionType ? `Option<BTreeMap<String, ${innerType.typeName}>>` : `BTreeMap<String, ${innerType.typeName}>`;
+  const defaultValue = isOptionType ? `None` : `BTreeMap::new()`;
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(serde_json::Value::Object(${innerKey})) => {
+                        let mut ${innerKey}_result: BTreeMap<String, ${innerType.typeName}> = BTreeMap::new();
+                        for (_key_, _value_) in ${innerKey}.into_iter() {
+                            ${innerKey}_result.insert(
+                                _key_.to_owned(),
+                                ${innerType.fromJsonTemplate(`Some(_value_.to_owned())`, `value`)},
+                            );
+                        }
+                        Some(${innerKey}_result)
+                    }
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(serde_json::Value::Object(${innerKey})) => {
+                    let mut ${innerKey}_result: BTreeMap<String, ${innerType.typeName}> = BTreeMap::new();
+                    for (_key_, _value_) in ${innerKey}.into_iter() {
+                        ${innerKey}_result.insert(
+                            _key_.to_owned(),
+                            ${innerType.fromJsonTemplate(`Some(_value_.to_owned())`, `value`)},
+                        );
+                    }
+                    ${innerKey}_result
+                }
+                _ => BTreeMap::new(),
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      if (innerType.isNullable) {
+        return `${target}.push('{');
+            for (_index_, (_key_, _value_)) in ${input}.iter().enumerate() {
+                if _index_ != 0 {
+                    ${target}.push(',');
+                }
+                ${target}.push_str(format!("\\"{}\\":", _key_).as_str());
+                match _value_ {
+                    Some(value_val) => {
+                        ${innerType.toJsonTemplate("value_val", target)};
+                    },
+                    _ => {
+                        ${target}.push_str("null");
+                    }
+                }
+            }
+            ${target}.push('}')`;
+      }
+      return `${target}.push('{');
+            for (_index_, (_key_, _value_)) in ${input}.iter().enumerate() {
+                if _index_ != 0 {
+                    ${target}.push(',');
+                }
+                ${target}.push_str(format!("\\"{}\\":", _key_).as_str());
+                ${innerType.toJsonTemplate(`_value_`, target)};
+            }
+            ${target}.push('}')`;
+    },
+    toQueryStringTemplate() {
+      return `println!("[WARNING] cannot serialize nested objects to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: innerType.content
+  };
+}
+
+function rustRefFromSchema(schema, context) {
+  const innerTypeName = `${context.typeNamePrefix}${validRustName(schema.ref)}`;
+  const isOptionType = outputIsOptionType(schema, context);
+  let typeName = `Box<${innerTypeName}>`;
+  if (isOptionType) {
+    typeName = `Option<${typeName}>`;
+  }
+  let defaultValue;
+  if (isOptionType) {
+    defaultValue = "None";
+  } else {
+    defaultValue = `Box::new(${innerTypeName}::new())`;
+  }
+  return {
+    typeName,
+    defaultValue,
+    isNullable: schema.nullable ?? false,
+    fromJsonTemplate(input, key) {
+      const innerKey = validRustIdentifier(`${key}_val`);
+      const valFromJson = (input2) => {
+        {
+          return `Box::new(${innerTypeName}::from_json(${input2}.to_owned()))`;
+        }
+      };
+      if (isOptionType) {
+        return `match ${input} {
+                    Some(${innerKey}) => match ${innerKey} {
+                        serde_json::Value::Object(_) => {
+                            Some(${valFromJson(innerKey)})
+                        }
+                        _ => None,
+                    },
+                    _ => None,
+                }`;
+      }
+      return `match ${input} {
+                Some(${innerKey}) => match ${innerKey} {
+                    serde_json::Value::Object(_) => {
+                        ${valFromJson(innerKey)}
+                    }
+                    _ => ${valFromJson(innerKey)},
+                },
+                _ => Box::new(${innerTypeName}::new()),
+            }`;
+    },
+    toJsonTemplate(input, target) {
+      return `${target}.push_str(${input}.to_json_string().as_str())`;
+    },
+    toQueryStringTemplate() {
+      return `println!("[WARNING] cannot serialize nested objects to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+}
+
+const rustClientGenerator = codegenUtils.defineGeneratorPlugin(
+  (options) => {
+    return {
+      generator(def) {
+        const context = {
+          clientVersion: def.info?.version ?? "",
+          clientName: options.clientName ?? "Client",
+          typeNamePrefix: options.typePrefix ?? "",
+          instancePath: "",
+          schemaPath: "",
+          generatedTypes: []
+        };
+        const client = createRustClient(def, {
+          ...context
+        });
+        const outputFile = path__default.resolve(options.outputFile);
+        fs__default.writeFileSync(outputFile, client);
+        const shouldFormat = options.format ?? true;
+        if (shouldFormat) {
+          try {
+            node_child_process.execSync(`rustfmt ${outputFile} --edition 2021`, {
+              stdio: "inherit"
+            });
+          } catch (err) {
+            console.error(`Error formatting`, err);
+          }
+        }
+      },
+      options
+    };
+  }
+);
+function createRustClient(def, context) {
+  const services = codegenUtils.unflattenProcedures(def.procedures);
+  const rpcParts = [];
+  const subServices = [];
+  const subServiceContent = [];
+  for (const key of Object.keys(services)) {
+    const subDef = services[key];
+    if (codegenUtils.isServiceDefinition(subDef)) {
+      const service = rustServiceFromSchema(subDef, {
+        clientVersion: def.info?.version ?? "",
+        clientName: context.clientName,
+        typeNamePrefix: context.typeNamePrefix,
+        instancePath: key,
+        schemaPath: key,
+        generatedTypes: context.generatedTypes
+      });
+      if (service.content) {
+        subServices.push({
+          key: validRustIdentifier(key),
+          name: service.name
+        });
+        subServiceContent.push(service.content);
+      }
+      continue;
+    }
+    if (codegenUtils.isRpcDefinition(subDef)) {
+      const rpc = rustRpcFromSchema(subDef, {
+        clientVersion: def.info?.version ?? "",
+        clientName: context.clientName,
+        typeNamePrefix: context.typeNamePrefix,
+        instancePath: key,
+        schemaPath: key,
+        generatedTypes: context.generatedTypes
+      });
+      if (rpc) {
+        rpcParts.push(rpc);
+      }
+      continue;
+    }
+  }
+  const modelParts = [];
+  for (const key of Object.keys(def.definitions)) {
+    const result = rustTypeFromSchema(def.definitions[key], {
+      ...context,
+      clientVersion: def.info?.version ?? "",
+      instancePath: key,
+      schemaPath: ""
+    });
+    if (result.content) {
+      modelParts.push(result.content);
+    }
+  }
+  if (rpcParts.length === 0 && subServiceContent.length === 0) {
+    return `#![allow(dead_code, unused_imports, unused_variables, unconditional_recursion, deprecated)]
+use arri_client::{
+    chrono::{DateTime, FixedOffset},
+    serde_json::{self},
+    utils::{serialize_date_time, serialize_string},
+    ArriEnum, ArriModel,
+};
+use std::collections::BTreeMap;
+${modelParts.join("\n\n")}`;
+  }
+  const clientName = validRustName(context.clientName);
+  return `#![allow(dead_code, unused_imports, unused_variables, unconditional_recursion, deprecated)]
+use arri_client::{
+    chrono::{DateTime, FixedOffset},
+    parsed_arri_request, reqwest, serde_json,
+    utils::{serialize_date_time, serialize_string},
+    ArriClientConfig, ArriClientService, ArriEnum, ArriModel, ArriParsedRequestOptions,
+    ArriServerError, EmptyArriModel,
+};
+use std::collections::BTreeMap;
+
+pub struct ${clientName}<'a> {
+    config: &'a ArriClientConfig,
+${subServices.map((service) => `    pub ${service.key}: ${service.name}<'a>,`).join("\n")}
+}
+
+impl<'a> ArriClientService<'a> for ${clientName}<'a> {
+    fn create(config: &'a ArriClientConfig) -> Self {
+        Self {
+            config: &config,
+${subServices.map((service) => `            ${service.key}: ${service.name}::create(config),`).join("\n")}
+        }
+    }
+}
+
+impl ${clientName}<'_> {
+${rpcParts.join("\n")}
+}
+
+${subServiceContent.join("\n\n")}
+
+${modelParts.join("\n\n")}`;
+}
+function rustTypeFromSchema(schema, context) {
+  if (codegenUtils.isSchemaFormType(schema)) {
+    switch (schema.type) {
+      case "string":
+        return rustStringFromSchema(schema, context);
+      case "boolean":
+        return rustBooleanFromSchema(schema, context);
+      case "timestamp":
+        return rustTimestampFromSchema(schema, context);
+      case "float32":
+        return rustF32FromSchema(schema, context);
+      case "float64":
+        return rustF64FromSchema(schema, context);
+      case "int8":
+        return rustI8FromSchema(schema, context);
+      case "uint8":
+        return rustU8FromSchema(schema, context);
+      case "int16":
+        return rustI16FromSchema(schema, context);
+      case "uint16":
+        return rustU16FromSchema(schema, context);
+      case "int32":
+        return rustI32FromSchema(schema, context);
+      case "uint32":
+        return rustU32FromSchema(schema, context);
+      case "int64":
+        return rustI64FromSchema(schema, context);
+      case "uint64":
+        return rustU64FromSchema(schema, context);
+      default:
+        schema.type;
+        throw new Error(`Unhandled schema type: "${schema.type}"`);
+    }
+  }
+  if (codegenUtils.isSchemaFormProperties(schema)) {
+    return rustObjectFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormEnum(schema)) {
+    return rustEnumFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormElements(schema)) {
+    return rustArrayFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormValues(schema)) {
+    return rustRecordFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormDiscriminator(schema)) {
+    return rustTaggedUnionFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormRef(schema)) {
+    return rustRefFromSchema(schema, context);
+  }
+  return rustAnyFromSchema(schema, context);
+}
+
+exports.createRustClient = createRustClient;
+exports.rustClientGenerator = rustClientGenerator;
+exports.rustTypeFromSchema = rustTypeFromSchema;