vovk-rust 0.0.1-beta.15 → 0.0.1-beta.16

package/client-templates/rsSrc/http_request.rs

@@ -46,6 +46,8 @@ fn prepare_request<B, Q, P>(
     handler_name: &str,
     body: Option<&B>,
     form: Option<multipart::Form>,
+    text_body: Option<String>,
+    binary_body: Option<(Vec<u8>, String)>,
     query: Option<&Q>,
     params: Option<&P>,
     headers: Option<&HashMap<String, String>>,
@@ -111,8 +113,8 @@ where
         .transpose()
         .map_err(|e| format!("Failed to serialize params: {}", e))?;
 
-    // Perform JSON validation if not disabled and no form data is provided
-    if !disable_client_validation && form.is_none() {
+    // Perform JSON validation if not disabled and no form/text/binary data is provided
+    if !disable_client_validation && form.is_none() && text_body.is_none() && binary_body.is_none() {
         if let Some(body_schema) = validation.get("body") {
             if let Some(ref body_val) = body_value {
                 let schema =
@@ -189,8 +191,12 @@ where
     // Set up request headers
     let mut headers_map = reqwest::header::HeaderMap::new();
     headers_map.insert("Accept", "application/jsonl, application/json".parse().unwrap());
-    if body_value.is_some() && form.is_none() {
+    if body_value.is_some() && form.is_none() && text_body.is_none() && binary_body.is_none() {
         headers_map.insert("Content-Type", "application/json".parse().unwrap());
+    } else if text_body.is_some() {
+        headers_map.insert("Content-Type", "text/plain".parse().unwrap());
+    } else if let Some((_, ref content_type)) = binary_body {
+        headers_map.insert("Content-Type", content_type.parse().unwrap());
     }
 
     // Merge with user-provided headers if any
@@ -220,9 +226,13 @@ where
     let client = Client::new();
     let mut request = client.request(method, &url).headers(headers_map);
     
-    // Apply form data or JSON body to the request
+    // Apply form data, text body, binary body, or JSON body to the request
     if let Some(form_data) = form {
         request = request.multipart(form_data);
+    } else if let Some(text) = text_body {
+        request = request.body(text);
+    } else if let Some((bytes, _)) = binary_body {
+        request = request.body(bytes);
     } else if let Some(body_val) = body_value {
         request = request.json(&body_val);
     }
@@ -239,6 +249,8 @@ pub async fn http_request<T, B, Q, P>(
     handler_name: &str,
     body: Option<&B>,
     form: Option<multipart::Form>,
+    text_body: Option<String>,
+    binary_body: Option<(Vec<u8>, String)>,
     query: Option<&Q>,
     params: Option<&P>,
     headers: Option<&HashMap<String, String>>,
@@ -258,6 +270,8 @@ where
         handler_name,
         body,
         form,
+        text_body,
+        binary_body,
         query,
         params,
         headers,
@@ -344,6 +358,8 @@ pub async fn http_request_stream<T, B, Q, P>(
     handler_name: &str,
     body: Option<&B>,
     form: Option<multipart::Form>,
+    text_body: Option<String>,
+    binary_body: Option<(Vec<u8>, String)>,
     query: Option<&Q>,
     params: Option<&P>,
     headers: Option<&HashMap<String, String>>,
@@ -363,6 +379,8 @@ where
         handler_name,
         body,
         form,
+        text_body,
+        binary_body,
         query,
         params,
         headers,

package/client-templates/rsSrc/lib.rs.ejs

@@ -45,8 +45,20 @@ vars.convertJSONSchemasToRustTypes({
     validation?.query?.description ? `Query: ${validation?.query?.description}`: '',
     validation?.output?.description ? `Returns: ${validation?.output?.description}`: ''
 ]).filter(Boolean).map((s) => s.split('\n')).flat().map((s) => ' '.repeat(4) + '/// ' + s).join('\n') %>
+<%
+    // Determine body kind: 'none', 'form', 'binary', 'text', or 'json'
+    const bodyKind = (() => {
+        if (!validation?.body) return 'none';
+        const ct = validation.body['x-contentType'];
+        if (ct?.includes('multipart/form-data') || ct?.includes('application/x-www-form-urlencoded')) return 'form';
+        if (validation.body.format === 'binary' || validation.body.contentEncoding === 'binary') return 'binary';
+        if (ct?.some(c => c.startsWith('text/'))) return 'text';
+        return 'json';
+    })();
+    const firstContentType = validation?.body?.['x-contentType']?.[0] || 'application/octet-stream';
+%>
     pub async fn <%= handlerName %>( 
-        body: <%- validation?.body ? (validation?.body?.['x-isForm'] ?'reqwest::multipart::Form' : `${handlerName}_::body`): '()' %>,
+        body: <%- bodyKind === 'form' ? 'reqwest::multipart::Form' : bodyKind !== 'none' ? `${handlerName}_::body` : '()' %>,
         query: <%- validation?.query ? `${handlerName}_::query` : '()' %>,
         params: <%- validation?.params ? `${handlerName}_::params` : '()' %>,
         headers: Option<&HashMap<String, String>>,
@@ -56,7 +68,7 @@ vars.convertJSONSchemasToRustTypes({
         let result = <%= validation?.iteration ? 'http_request_stream' : 'http_request' %>::<
 <%- [
                 validation?.output ? `${handlerName}_::output` : validation?.iteration ? `${handlerName}_::iteration` : 'serde_json::Value',
-                validation?.body && !validation?.body?.['x-isForm'] ? `${handlerName}_::body` : '()',
+                bodyKind === 'json' ? `${handlerName}_::body` : '()',
                 validation?.query ? `${handlerName}_::query` : '()',
                 validation?.params ? `${handlerName}_::params` : '()'
             ].filter(Boolean).map((s) => ' '.repeat(12) + s).join(',\n') %>
@@ -65,8 +77,10 @@ vars.convertJSONSchemasToRustTypes({
             "<%= segmentName %>",
             "<%= controllerSchema.rpcModuleName %>",
             "<%= handlerNameOriginal %>",
-            <%- !validation?.body || !validation?.body?.['x-isForm'] ? `Some(&body)` : 'None' %>,
-            <%- validation?.body && validation?.body?.['x-isForm'] ? `Some(body)` : 'None' %>,
+            <%- bodyKind === 'json' ? 'Some(&body)' : 'None' %>,
+            <%- bodyKind === 'form' ? 'Some(body)' : 'None' %>,
+            <%- bodyKind === 'text' ? 'Some(body)' : 'None' %>,
+            <%- bodyKind === 'binary' ? `Some((body, "${firstContentType}".to_string()))` : 'None' %>,
             Some(&query),
             Some(&params),
             headers,

package/index.js

@@ -1,499 +1,611 @@
+// Rust reserved keywords that cannot be used as identifiers
+const RUST_KEYWORDS = new Set([
+    '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',
+    'union',
+]);
 // Helper function for indentation
 export function indent(level, pad = 0) {
-  return ' '.repeat(pad + level * 2);
+    return ' '.repeat(pad + level * 2);
 }
 // Generate documentation comments from title and description
 export function generateDocComment(schema, level, pad = 0) {
-  if (!schema?.title && !schema?.description) return '';
-  let comment = '';
-  if (schema.title) {
-    comment += `${indent(level, pad)}/// ${schema.title}\n`;
-    if (schema.description) {
-      comment += `${indent(level, pad)}///\n`;
+    if (!schema?.title && !schema?.description)
+        return '';
+    let comment = '';
+    if (schema.title) {
+        comment += `${indent(level, pad)}/// ${schema.title}\n`;
+        if (schema.description) {
+            comment += `${indent(level, pad)}///\n`;
+        }
     }
-  }
-  if (schema.description) {
-    // Split description into lines and add /// to each line
-    const lines = schema.description.split('\n');
-    for (const line of lines) {
-      comment += `${indent(level, pad)}/// ${line}\n`;
+    if (schema.description) {
+        // Split description into lines and add /// to each line
+        const lines = schema.description.split('\n');
+        for (const line of lines) {
+            comment += `${indent(level, pad)}/// ${line}\n`;
+        }
     }
-  }
-  return comment;
+    return comment;
 }
 // Track processed $refs to avoid circular references
 const processedRefs = new Set();
 // Resolve $ref paths in the schema
 export function resolveRef(ref, rootSchema) {
-  if (processedRefs.has(ref)) {
-    // Circular reference detected, return a placeholder
-    return { type: 'string' };
-  }
-  processedRefs.add(ref);
-  // Format: #/$defs/TypeName or #/components/schemas/TypeName or #/definitions/TypeName etc.
-  const parts = ref.split('/').filter((part) => part && part !== '#');
-  // Standard path traversal
-  let current = rootSchema;
-  for (const part of parts) {
-    if (!current || typeof current !== 'object') {
-      // If standard traversal fails and the path might be a definition reference
-      if (parts.includes('definitions') && rootSchema.definitions) {
-        // Try to access the definition directly using the last part as the key
-        const definitionKey = parts[parts.length - 1];
-        return rootSchema.definitions[definitionKey];
-      }
-      return undefined;
+    if (processedRefs.has(ref)) {
+        // Circular reference detected, return a placeholder
+        return { type: 'string' };
+    }
+    processedRefs.add(ref);
+    // Format: #/$defs/TypeName or #/components/schemas/TypeName or #/definitions/TypeName etc.
+    const parts = ref.split('/').filter((part) => part && part !== '#');
+    // Standard path traversal
+    let current = rootSchema;
+    for (const part of parts) {
+        if (!current || typeof current !== 'object') {
+            // If standard traversal fails and the path might be a definition reference
+            if (parts.includes('definitions') && rootSchema.definitions) {
+                // Try to access the definition directly using the last part as the key
+                const definitionKey = parts[parts.length - 1];
+                return rootSchema.definitions[definitionKey];
+            }
+            return undefined;
+        }
+        current = current[part];
+    }
+    // If the resolved schema also has a $ref, resolve it recursively
+    if (current && current.$ref) {
+        return resolveRef(current.$ref, rootSchema);
     }
-    current = current[part];
-  }
-  // If the resolved schema also has a $ref, resolve it recursively
-  if (current && current.$ref) {
-    return resolveRef(current.$ref, rootSchema);
-  }
-  processedRefs.delete(ref);
-  return current;
+    processedRefs.delete(ref);
+    return current;
 }
 // Generate module path for nested types
 export function getModulePath(path) {
-  if (path.length <= 1) return path[0];
-  let result = '';
-  for (let i = 0; i < path.length - 1; i++) {
-    result += path[i] + '_::';
-  }
-  result += path[path.length - 1];
-  return result;
+    if (path.length <= 1)
+        return path[0];
+    let result = '';
+    for (let i = 0; i < path.length - 1; i++) {
+        result += path[i] + '_::';
+    }
+    result += path[path.length - 1];
+    return result;
 }
 // Convert JSON Schema type to Rust type
 export function toRustType(schema, path, rootSchema = schema) {
-  if (!schema) return 'String';
-  // Handle $ref first
-  if (schema.$ref) {
-    const resolvedSchema = resolveRef(schema.$ref, rootSchema);
-    if (resolvedSchema) {
-      // Extract type name from ref path for better type naming
-      const refName = schema.$ref.split('/').pop();
-      // Use the ref name directly if it's a definition reference
-      if (schema.$ref.includes('definitions/') || schema.$ref.includes('$defs/')) {
-        return refName || 'String';
-      }
-      return toRustType(resolvedSchema, refName ? [...path.slice(0, -1), refName] : path, rootSchema);
+    if (!schema)
+        return 'String';
+    // Handle $ref first
+    if (schema.$ref) {
+        const resolvedSchema = resolveRef(schema.$ref, rootSchema);
+        if (resolvedSchema) {
+            // Extract type name from ref path for better type naming
+            const refName = schema.$ref.split('/').pop();
+            // Use the ref name directly if it's a definition reference
+            if (schema.$ref.includes('definitions/') || schema.$ref.includes('$defs/')) {
+                return refName || 'String';
+            }
+            return toRustType(resolvedSchema, refName ? [...path.slice(0, -1), refName] : path, rootSchema);
+        }
+        return 'serde_json::Value'; // Fallback for unresolved $ref
     }
-    return 'serde_json::Value'; // Fallback for unresolved $ref
-  }
-  // Check for enum without type (assume string)
-  if (schema.enum) {
-    if (schema.type === 'string' || !schema.type) {
-      return `${getModulePath(path)}`;
+    // Check for enum without type (assume string)
+    if (schema.enum) {
+        if (schema.type === 'string' || !schema.type) {
+            return `${getModulePath(path)}`;
+        }
     }
-  }
-  if (schema.type === 'string') {
-    return 'String';
-  } else if (schema.type === 'number' || schema.type === 'integer') {
-    // Handle numeric types with constraints
-    if (schema.type === 'integer') {
-      // Determine integer type based on min/max constraints
-      const min =
-        typeof schema.minimum === 'number'
-          ? schema.minimum
-          : typeof schema.exclusiveMinimum === 'number'
-            ? schema.exclusiveMinimum + 1
-            : undefined;
-      const max =
-        typeof schema.maximum === 'number'
-          ? schema.maximum
-          : typeof schema.exclusiveMaximum === 'number'
-            ? schema.exclusiveMaximum - 1
-            : undefined;
-      // Check if we need unsigned (no negative values)
-      if (min !== undefined && min >= 0) {
-        // Choose appropriate unsigned int size
-        if (max !== undefined) {
-          if (max <= 255) return 'u8';
-          if (max <= 65535) return 'u16';
-          if (max <= 4294967295) return 'u32';
-        }
-        return 'u64'; // Default unsigned
-      } else {
-        // Choose appropriate signed int size
-        if (min !== undefined && max !== undefined) {
-          const absMin = Math.abs(min);
-          const absMax = Math.abs(max);
-          const maxVal = Math.max(absMin - 1, absMax);
-          if (maxVal <= 127) return 'i8';
-          if (maxVal <= 32767) return 'i16';
-          if (maxVal <= 2147483647) return 'i32';
-        }
-        return 'i64'; // Default signed
-      }
-    } else {
-      // Floating point
-      const hasLowRange =
-        (schema.minimum !== undefined &&
-          schema.maximum !== undefined &&
-          Math.abs(schema.maximum - schema.minimum) <= 3.4e38) ||
-        (schema.exclusiveMinimum !== undefined &&
-          schema.exclusiveMaximum !== undefined &&
-          Math.abs(schema.exclusiveMaximum - schema.exclusiveMinimum) <= 3.4e38);
-      return hasLowRange ? 'f32' : 'f64';
+    if (schema.type === 'string') {
+        // Binary format maps to Vec<u8>
+        if (schema.format === 'binary' || schema.contentEncoding === 'binary') {
+            return 'Vec<u8>';
+        }
+        return 'String';
     }
-  } else if (schema.type === 'boolean') {
-    return 'bool';
-  } else if (schema.type === 'null') {
-    return '()';
-  } else if (schema.type === 'array') {
-    if (schema.items) {
-      // Check if array items are objects that need special handling
-      if (schema.items.type === 'object' || schema.items.properties || schema.items.$ref) {
-        // For array of objects, reference the item type with proper module path
-        // Find the parent module name to reference the item
-        const parentName = path[path.length - 2] || path[0];
-        return `Vec<${parentName}_::${path[path.length - 1]}Item>`;
-      }
-      const itemType = toRustType(schema.items, [...path, '_item'], rootSchema);
-      return `Vec<${itemType}>`;
+    else if (schema.type === 'number' || schema.type === 'integer') {
+        // Handle numeric types with constraints
+        if (schema.type === 'integer') {
+            // Determine integer type based on min/max constraints
+            const min = typeof schema.minimum === 'number'
+                ? schema.minimum
+                : typeof schema.exclusiveMinimum === 'number'
+                    ? schema.exclusiveMinimum + 1
+                    : undefined;
+            const max = typeof schema.maximum === 'number'
+                ? schema.maximum
+                : typeof schema.exclusiveMaximum === 'number'
+                    ? schema.exclusiveMaximum - 1
+                    : undefined;
+            // Check if we need unsigned (no negative values)
+            if (min !== undefined && min >= 0) {
+                // Choose appropriate unsigned int size
+                if (max !== undefined) {
+                    if (max <= 255)
+                        return 'u8';
+                    if (max <= 65535)
+                        return 'u16';
+                    if (max <= 4294967295)
+                        return 'u32';
+                }
+                return 'u64'; // Default unsigned
+            }
+            else {
+                // Choose appropriate signed int size
+                if (min !== undefined && max !== undefined) {
+                    const absMin = Math.abs(min);
+                    const absMax = Math.abs(max);
+                    const maxVal = Math.max(absMin - 1, absMax);
+                    if (maxVal <= 127)
+                        return 'i8';
+                    if (maxVal <= 32767)
+                        return 'i16';
+                    if (maxVal <= 2147483647)
+                        return 'i32';
+                }
+                return 'i64'; // Default signed
+            }
+        }
+        else {
+            // Floating point
+            const hasLowRange = (schema.minimum !== undefined &&
+                schema.maximum !== undefined &&
+                Math.abs(schema.maximum - schema.minimum) <= 3.4e38) ||
+                (schema.exclusiveMinimum !== undefined &&
+                    schema.exclusiveMaximum !== undefined &&
+                    Math.abs(schema.exclusiveMaximum - schema.exclusiveMinimum) <= 3.4e38);
+            return hasLowRange ? 'f32' : 'f64';
+        }
     }
-    return 'Vec<String>';
-  } else if (schema.type === 'object' || schema.properties) {
-    // Handle empty objects
-    if (schema.type === 'object' && (!schema.properties || Object.keys(schema.properties).length === 0)) {
-      return 'serde_json::Value';
+    else if (schema.type === 'boolean') {
+        return 'bool';
+    }
+    else if (schema.type === 'null') {
+        return '()';
+    }
+    else if (schema.type === 'array') {
+        if (schema.items && typeof schema.items !== 'boolean') {
+            // Check if array items are objects that need special handling
+            if (schema.items.type === 'object' || schema.items.properties || schema.items.$ref) {
+                // For array of objects, reference the item type with proper module path
+                // Find the parent module name to reference the item
+                const parentName = path[path.length - 2] || path[0];
+                return `Vec<${parentName}_::${path[path.length - 1]}Item>`;
+            }
+            const itemType = toRustType(schema.items, [...path, '_item'], rootSchema);
+            return `Vec<${itemType}>`;
+        }
+        return 'Vec<String>';
     }
-    return path[path.length - 1];
-  } else if (schema.anyOf || schema.oneOf || schema.allOf) {
-    return `${getModulePath(path)}`;
-  }
-  return 'String'; // Default fallback
+    else if (schema.type === 'object' || schema.properties) {
+        // Handle empty objects
+        if (schema.type === 'object' && (!schema.properties || Object.keys(schema.properties).length === 0)) {
+            return 'serde_json::Value';
+        }
+        return path[path.length - 1];
+    }
+    else if (schema.anyOf || schema.oneOf || schema.allOf) {
+        return `${getModulePath(path)}`;
+    }
+    return 'String'; // Default fallback
 }
 // Generate enum for string with enum values
 export function generateEnum(schema, name, level, pad = 0) {
-  const indentFn = (level) => ' '.repeat(pad + level * 2);
-  let code = '';
-  // Add documentation comments for the enum
-  code += generateDocComment(schema, level, pad);
-  code += `${indentFn(level)}#[derive(Debug, Serialize, Deserialize, Clone)]\n`;
-  code += `${indentFn(level)}#[allow(non_camel_case_types)]\n`;
-  code += `${indentFn(level)}pub enum ${name} {\n`;
-  schema.enum?.forEach((value) => {
-    // Create valid Rust enum variant
-    const variant = value?.replace(/[^a-zA-Z0-9_]/g, '_');
-    code += `${indentFn(level + 1)}#[serde(rename = "${value}")]\n`;
-    code += `${indentFn(level + 1)}${variant},\n`;
-  });
-  code += `${indentFn(level)}}\n\n`;
-  return code;
+    const indentFn = (level) => ' '.repeat(pad + level * 2);
+    let code = '';
+    // Add documentation comments for the enum
+    code += generateDocComment(schema, level, pad);
+    code += `${indentFn(level)}#[derive(Debug, Serialize, Deserialize, Clone)]\n`;
+    code += `${indentFn(level)}#[allow(non_camel_case_types)]\n`;
+    code += `${indentFn(level)}pub enum ${name} {\n`;
+    schema.enum?.forEach((value) => {
+        // Create valid Rust enum variant
+        const variant = value?.replace(/[^a-zA-Z0-9_]/g, '_');
+        code += `${indentFn(level + 1)}#[serde(rename = "${value}")]\n`;
+        code += `${indentFn(level + 1)}${variant},\n`;
+    });
+    code += `${indentFn(level)}}\n\n`;
+    return code;
 }
 // Generate enum for anyOf/oneOf/allOf schemas
 export function generateVariantEnum(schema, name, path, level, rootSchema, pad = 0) {
-  const indentFn = (level) => ' '.repeat(pad + level * 2);
-  // Handle allOf separately - it should combine schemas rather than create variants
-  if (schema.allOf) {
-    return generateAllOfType(schema.allOf, name, path, level, rootSchema, pad);
-  }
-  const variants = schema.anyOf || schema.oneOf || [];
-  let code = '';
-  let nestedTypes = '';
-  // Add documentation comments for the enum
-  code += generateDocComment(schema, level, pad);
-  code += `${indentFn(level)}#[derive(Debug, Serialize, Deserialize, Clone)]\n`;
-  code += `${indentFn(level)}#[allow(non_camel_case_types)]\n`;
-  code += `${indentFn(level)}#[serde(untagged)]\n`;
-  code += `${indentFn(level)}pub enum ${name} {\n`;
-  variants.forEach((variant, index) => {
-    // Resolve $ref if present
-    if (variant.$ref) {
-      const resolved = resolveRef(variant.$ref, rootSchema);
-      if (resolved) {
-        variant = resolved;
-      }
+    const indentFn = (level) => ' '.repeat(pad + level * 2);
+    // Handle allOf separately - it should combine schemas rather than create variants
+    if (schema.allOf) {
+        return generateAllOfType(schema.allOf, name, path, level, rootSchema, pad);
     }
-    const variantName = `Variant${index}`;
-    const variantPath = [...path, name, variantName];
-    // If it's an object type, we need to create a separate struct
-    if (variant.type === 'object' || variant.properties) {
-      code += `${indentFn(level + 1)}${variantName}(${name}_::${variantName}),\n`;
-      // Create a nested type definition to be added outside the enum
-      nestedTypes += processObject(variant, variantPath, level, rootSchema, pad);
-    } else {
-      // For simple types, we can include them directly in the enum
-      const variantType = toRustType(variant, variantPath, rootSchema);
-      code += `${indentFn(level + 1)}${variantName}(${variantType}),\n`;
+    const variants = schema.anyOf || schema.oneOf || [];
+    let code = '';
+    let nestedTypes = '';
+    // Add documentation comments for the enum
+    code += generateDocComment(schema, level, pad);
+    code += `${indentFn(level)}#[derive(Debug, Serialize, Deserialize, Clone)]\n`;
+    code += `${indentFn(level)}#[allow(non_camel_case_types)]\n`;
+    code += `${indentFn(level)}#[serde(untagged)]\n`;
+    code += `${indentFn(level)}pub enum ${name} {\n`;
+    variants.forEach((variant, index) => {
+        // Resolve $ref if present
+        if (variant.$ref) {
+            const resolved = resolveRef(variant.$ref, rootSchema);
+            if (resolved) {
+                variant = resolved;
+            }
+        }
+        const variantName = `Variant${index}`;
+        const variantPath = [...path, name, variantName];
+        // If it's an object type, we need to create a separate struct
+        if (variant.type === 'object' || variant.properties) {
+            code += `${indentFn(level + 1)}${variantName}(${name}_::${variantName}),\n`;
+            // Create a nested type definition to be added inside a sub-module
+            nestedTypes += processObject(variant, variantPath, level + 1, rootSchema, pad);
+        }
+        else {
+            // For simple types, we can include them directly in the enum
+            const variantType = toRustType(variant, variantPath, rootSchema);
+            code += `${indentFn(level + 1)}${variantName}(${variantType}),\n`;
+        }
+    });
+    code += `${indentFn(level)}}\n\n`;
+    // Add nested type definitions wrapped in a sub-module
+    if (nestedTypes) {
+        code += `${indentFn(level)}#[allow(non_snake_case)]\n`;
+        code += `${indentFn(level)}pub mod ${name}_ {\n`;
+        code += `${indentFn(level + 1)}use serde::{Serialize, Deserialize};\n\n`;
+        code += nestedTypes;
+        code += `${indentFn(level)}}\n`;
     }
-  });
-  code += `${indentFn(level)}}\n\n`;
-  // Add nested type definitions if needed
-  if (nestedTypes) {
-    code += nestedTypes;
-  }
-  return code;
+    return code;
 }
 // Handle allOf schema by merging properties
 export function generateAllOfType(schemas, name, path, level, rootSchema, pad = 0) {
-  const mergedSchema = {
-    type: 'object',
-    properties: {},
-    required: [],
-  };
-  // Merge all schemas in allOf
-  schemas.forEach((schema) => {
-    // Resolve $ref if present
-    if (schema.$ref) {
-      const resolved = resolveRef(schema.$ref, rootSchema);
-      if (resolved) {
-        schema = resolved;
-      }
-    }
-    if (schema.properties) {
-      mergedSchema.properties = {
-        ...mergedSchema.properties,
-        ...schema.properties,
-      };
-    }
-    if (schema.required) {
-      mergedSchema.required = [...(mergedSchema.required ?? []), ...schema.required];
-    }
-  });
-  // Process the merged schema as a regular object
-  return processObject(mergedSchema, [...path, name], level, rootSchema, pad);
+    const mergedSchema = {
+        type: 'object',
+        properties: {},
+        required: [],
+    };
+    // Merge all schemas in allOf
+    schemas.forEach((schema) => {
+        // Resolve $ref if present
+        if (schema.$ref) {
+            const resolved = resolveRef(schema.$ref, rootSchema);
+            if (resolved) {
+                schema = resolved;
+            }
+        }
+        if (schema.properties) {
+            mergedSchema.properties = {
+                ...mergedSchema.properties,
+                ...schema.properties,
+            };
+        }
+        if (schema.required) {
+            mergedSchema.required = [...(mergedSchema.required ?? []), ...schema.required];
+        }
+    });
+    // Process the merged schema as a regular object
+    return processObject(mergedSchema, [...path, name], level, rootSchema, pad);
 }
 // Process schema objects and generate Rust code
 export function processObject(schema, path, level, rootSchema = schema, pad = 0) {
-  const indentFn = (level) => ' '.repeat(pad + level * 2);
-  if (!schema) {
-    return '';
-  }
-  // Handle empty objects
-  if (schema.type === 'object' && (!schema.properties || Object.keys(schema.properties).length === 0)) {
-    // Empty object is handled as serde_json::Value at the field level
-    return '';
-  }
-  if (!schema.properties) {
-    return '';
-  }
-  const currentName = path[path.length - 1];
-  let code = '';
-  // Add documentation comments for the struct
-  code += generateDocComment(schema, level, pad);
-  if (schema.type === 'object' && schema['x-isForm'] === true) {
-    code += `${indentFn(level)}pub use reqwest::multipart::Form as ${currentName};\n`;
-    return code;
-  }
-  // Generate struct
-  code += `${indentFn(level)}#[derive(Debug, Serialize, Deserialize, Clone)]\n`;
-  code += `${indentFn(level)}#[allow(non_snake_case, non_camel_case_types)]\n`;
-  code += `${indentFn(level)}pub struct ${currentName} {\n`;
-  // Generate struct fields
-  Object.entries(schema.properties).forEach(([propName, propSchema]) => {
-    const isRequired = schema.required && schema.required.includes(propName);
-    // Handle $ref in property
-    if (propSchema.$ref) {
-      const resolvedSchema = resolveRef(propSchema.$ref, rootSchema);
-      if (resolvedSchema) {
-        propSchema = resolvedSchema;
-      }
+    const indentFn = (level) => ' '.repeat(pad + level * 2);
+    if (!schema) {
+        return '';
     }
-    // Add documentation comments for the field
-    code += generateDocComment(propSchema, level + 1, pad);
-    // Determine if this property is a nested type that should be accessed via module path
-    const isNestedObject = propSchema.type === 'object' || propSchema.properties;
-    const isGenericObject = propSchema.type === 'object' && !propSchema.properties;
-    // Define nested enum types
-    const isNestedEnum =
-      ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) ||
-      propSchema.anyOf ||
-      propSchema.oneOf ||
-      propSchema.allOf;
-    const propPath = [...path, propName];
-    let propType;
-    if (isGenericObject) {
-      // For generic objects, we can use serde_json::Value
-      propType = 'serde_json::Value';
-    } else if (isNestedObject || isNestedEnum) {
-      // For nested objects and enums, we need to reference them via their module path
-      propType = `${currentName}_::${propName}`;
-      // Special case for enums which have a different naming convention
-      if (isNestedEnum) {
-        propType += ''; // 'Enum';
-      }
-    } else {
-      // For other types, use the standard type resolution
-      propType = toRustType(propSchema, propPath, rootSchema);
+    // Handle empty objects
+    if (schema.type === 'object' && (!schema.properties || Object.keys(schema.properties).length === 0)) {
+        // Empty object is handled as serde_json::Value at the field level
+        return '';
     }
-    if (!isRequired) {
-      propType = `Option<${propType}>`;
+    if (!schema.properties) {
+        return '';
     }
-    code += `${indentFn(level + 1)}pub ${propName}: ${propType},\n`;
-  });
-  code += `${indentFn(level)}}\n\n`;
-  // Check if any properties require nested types before generating the sub-module
-  const hasNestedTypes = Object.entries(schema.properties).some(([, propSchema]) => {
-    // Resolve $ref if present
-    if (propSchema.$ref) {
-      const resolved = resolveRef(propSchema.$ref, rootSchema);
-      propSchema = resolved || propSchema;
+    const currentName = path[path.length - 1];
+    let code = '';
+    // Add documentation comments for the struct
+    code += generateDocComment(schema, level, pad);
+    if (schema.type === 'object' &&
+        (schema['x-contentType']?.includes('multipart/form-data') ||
+            schema['x-contentType']?.includes('application/x-www-form-urlencoded'))) {
+        code += `${indentFn(level)}pub use reqwest::multipart::Form as ${currentName};\n`;
+        return code;
     }
-    return (
-      propSchema.type === 'object' ||
-      propSchema.properties ||
-      ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) ||
-      (propSchema.type === 'array' &&
-        propSchema.items &&
-        (propSchema.items.type === 'object' || propSchema.items.properties || propSchema.items.$ref)) ||
-      propSchema.anyOf ||
-      propSchema.oneOf ||
-      propSchema.allOf
-    );
-  });
-  // Only generate sub-modules if there are nested types
-  if (hasNestedTypes && Object.keys(schema.properties).length > 0) {
-    code += `${indentFn(level)}#[allow(non_snake_case)]\n`;
-    code += `${indentFn(level)}pub mod ${currentName}_ {\n`;
-    code += `${indentFn(level + 1)}use serde::{Serialize, Deserialize};\n\n`;
+    // Generate struct
+    code += `${indentFn(level)}#[derive(Debug, Serialize, Deserialize, Clone)]\n`;
+    code += `${indentFn(level)}#[allow(non_snake_case, non_camel_case_types)]\n`;
+    code += `${indentFn(level)}pub struct ${currentName} {\n`;
+    // Generate struct fields
     Object.entries(schema.properties).forEach(([propName, propSchema]) => {
-      // Resolve $ref if present
-      if (propSchema.$ref) {
-        const resolved = resolveRef(propSchema.$ref, rootSchema);
-        if (resolved) {
-          propSchema = resolved;
-        }
-      }
-      // Generate nested object types
-      if (propSchema.type === 'object' || propSchema.properties) {
-        code += processObject(propSchema, [...path, propName], level + 1, rootSchema, pad);
-      }
-      // Generate enum types for string enums (also when type is missing but enum exists)
-      else if ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) {
-        code += generateEnum(propSchema, propName, level + 1, pad);
-      }
-      // Generate types for array items if they're objects
-      else if (propSchema.type === 'array' && propSchema.items) {
-        // Check if items has a $ref
-        if (propSchema.items.$ref) {
-          const resolved = resolveRef(propSchema.items.$ref, rootSchema);
-          if (resolved && (resolved.type === 'object' || resolved.properties)) {
-            code += processObject(resolved, [...path, propName + 'Item'], level + 1, rootSchema, pad);
-          }
-        } else if (propSchema.items.type === 'object' || propSchema.items.properties) {
-          code += processObject(propSchema.items, [...path, propName + 'Item'], level + 1, rootSchema, pad);
-        }
-      }
-      // Handle anyOf/oneOf/allOf schemas
-      else if (propSchema.anyOf || propSchema.oneOf || propSchema.allOf) {
-        code += generateVariantEnum(propSchema, propName, path, level + 1, rootSchema, pad);
-      }
+        const isRequired = schema.required && schema.required.includes(propName);
+        // Handle $ref in property
+        if (propSchema.$ref) {
+            const resolvedSchema = resolveRef(propSchema.$ref, rootSchema);
+            if (resolvedSchema) {
+                propSchema = resolvedSchema;
+            }
+        }
+        // Add documentation comments for the field
+        code += generateDocComment(propSchema, level + 1, pad);
+        // Determine if this property is a nested type that should be accessed via module path
+        const isNestedObject = propSchema.type === 'object' || propSchema.properties;
+        const isGenericObject = propSchema.type === 'object' && !propSchema.properties;
+        // Define nested enum types
+        const isNestedEnum = ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) ||
+            propSchema.anyOf ||
+            propSchema.oneOf ||
+            propSchema.allOf;
+        const propPath = [...path, propName];
+        let propType;
+        if (isGenericObject) {
+            // For generic objects, we can use serde_json::Value
+            propType = 'serde_json::Value';
+        }
+        else if (isNestedObject || isNestedEnum) {
+            // For nested objects and enums, we need to reference them via their module path
+            propType = `${currentName}_::${propName}`;
+            // Special case for enums which have a different naming convention
+            if (isNestedEnum) {
+                propType += ''; // 'Enum';
+            }
+        }
+        else {
+            // For other types, use the standard type resolution
+            propType = toRustType(propSchema, propPath, rootSchema);
+        }
+        if (!isRequired) {
+            propType = `Option<${propType}>`;
+        }
+        if (RUST_KEYWORDS.has(propName)) {
+            code += `${indentFn(level + 1)}#[serde(rename = "${propName}")]\n`;
+            code += `${indentFn(level + 1)}pub r#${propName}: ${propType},\n`;
+        }
+        else {
+            code += `${indentFn(level + 1)}pub ${propName}: ${propType},\n`;
+        }
     });
-    code += `${indentFn(level)}}\n`;
-  }
-  return code;
+    code += `${indentFn(level)}}\n\n`;
+    // Check if any properties require nested types before generating the sub-module
+    const hasNestedTypes = Object.entries(schema.properties).some(([, propSchema]) => {
+        // Resolve $ref if present
+        if (propSchema.$ref) {
+            const resolved = resolveRef(propSchema.$ref, rootSchema);
+            propSchema = resolved || propSchema;
+        }
+        return (propSchema.type === 'object' ||
+            propSchema.properties ||
+            ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) ||
+            (propSchema.type === 'array' &&
+                propSchema.items &&
+                typeof propSchema.items !== 'boolean' &&
+                (propSchema.items.type === 'object' || propSchema.items.properties || propSchema.items.$ref)) ||
+            propSchema.anyOf ||
+            propSchema.oneOf ||
+            propSchema.allOf);
+    });
+    // Only generate sub-modules if there are nested types
+    if (hasNestedTypes && Object.keys(schema.properties).length > 0) {
+        code += `${indentFn(level)}#[allow(non_snake_case)]\n`;
+        code += `${indentFn(level)}pub mod ${currentName}_ {\n`;
+        code += `${indentFn(level + 1)}use serde::{Serialize, Deserialize};\n\n`;
+        Object.entries(schema.properties).forEach(([propName, propSchema]) => {
+            // Resolve $ref if present
+            if (propSchema.$ref) {
+                const resolved = resolveRef(propSchema.$ref, rootSchema);
+                if (resolved) {
+                    propSchema = resolved;
+                }
+            }
+            // Generate nested object types
+            if (propSchema.type === 'object' || propSchema.properties) {
+                code += processObject(propSchema, [...path, propName], level + 1, rootSchema, pad);
+            }
+            // Generate enum types for string enums (also when type is missing but enum exists)
+            else if ((propSchema.type === 'string' || !propSchema.type) && propSchema.enum) {
+                code += generateEnum(propSchema, propName, level + 1, pad);
+            }
+            // Generate types for array items if they're objects
+            else if (propSchema.type === 'array' && propSchema.items && typeof propSchema.items !== 'boolean') {
+                // Check if items has a $ref
+                if (propSchema.items.$ref) {
+                    const resolved = resolveRef(propSchema.items.$ref, rootSchema);
+                    if (resolved && (resolved.type === 'object' || resolved.properties)) {
+                        code += processObject(resolved, [...path, propName + 'Item'], level + 1, rootSchema, pad);
+                    }
+                }
+                else if (propSchema.items.type === 'object' || propSchema.items.properties) {
+                    code += processObject(propSchema.items, [...path, propName + 'Item'], level + 1, rootSchema, pad);
+                }
+            }
+            // Handle anyOf/oneOf/allOf schemas
+            else if (propSchema.anyOf || propSchema.oneOf || propSchema.allOf) {
+                code += generateVariantEnum(propSchema, propName, path, level + 1, rootSchema, pad);
+            }
+        });
+        code += `${indentFn(level)}}\n`;
+    }
+    return code;
 }
 // Generate code for primitive types
 export function processPrimitive(schema, name, level, pad = 0) {
-  const indentFn = (level) => ' '.repeat(pad + level * 2);
-  let code = '';
-  // Add documentation comments
-  code += generateDocComment(schema, level, pad);
-  // For primitive types, create a type alias
-  code += `${indentFn(level)}pub type ${name} = `;
-  if (schema.type === 'string') {
-    code += 'String';
-  } else if (schema.type === 'number') {
-    code += 'f64';
-  } else if (schema.type === 'integer') {
-    code += 'i64';
-  } else if (schema.type === 'boolean') {
-    code += 'bool';
-  } else if (schema.type === 'null') {
-    code += '()';
-  } else if (schema.enum) {
-    // If it has enum values, we'll generate an actual enum instead of a type alias
-    return generateEnum(schema, name, level, pad);
-  } else {
-    code += 'String'; // Default fallback
-  }
-  code += ';\n\n';
-  return code;
-}
-export function convertJSONSchemasToRustTypes({ schemas, pad = 0, rootName }) {
-  // Check if all schemas are undefined
-  const hasDefinedSchemas = Object.values(schemas).some((schema) => schema !== undefined);
-  if (!hasDefinedSchemas) {
-    return '';
-  }
-  const indentFn = (level) => ' '.repeat(pad + level * 2);
-  // Start code generation
-  let result = `${indentFn(0)}pub mod ${rootName}_ {\n`;
-  result += `${indentFn(1)}use serde::{Serialize, Deserialize};\n`;
-  // Process each schema in the schemas object
-  Object.entries(schemas).forEach(([schemaName, schemaObj]) => {
-    // Skip undefined schemas
-    if (!schemaObj) return;
-    // Extract and process types from $defs if present
-    if (schemaObj.$defs) {
-      Object.entries(schemaObj.$defs).forEach(([defName, defSchema]) => {
-        // Create a root object for each definition
-        if (defSchema) {
-          if (defSchema.type === 'object' || defSchema.properties) {
-            const rootDefObject = {
-              type: 'object',
-              properties: defSchema.properties || {},
-              required: defSchema.required || [],
-              title: defSchema.title,
-              description: defSchema.description,
-              'x-isForm': defSchema['x-isForm'],
-            };
-            result += processObject(rootDefObject, [defName], 1, schemaObj, pad);
-          } else if (defSchema.type === 'string' && defSchema.enum) {
-            result += generateEnum(defSchema, defName, 1, pad);
-          } else if (defSchema.anyOf || defSchema.oneOf || defSchema.allOf) {
-            result += generateVariantEnum(defSchema, defName, [defName], 1, schemaObj, pad);
-          } else if (defSchema.type && ['string', 'number', 'integer', 'boolean', 'null'].includes(defSchema.type)) {
-            // Handle primitive types in $defs
-            result += processPrimitive(defSchema, defName, 1, pad);
-          }
-        }
-      });
+    const indentFn = (level) => ' '.repeat(pad + level * 2);
+    let code = '';
+    // Add documentation comments
+    code += generateDocComment(schema, level, pad);
+    // For primitive types, create a type alias
+    code += `${indentFn(level)}pub type ${name} = `;
+    if (schema.type === 'string') {
+        // Binary format maps to Vec<u8>
+        if (schema.format === 'binary' || schema.contentEncoding === 'binary') {
+            code += 'Vec<u8>';
+        }
+        else {
+            code += 'String';
+        }
     }
-    // Handle the schema based on its type
-    if (schemaObj.type === 'object' || schemaObj.properties) {
-      // Create a root object for object schema
-      const rootObject = {
-        type: 'object',
-        properties: schemaObj.properties || {},
-        required: schemaObj.required || [],
-        title: schemaObj.title,
-        description: schemaObj.description,
-        'x-isForm': schemaObj['x-isForm'],
-      };
-      result += processObject(rootObject, [schemaName], 1, schemaObj, pad);
-    } else if (['string', 'number', 'integer', 'boolean', 'null'].includes(schemaObj.type)) {
-      // Handle primitive schema
-      result += processPrimitive(schemaObj, schemaName, 1, pad);
-    } else if (schemaObj.enum) {
-      // Handle enum schema
-      result += generateEnum(schemaObj, schemaName, 1, pad);
-    } else if (schemaObj.anyOf || schemaObj.oneOf || schemaObj.allOf) {
-      // Handle variant schema
-      result += generateVariantEnum(schemaObj, schemaName, [schemaName], 1, schemaObj, pad);
-    } else if (schemaObj.type === 'array') {
-      // For array as root type, create a type alias to Vec<ItemType>
-      let itemType = 'String'; // Default if no items specified
-      if (schemaObj.items) {
-        if (schemaObj.items.type === 'object' || schemaObj.items.properties) {
-          // Create the item type
-          const itemSchema = {
-            ...schemaObj.items,
-            title: schemaObj.items.title || `${schemaName}Item`,
-            description: schemaObj.items.description || `Item of ${schemaName} array`,
-          };
-          result += processObject(itemSchema, [`${schemaName}Item`], 1, schemaObj, pad);
-          itemType = `${schemaName}Item`;
-        } else {
-          // For primitive array items
-          itemType = toRustType(schemaObj.items, [`${schemaName}Item`], schemaObj);
-        }
-      }
-      result += `${indentFn(1)}pub type ${schemaName} = Vec<${itemType}>;\n\n`;
+    else if (schema.type === 'number') {
+        code += 'f64';
+    }
+    else if (schema.type === 'integer') {
+        code += 'i64';
+    }
+    else if (schema.type === 'boolean') {
+        code += 'bool';
+    }
+    else if (schema.type === 'null') {
+        code += '()';
+    }
+    else if (schema.enum) {
+        // If it has enum values, we'll generate an actual enum instead of a type alias
+        return generateEnum(schema, name, level, pad);
+    }
+    else {
+        code += 'String'; // Default fallback
+    }
+    code += ';\n\n';
+    return code;
+}
+export function convertJSONSchemasToRustTypes({ schemas, pad = 0, rootName, }) {
+    // Check if all schemas are undefined
+    const hasDefinedSchemas = Object.values(schemas).some((schema) => schema !== undefined);
+    if (!hasDefinedSchemas) {
+        return '';
     }
-  });
-  result += `${indentFn(0)}}\n`;
-  return result;
+    const indentFn = (level) => ' '.repeat(pad + level * 2);
+    // Start code generation
+    let result = `${indentFn(0)}#[allow(non_camel_case_types)]\n`;
+    result += `${indentFn(0)}pub mod ${rootName}_ {\n`;
+    result += `${indentFn(1)}#[allow(unused_imports)]\n`;
+    result += `${indentFn(1)}use serde::{Serialize, Deserialize};\n`;
+    // Process each schema in the schemas object
+    Object.entries(schemas).forEach(([schemaName, schemaObj]) => {
+        // Skip undefined schemas
+        if (!schemaObj)
+            return;
+        // Extract and process types from $defs if present
+        if (schemaObj.$defs) {
+            Object.entries(schemaObj.$defs).forEach(([defName, defSchema]) => {
+                // Create a root object for each definition
+                if (defSchema) {
+                    if (defSchema.type === 'object' || defSchema.properties) {
+                        const rootDefObject = {
+                            type: 'object',
+                            properties: defSchema.properties || {},
+                            required: defSchema.required || [],
+                            title: defSchema.title,
+                            description: defSchema.description,
+                            'x-contentType': defSchema['x-contentType'],
+                        };
+                        result += processObject(rootDefObject, [defName], 1, schemaObj, pad);
+                    }
+                    else if (defSchema.type === 'string' && defSchema.enum) {
+                        result += generateEnum(defSchema, defName, 1, pad);
+                    }
+                    else if (defSchema.anyOf || defSchema.oneOf || defSchema.allOf) {
+                        result += generateVariantEnum(defSchema, defName, [defName], 1, schemaObj, pad);
+                    }
+                    else if (typeof defSchema.type === 'string' &&
+                        ['string', 'number', 'integer', 'boolean', 'null'].includes(defSchema.type)) {
+                        // Handle primitive types in $defs
+                        result += processPrimitive(defSchema, defName, 1, pad);
+                    }
+                }
+            });
+        }
+        // Handle the schema based on its type
+        if (schemaObj.type === 'object' || schemaObj.properties) {
+            // Create a root object for object schema
+            const rootObject = {
+                type: 'object',
+                properties: schemaObj.properties || {},
+                required: schemaObj.required || [],
+                title: schemaObj.title,
+                description: schemaObj.description,
+                'x-contentType': schemaObj['x-contentType'],
+            };
+            result += processObject(rootObject, [schemaName], 1, schemaObj, pad);
+        }
+        else if (typeof schemaObj.type === 'string' &&
+            ['string', 'number', 'integer', 'boolean', 'null'].includes(schemaObj.type)) {
+            // Handle primitive schema
+            result += processPrimitive(schemaObj, schemaName, 1, pad);
+        }
+        else if (schemaObj.enum) {
+            // Handle enum schema
+            result += generateEnum(schemaObj, schemaName, 1, pad);
+        }
+        else if (schemaObj.anyOf || schemaObj.oneOf || schemaObj.allOf) {
+            // Handle variant schema
+            result += generateVariantEnum(schemaObj, schemaName, [schemaName], 1, schemaObj, pad);
+        }
+        else if (schemaObj.type === 'array') {
+            // For array as root type, create a type alias to Vec<ItemType>
+            let itemType = 'String'; // Default if no items specified
+            if (schemaObj.items && typeof schemaObj.items !== 'boolean') {
+                if (schemaObj.items.type === 'object' || schemaObj.items.properties) {
+                    // Create the item type
+                    const itemSchema = {
+                        ...schemaObj.items,
+                        title: schemaObj.items.title || `${schemaName}Item`,
+                        description: schemaObj.items.description || `Item of ${schemaName} array`,
+                    };
+                    result += processObject(itemSchema, [`${schemaName}Item`], 1, schemaObj, pad);
+                    itemType = `${schemaName}Item`;
+                }
+                else {
+                    // For primitive array items
+                    itemType = toRustType(schemaObj.items, [`${schemaName}Item`], schemaObj);
+                }
+            }
+            result += `${indentFn(1)}pub type ${schemaName} = Vec<${itemType}>;\n\n`;
+        }
+    });
+    result += `${indentFn(0)}}\n`;
+    return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-rust",
-  "version": "0.0.1-beta.15",
+  "version": "0.0.1-beta.16",
   "description": "Codegen templates for Rust client library for Vovk.ts",
   "files": [
     "client-templates",