@ioka-technologies/asyncapi-rust-client-template 0.0.22 → 0.0.24

package/dist/common/index.js

@@ -1,3 +1,4 @@
+import "@asyncapi/generator-react-sdk";
 /******/ // The require scope
 /******/ var __webpack_require__ = {};
 /******/ 
@@ -1883,6 +1884,1469 @@ function generateOperationHandlerName(operation, suffix = 'Handler') {
   const pascalCaseName = toPascalCase(operationName);
   return `${pascalCaseName}${suffix}`;
 }
+;// external "@asyncapi/generator-react-sdk"
+
+;// ../common/src/models-rust.js
+/* eslint-disable no-unused-vars */
+
+
+/**
+ * Generate Rust models from AsyncAPI specification
+ * This helper extracts the common schema processing logic used by both rust-server and rust-client templates
+ *
+ * @param {Object} asyncapi - AsyncAPI document
+ * @param {Object} options - Generation options
+ * @param {Function} options.toRustTypeName - Function to convert names to Rust type names
+ * @param {Function} options.toRustFieldName - Function to convert names to Rust field names
+ * @param {Function} options.toRustEnumVariantWithSerde - Function to convert enum variants with serde attributes
+ * @param {boolean} options.includeAsyncApiTrait - Whether to include AsyncApiMessage trait implementations
+ * @param {boolean} options.includeEnvelope - Whether to include MessageEnvelope (from envelope-rust.js)
+ * @returns {Object} Generated models data and functions
+ */
+function generateRustModels(asyncapi, options = {}) {
+  const {
+    toRustTypeName,
+    toRustFieldName,
+    toRustEnumVariantWithSerde,
+    includeAsyncApiTrait = false,
+    includeEnvelope = false
+  } = options;
+
+  // Extract message schemas and build channel mapping
+  const components = asyncapi.components();
+  const messageSchemas = [];
+  const componentSchemas = [];
+  const messageToChannels = new Map();
+  const generatedTypes = new Set();
+  const nestedSchemas = new Map();
+  const schemaRegistry = new Map();
+
+  // First, build channel to message mapping and extract inline message schemas
+  if (asyncapi.channels) {
+    const channels = asyncapi.channels();
+    if (channels) {
+      // Use proper iteration for AsyncAPI collection
+      for (const channel of channels) {
+        try {
+          const channelName = channel.id();
+
+          // Handle AsyncAPI 3.x format - extract inline messages from channels
+          if (channel.messages) {
+            const messages = channel.messages();
+            if (messages) {
+              // Check if messages is an object with message names as keys
+              if (typeof messages === 'object' && !Array.isArray(messages)) {
+                // Iterate through message entries (messageName -> messageObject)
+                Object.entries(messages).forEach(([messageName, message]) => {
+                  if (message && messageName) {
+                    let payload = null;
+                    let description = null;
+
+                    // Get payload schema
+                    if (message.payload && typeof message.payload === 'function') {
+                      payload = message.payload();
+                      if (payload && payload.json && typeof payload.json === 'function') {
+                        payload = payload.json();
+                      }
+                    } else if (message.payload) {
+                      payload = message.payload;
+                    }
+
+                    // Get description
+                    if (message.description && typeof message.description === 'function') {
+                      description = message.description();
+                    } else if (message.description) {
+                      description = message.description;
+                    }
+
+                    // Add to channel mapping
+                    if (!messageToChannels.has(messageName)) {
+                      messageToChannels.set(messageName, []);
+                    }
+                    messageToChannels.get(messageName).push(channelName);
+
+                    // Add to message schemas for inline messages
+                    messageSchemas.push({
+                      name: messageName,
+                      rustName: toRustTypeName(messageName),
+                      payload,
+                      rawPayload: payload,
+                      description,
+                      channels: [channelName]
+                    });
+                  }
+                });
+              } else {
+                // Try iterating as a collection
+                for (const message of messages) {
+                  if (message) {
+                    let messageName = null;
+                    let payload = null;
+                    let description = null;
+
+                    // Get message name - try multiple approaches
+                    if (message._meta && message._meta.id) {
+                      messageName = message._meta.id;
+                    } else if (message._json && message._json['x-parser-message-name']) {
+                      messageName = message._json['x-parser-message-name'];
+                    } else if (message._json && message._json['x-parser-unique-object-id']) {
+                      messageName = message._json['x-parser-unique-object-id'];
+                    } else if (message.name && typeof message.name === 'function') {
+                      messageName = message.name();
+                    } else if (message.name) {
+                      messageName = message.name;
+                    } else if (message.$ref) {
+                      messageName = message.$ref.split('/').pop();
+                    }
+
+                    // Get payload schema
+                    if (message.payload && typeof message.payload === 'function') {
+                      payload = message.payload();
+                      if (payload && payload.json && typeof payload.json === 'function') {
+                        payload = payload.json();
+                      }
+                    } else if (message.payload) {
+                      payload = message.payload;
+                    }
+
+                    // Get description
+                    if (message.description && typeof message.description === 'function') {
+                      description = message.description();
+                    } else if (message.description) {
+                      description = message.description;
+                    }
+                    if (messageName) {
+                      // Add to channel mapping
+                      if (!messageToChannels.has(messageName)) {
+                        messageToChannels.set(messageName, []);
+                      }
+                      messageToChannels.get(messageName).push(channelName);
+
+                      // Add to message schemas for inline messages
+                      messageSchemas.push({
+                        name: messageName,
+                        rustName: toRustTypeName(messageName),
+                        payload,
+                        rawPayload: payload,
+                        description,
+                        channels: [channelName]
+                      });
+                    }
+                  }
+                }
+              }
+            }
+          }
+
+          // Handle AsyncAPI 2.x format
+          if (channel.subscribe && channel.subscribe()) {
+            const message = channel.subscribe().message();
+            if (message) {
+              let messageName = null;
+              if (message.$ref) {
+                messageName = message.$ref.split('/').pop();
+              } else if (message.name) {
+                messageName = typeof message.name === 'function' ? message.name() : message.name;
+              }
+              if (messageName) {
+                if (!messageToChannels.has(messageName)) {
+                  messageToChannels.set(messageName, []);
+                }
+                messageToChannels.get(messageName).push(channelName);
+              }
+            }
+          }
+          if (channel.publish && channel.publish()) {
+            const message = channel.publish().message();
+            if (message) {
+              let messageName = null;
+              if (message.$ref) {
+                messageName = message.$ref.split('/').pop();
+              } else if (message.name) {
+                messageName = typeof message.name === 'function' ? message.name() : message.name;
+              }
+              if (messageName) {
+                if (!messageToChannels.has(messageName)) {
+                  messageToChannels.set(messageName, []);
+                }
+                messageToChannels.get(messageName).push(channelName);
+              }
+            }
+          }
+        } catch (e) {
+          // Ignore channel processing errors
+          console.warn(`Error processing channel: ${e.message}`);
+        }
+      }
+    }
+  }
+
+  // Build schema registry from components.schemas
+  // Try to access the raw AsyncAPI document
+  let rawDoc = null;
+  try {
+    if (asyncapi.json && typeof asyncapi.json === 'function') {
+      rawDoc = asyncapi.json();
+    } else if (asyncapi._json) {
+      rawDoc = asyncapi._json;
+    }
+  } catch (e) {
+    // Ignore
+  }
+
+  // Extract schemas from raw document if available
+  if (rawDoc && rawDoc.components && rawDoc.components.schemas) {
+    Object.entries(rawDoc.components.schemas).forEach(([name, schema]) => {
+      if (name && typeof name === 'string' && schema && typeof schema === 'object') {
+        schemaRegistry.set(name, schema);
+        componentSchemas.push({
+          name,
+          rustName: toRustTypeName(name),
+          schema: schema,
+          description: schema.description
+        });
+      }
+    });
+  }
+
+  // Fallback: try the components.schemas() method
+  if (componentSchemas.length === 0 && components && components.schemas) {
+    try {
+      const schemas = components.schemas();
+      if (schemas) {
+        // Try different ways to access schemas
+        let schemaEntries = [];
+        if (schemas instanceof Map) {
+          schemaEntries = Array.from(schemas.entries());
+        } else if (typeof schemas === 'object') {
+          schemaEntries = Object.entries(schemas);
+        } else if (schemas.all && typeof schemas.all === 'function') {
+          // AsyncAPI parser might have an all() method
+          const allSchemas = schemas.all();
+          if (Array.isArray(allSchemas)) {
+            schemaEntries = allSchemas.map(schema => {
+              const name = schema.uid ? schema.uid() : schema.id ? schema.id() : null;
+              return [name, schema];
+            }).filter(([name]) => name);
+          }
+        }
+        schemaEntries.forEach(([name, schema]) => {
+          // Skip internal AsyncAPI parser objects and numeric keys
+          if (!name || name === 'collections' || name === '_meta' || name.startsWith('_') || /^\d+$/.test(name)) {
+            return;
+          }
+          let schemaData = null;
+          let description = null;
+          try {
+            // Handle different schema object types
+            if (schema && typeof schema.json === 'function') {
+              schemaData = schema.json();
+            } else if (schema && typeof schema === 'object') {
+              schemaData = schema;
+            }
+            if (schema && typeof schema.description === 'function') {
+              description = schema.description();
+            } else if (schema && schema.description) {
+              description = schema.description;
+            }
+          } catch (e) {
+            // Ignore schema extraction errors
+            console.warn(`Failed to extract schema for ${name}:`, e.message);
+          }
+          if (schemaData && typeof name === 'string' && name.length > 0) {
+            schemaRegistry.set(name, schemaData);
+            componentSchemas.push({
+              name,
+              rustName: toRustTypeName(name),
+              schema: schemaData,
+              description
+            });
+          }
+        });
+      }
+    } catch (e) {
+      console.warn('Failed to extract component schemas:', e.message);
+    }
+  }
+
+  // Extract messages from components
+  if (components && components.messages) {
+    const messages = components.messages();
+    if (messages) {
+      Object.entries(messages).forEach(([name, message]) => {
+        let payload = null;
+        let description = null;
+        let title = null;
+        let messageName = name;
+        try {
+          let rawPayload = null;
+          if (message.payload && typeof message.payload === 'function') {
+            const payloadSchema = message.payload();
+            payload = payloadSchema && payloadSchema.json ? payloadSchema.json() : payloadSchema;
+            // Try to get the raw payload reference from the message
+            if (message._json && message._json.payload) {
+              rawPayload = message._json.payload;
+            }
+          }
+          description = message.description && typeof message.description === 'function' ? message.description() : null;
+          title = message.title && typeof message.title === 'function' ? message.title() : null;
+
+          // Try to get the actual message name
+          if (message.name && typeof message.name === 'function') {
+            messageName = message.name();
+          } else if (message.name) {
+            messageName = message.name;
+          }
+
+          // If we have raw document access, try to get the payload reference from there
+          if (!rawPayload && rawDoc && rawDoc.components && rawDoc.components.messages && rawDoc.components.messages[name]) {
+            rawPayload = rawDoc.components.messages[name].payload;
+          }
+          const channels = messageToChannels.get(messageName) || messageToChannels.get(name) || [];
+          messageSchemas.push({
+            name: messageName,
+            rustName: toRustTypeName(messageName),
+            payload,
+            rawPayload,
+            description: description || title,
+            channels
+          });
+        } catch (e) {
+          // Ignore payload extraction errors
+          const channels = messageToChannels.get(messageName) || messageToChannels.get(name) || [];
+          messageSchemas.push({
+            name: messageName,
+            rustName: toRustTypeName(messageName),
+            payload,
+            rawPayload: null,
+            description: description || title,
+            channels
+          });
+        }
+      });
+    }
+  }
+
+  // Helper function to convert JSON schema to Rust type
+  function jsonSchemaToRustType(schema, typeName = null) {
+    if (!schema) return 'serde_json::Value';
+
+    // Handle $ref
+    if (schema.$ref) {
+      const refName = schema.$ref.split('/').pop();
+      const rustTypeName = toRustTypeName(refName);
+
+      // Generate the referenced schema if we have access to components
+      if (components && components.schemas) {
+        const schemas = components.schemas();
+        if (schemas && schemas[refName] && !generatedTypes.has(rustTypeName)) {
+          generatedTypes.add(rustTypeName);
+          const referencedSchema = schemas[refName];
+          const schemaJson = referencedSchema.json ? referencedSchema.json() : referencedSchema;
+          nestedSchemas.set(rustTypeName, {
+            type: 'struct',
+            schema: schemaJson,
+            description: referencedSchema.description && typeof referencedSchema.description === 'function' ? referencedSchema.description() : null
+          });
+        }
+      }
+      return rustTypeName;
+    }
+
+    // Handle resolved $ref - check for x-parser-schema-id which indicates original schema name
+    if (schema['x-parser-schema-id'] && typeof schema['x-parser-schema-id'] === 'string') {
+      const schemaId = schema['x-parser-schema-id'];
+      // Check if this matches a known component schema
+      if (schemaRegistry.has(schemaId)) {
+        const rustTypeName = toRustTypeName(schemaId);
+        return rustTypeName;
+      }
+    }
+    if (!schema.type) {
+      // If no type specified, check for properties (object) or items (array)
+      if (schema.properties) {
+        schema.type = 'object';
+      } else if (schema.items) {
+        schema.type = 'array';
+      } else {
+        return 'serde_json::Value';
+      }
+    }
+    switch (schema.type) {
+      case 'string':
+        if (schema.enum && schema.enum.length > 0) {
+          // Generate enum type
+          if (typeName) {
+            const enumName = `${typeName}Enum`;
+            if (!generatedTypes.has(enumName)) {
+              generatedTypes.add(enumName);
+              nestedSchemas.set(enumName, {
+                type: 'enum',
+                variants: schema.enum,
+                description: schema.description
+              });
+            }
+            return enumName;
+          }
+          return 'String'; // Fallback if no type name provided
+        }
+        if (schema.format === 'date-time') return 'chrono::DateTime<chrono::Utc>';
+        if (schema.format === 'uuid') return 'uuid::Uuid';
+        if (schema.format === 'email') return 'String';
+        if (schema.format === 'uri') return 'String';
+        return 'String';
+      case 'integer':
+        switch (schema.format) {
+          case 'int32':
+            return 'i32';
+          case 'int64':
+            return 'i64';
+          case 'uint32':
+            return 'u32';
+          case 'uint64':
+            return 'u64';
+          default:
+            // Default to i32 for unspecified format (maintains backward compatibility)
+            return 'i32';
+        }
+      case 'number':
+        return 'f64';
+      case 'boolean':
+        return 'bool';
+      case 'array':
+        {
+          const itemType = jsonSchemaToRustType(schema.items);
+          return `Vec<${itemType}>`;
+        }
+      case 'object':
+        if (schema.properties && Object.keys(schema.properties).length > 0) {
+          // Generate nested struct
+          if (typeName) {
+            const structName = toRustTypeName(typeName);
+            if (!generatedTypes.has(structName)) {
+              generatedTypes.add(structName);
+              nestedSchemas.set(structName, {
+                type: 'struct',
+                schema: schema,
+                description: schema.description
+              });
+            }
+            return structName;
+          }
+        }
+        return 'serde_json::Value';
+      default:
+        return 'serde_json::Value';
+    }
+  }
+
+  // Generate message structs
+  function generateMessageStruct(schema, messageName) {
+    if (!schema || !schema.properties) {
+      return '    pub data: serde_json::Value,';
+    }
+    const fields = Object.entries(schema.properties).map(([fieldName, fieldSchema]) => {
+      const rustFieldName = toRustFieldName(fieldName);
+      const fieldTypeName = `${messageName}${toRustTypeName(fieldName)}`;
+      const rustType = jsonSchemaToRustType(fieldSchema, fieldTypeName);
+      const requiredFields = schema.required;
+      const optional = !requiredFields || !Array.isArray(requiredFields) || requiredFields.indexOf(fieldName) === -1;
+      const finalType = optional ? `Option<${rustType}>` : rustType;
+      let fieldDoc = '';
+      if (fieldSchema.description) {
+        fieldDoc = `    /// ${fieldSchema.description}\n`;
+      }
+      let serdeRename = '';
+      if (rustFieldName !== fieldName) {
+        serdeRename = `    #[serde(rename = "${fieldName}")]\n`;
+      }
+      let skipSerializing = '';
+      if (optional) {
+        skipSerializing = '    #[serde(skip_serializing_if = "Option::is_none")]\n';
+      }
+      return `${fieldDoc}${serdeRename}${skipSerializing}    pub ${rustFieldName}: ${finalType},`;
+    }).join('\n');
+    return fields;
+  }
+
+  // Process all component schemas first to ensure they are available for references
+  componentSchemas.forEach(schema => {
+    jsonSchemaToRustType(schema.schema, schema.rustName);
+    generatedTypes.add(schema.rustName);
+  });
+
+  // Process all message schemas to ensure all referenced types are generated
+  messageSchemas.forEach(schema => {
+    if (schema.payload) {
+      jsonSchemaToRustType(schema.payload, schema.rustName);
+    }
+  });
+
+  // Return the processed data and generation functions
+  return {
+    messageSchemas,
+    componentSchemas,
+    messageToChannels,
+    generatedTypes,
+    nestedSchemas,
+    schemaRegistry,
+    // Generation functions
+    generateMessageStruct,
+    jsonSchemaToRustType,
+    // Generate component schema definitions
+    generateComponentSchemas() {
+      let result = '';
+      componentSchemas.forEach(schema => {
+        const doc = schema.description ? `/// ${schema.description}\n` : `/// ${schema.name}\n`;
+
+        // Check if this is a standalone enum schema
+        if (schema.schema.type === 'string' && schema.schema.enum && Array.isArray(schema.schema.enum)) {
+          // Generate enum definition with serde rename attributes for lowercase serialization
+          const variants = schema.schema.enum.map(variant => {
+            const {
+              rustName,
+              serializedName
+            } = toRustEnumVariantWithSerde(variant);
+            return `    #[serde(rename = "${serializedName}")]\n    ${rustName}`;
+          }).join(',\n');
+          result += `
+${doc}#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum ${schema.rustName} {
+${variants},
+}
+`;
+        } else {
+          // Generate struct definition
+          const fields = generateMessageStruct(schema.schema, schema.rustName);
+          result += `
+${doc}#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ${schema.rustName} {
+${fields}
+}
+`;
+        }
+      });
+      return result;
+    },
+    // Generate nested type definitions
+    generateNestedTypes() {
+      let result = '';
+      for (const [typeName, typeInfo] of nestedSchemas.entries()) {
+        // Don't skip enums - they need to be generated even if the parent type exists
+        const isEnum = typeInfo.type === 'enum';
+        const isComponentSchema = componentSchemas.some(cs => cs.rustName === typeName);
+
+        // Skip if this type was already generated as a component schema (but not enums)
+        if (!isEnum && isComponentSchema) {
+          continue;
+        }
+        if (typeInfo.type === 'enum') {
+          const variants = typeInfo.variants.map(variant => {
+            const {
+              rustName,
+              serializedName
+            } = toRustEnumVariantWithSerde(variant);
+            return `    #[serde(rename = "${serializedName}")]\n    ${rustName}`;
+          }).join(',\n');
+          const doc = typeInfo.description ? `/// ${typeInfo.description}\n` : '';
+          result += `
+${doc}#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum ${typeName} {
+${variants},
+}
+`;
+        } else if (typeInfo.type === 'struct') {
+          const fields = generateMessageStruct(typeInfo.schema, typeName);
+          const doc = typeInfo.description ? `/// ${typeInfo.description}\n` : '';
+          result += `
+${doc}#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ${typeName} {
+${fields}
+}
+`;
+        }
+      }
+      return result;
+    },
+    // Generate AsyncApiMessage trait implementations (optional)
+    generateAsyncApiTrait() {
+      if (!includeAsyncApiTrait) {
+        return '';
+      }
+
+      // Track which types have already had AsyncApiMessage implementations generated
+      const implementedTypes = new Set();
+      const implementations = [];
+
+      // First add the trait definition
+      implementations.push(`
+/// Base trait for all AsyncAPI messages providing runtime type information
+///
+/// This trait enables:
+/// - **Dynamic message routing**: Route messages based on their type at runtime
+/// - **Channel identification**: Determine which channel a message belongs to
+/// - **Logging and monitoring**: Track message types for observability
+/// - **Protocol abstraction**: Handle different message types uniformly
+pub trait AsyncApiMessage {
+    /// Returns the message type identifier as defined in the AsyncAPI specification
+    ///
+    /// This is used for:
+    /// - Message routing and dispatch
+    /// - Logging and monitoring
+    /// - Protocol-level message identification
+    fn message_type(&self) -> &'static str;
+
+    /// Returns the primary channel this message is associated with
+    ///
+    /// Used for:
+    /// - Default routing when channel is not explicitly specified
+    /// - Message categorization and organization
+    /// - Channel-based access control and filtering
+    fn channel(&self) -> &'static str;
+}`);
+      messageSchemas.forEach(schema => {
+        const doc = schema.description ? `/// ${schema.description}` : `/// ${schema.name} message`;
+        const primaryChannel = schema.channels.length > 0 ? schema.channels[0] : 'default';
+
+        // Check if the message payload references a component schema
+        let payloadRustName = null;
+        let isComponentMessage = false;
+        if (schema.rawPayload && schema.rawPayload.$ref) {
+          const refName = schema.rawPayload.$ref.split('/').pop();
+          payloadRustName = toRustTypeName(refName);
+          isComponentMessage = true;
+        } else if (schema.payload && schema.payload.$ref) {
+          const refName = schema.payload.$ref.split('/').pop();
+          payloadRustName = toRustTypeName(refName);
+          isComponentMessage = true;
+        } else if (schema.payload && schema.payload['x-parser-schema-id']) {
+          // Handle resolved $ref references
+          const schemaId = schema.payload['x-parser-schema-id'];
+          if (schemaRegistry.has(schemaId)) {
+            payloadRustName = toRustTypeName(schemaId);
+            isComponentMessage = true;
+          }
+        }
+
+        // For component messages, always generate the message wrapper type
+        // even if the payload schema already exists
+        if (isComponentMessage && payloadRustName && !implementedTypes.has(schema.rustName)) {
+          implementedTypes.add(schema.rustName);
+          implementations.push(`
+${doc}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ${schema.rustName} {
+    #[serde(flatten)]
+    pub payload: ${payloadRustName},
+}
+
+impl AsyncApiMessage for ${schema.rustName} {
+    fn message_type(&self) -> &'static str {
+        "${schema.name}"
+    }
+
+    fn channel(&self) -> &'static str {
+        "${primaryChannel}"
+    }
+}`);
+        } else if (!generatedTypes.has(schema.rustName) && !implementedTypes.has(schema.rustName)) {
+          // Generate both struct and implementation for inline message schemas
+          implementedTypes.add(schema.rustName);
+          implementations.push(`
+${doc}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ${schema.rustName} {
+${generateMessageStruct(schema.payload, schema.rustName)}
+}
+
+impl AsyncApiMessage for ${schema.rustName} {
+    fn message_type(&self) -> &'static str {
+        "${schema.name}"
+    }
+
+    fn channel(&self) -> &'static str {
+        "${primaryChannel}"
+    }
+}`);
+        } else if (payloadRustName && generatedTypes.has(payloadRustName) && !implementedTypes.has(payloadRustName)) {
+          // Generate AsyncApiMessage implementation for existing component schema
+          implementedTypes.add(payloadRustName);
+          implementations.push(`
+impl AsyncApiMessage for ${payloadRustName} {
+    fn message_type(&self) -> &'static str {
+        "${schema.name}"
+    }
+
+    fn channel(&self) -> &'static str {
+        "${primaryChannel}"
+    }
+}`);
+        }
+      });
+      return implementations.join('');
+    }
+  };
+}
+;// ../common/src/envelope-rust.js
+/* eslint-disable no-unused-vars */
+
+
+/**
+ * Generate a unified MessageEnvelope for both rust-server and rust-client templates
+ * This envelope includes all features needed by both templates:
+ * - Basic message structure (id, operation, payload, timestamp)
+ * - Request/response patterns (correlation_id, create_response)
+ * - Channel routing (channel field)
+ * - Error handling (error field, error methods)
+ * - Authentication (auth header methods)
+ * - Serialization (to_bytes, from_bytes)
+ */
+function generateMessageEnvelope() {
+  return `use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use std::collections::HashMap;
+use uuid::Uuid;
+
+/// Unified message envelope for consistent AsyncAPI message format
+///
+/// This envelope provides a standardized structure for all messages sent through the system,
+/// enabling better correlation, error handling, authentication, and observability.
+///
+/// ## Features
+///
+/// - **Request/Response Patterns**: Correlation IDs for matching requests with responses
+/// - **Error Handling**: Built-in error information for failed operations
+/// - **Authentication**: Integrated auth header support
+/// - **Channel Routing**: Optional channel context for message routing
+/// - **Serialization**: Efficient byte conversion for transport layers
+/// - **Type Safety**: Strongly-typed payload extraction
+///
+/// ## Usage
+///
+/// \`\`\`no-run
+/// use crate::models::*;
+/// use uuid::Uuid;
+/// use std::collections::HashMap;
+///
+/// // Create a basic message envelope
+/// let envelope = MessageEnvelope::new("sendChatMessage", chat_message)?;
+///
+/// // Create with correlation ID for request/response
+/// let request = MessageEnvelope::new_with_correlation_id(
+///     "getUserProfile",
+///     user_request,
+///     Uuid::new_v4().to_string()
+/// )?;
+///
+/// // Create response with same correlation ID
+/// let response = request.create_response("getUserProfile_response", user_profile)?;
+///
+/// // Create error response
+/// let error = MessageEnvelope::error_response(
+///     "getUserProfile_response",
+///     "USER_NOT_FOUND",
+///     "User does not exist",
+///     request.correlation_id().map(|s| s.to_string())
+/// );
+///
+/// // Add authentication headers
+/// let mut headers = HashMap::new();
+/// headers.insert("Authorization".to_string(), "Bearer token123".to_string());
+/// let auth_envelope = envelope.with_headers(headers);
+///
+/// // Serialize for transport
+/// let bytes = envelope.to_bytes()?;
+/// let deserialized = MessageEnvelope::from_bytes(&bytes)?;
+/// \`\`\`
+
+/// Standard message envelope for all AsyncAPI messages
+///
+/// This envelope provides a consistent structure for all messages sent through the system,
+/// enabling better correlation, error handling, and observability.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MessageEnvelope {
+    /// Unique message identifier
+    pub id: String,
+    /// AsyncAPI operation ID
+    pub operation: String,
+    /// Message payload (any serializable type)
+    pub payload: serde_json::Value,
+    /// ISO 8601 timestamp when message was created
+    pub timestamp: String,
+    /// Correlation ID for request/response patterns
+    pub correlation_id: Option<String>,
+    /// Optional channel context for routing
+    pub channel: Option<String>,
+    /// Transport-level headers (auth, routing, etc.)
+    pub headers: Option<HashMap<String, String>>,
+    /// Error information if applicable
+    pub error: Option<MessageError>,
+}
+
+/// Error information for failed operations
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct MessageError {
+    /// Error code (e.g., "VALIDATION_ERROR", "TIMEOUT", "UNAUTHORIZED")
+    pub code: String,
+    /// Human-readable error message
+    pub message: String,
+}
+
+impl MessageEnvelope {
+    /// Create a new message envelope with the given operation and payload
+    pub fn new<T: Serialize>(operation: &str, payload: T) -> Result<Self, serde_json::Error> {
+        Ok(Self {
+            id: Uuid::new_v4().to_string(),
+            operation: operation.to_string(),
+            payload: serde_json::to_value(payload)?,
+            timestamp: chrono::Utc::now().to_rfc3339(),
+            correlation_id: None,
+            channel: None,
+            headers: None,
+            error: None,
+        })
+    }
+
+    /// Create a new envelope with automatic correlation ID generation
+    pub fn new_with_id<T: Serialize>(
+        operation: &str,
+        payload: T,
+    ) -> Result<Self, serde_json::Error> {
+        Self::new(operation, payload)
+            .map(|envelope| envelope.with_correlation_id(Uuid::new_v4().to_string()))
+    }
+
+    /// Create a new message envelope with a specific correlation ID
+    pub fn new_with_correlation_id<T: Serialize>(
+        operation: &str,
+        payload: T,
+        correlation_id: String,
+    ) -> Result<Self, serde_json::Error> {
+        let mut envelope = Self::new(operation, payload)?;
+        envelope.correlation_id = Some(correlation_id);
+        Ok(envelope)
+    }
+
+    /// Create an error response envelope
+    pub fn error_response(
+        operation: &str,
+        error_code: &str,
+        error_message: &str,
+        correlation_id: Option<String>,
+    ) -> Self {
+        Self {
+            id: Uuid::new_v4().to_string(),
+            operation: operation.to_string(),
+            payload: serde_json::Value::Null,
+            timestamp: chrono::Utc::now().to_rfc3339(),
+            correlation_id,
+            channel: None,
+            headers: None,
+            error: Some(MessageError {
+                code: error_code.to_string(),
+                message: error_message.to_string(),
+            }),
+        }
+    }
+
+    /// Set the correlation ID for this envelope
+    pub fn with_correlation_id(mut self, id: String) -> Self {
+        self.correlation_id = Some(id);
+        self
+    }
+
+    /// Set the channel for this envelope
+    pub fn with_channel(mut self, channel: String) -> Self {
+        self.channel = Some(channel);
+        self
+    }
+
+    /// Set headers for this envelope
+    pub fn with_headers(mut self, headers: HashMap<String, String>) -> Self {
+        self.headers = Some(headers);
+        self
+    }
+
+    /// Add a single header to this envelope
+    pub fn with_header(mut self, key: String, value: String) -> Self {
+        if self.headers.is_none() {
+            self.headers = Some(HashMap::new());
+        }
+        if let Some(ref mut headers) = self.headers {
+            headers.insert(key, value);
+        }
+        self
+    }
+
+    /// Add authentication headers to the envelope
+    /// This method accepts any headers map, allowing templates to integrate their own auth systems
+    pub fn with_auth_headers(mut self, auth_headers: HashMap<String, String>) -> Self {
+        if !auth_headers.is_empty() {
+            if let Some(ref mut headers) = self.headers {
+                headers.extend(auth_headers);
+            } else {
+                self.headers = Some(auth_headers);
+            }
+        }
+        self
+    }
+
+    /// Set an error on this envelope
+    pub fn with_error(mut self, code: &str, message: &str) -> Self {
+        self.error = Some(MessageError {
+            code: code.to_string(),
+            message: message.to_string(),
+        });
+        self
+    }
+
+    /// Extract the payload as a strongly-typed message
+    pub fn extract_payload<T: DeserializeOwned>(&self) -> Result<T, serde_json::Error> {
+        serde_json::from_value(self.payload.clone())
+    }
+
+    /// Check if this envelope contains an error
+    pub fn is_error(&self) -> bool {
+        self.error.is_some()
+    }
+
+    /// Get the correlation ID if present
+    pub fn correlation_id(&self) -> Option<&str> {
+        self.correlation_id.as_deref()
+    }
+
+    /// Create a response envelope with the same correlation ID
+    pub fn create_response<T: Serialize>(
+        &self,
+        response_operation: &str,
+        payload: T,
+    ) -> Result<Self, serde_json::Error> {
+        let mut response = Self::new(response_operation, payload)?;
+        response.correlation_id = self.correlation_id.clone();
+        response.channel = self.channel.clone();
+        Ok(response)
+    }
+
+    /// Convert the envelope to bytes for transport
+    pub fn to_bytes(&self) -> Result<Vec<u8>, serde_json::Error> {
+        serde_json::to_vec(self)
+    }
+
+    /// Parse envelope from bytes received from transport
+    pub fn from_bytes(bytes: &[u8]) -> Result<Self, serde_json::Error> {
+        serde_json::from_slice(bytes)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Debug, Serialize, Deserialize, PartialEq)]
+    struct TestPayload {
+        message: String,
+        count: u32,
+    }
+
+    #[test]
+    fn test_envelope_creation() {
+        let payload = TestPayload {
+            message: "test".to_string(),
+            count: 42,
+        };
+
+        let envelope = MessageEnvelope::new("test_operation", &payload).unwrap();
+
+        assert_eq!(envelope.operation, "test_operation");
+        assert!(!envelope.id.is_empty());
+        assert!(!envelope.timestamp.is_empty());
+        assert_eq!(envelope.correlation_id, None);
+        assert_eq!(envelope.error, None);
+
+        let extracted: TestPayload = envelope.extract_payload().unwrap();
+        assert_eq!(extracted, payload);
+    }
+
+    #[test]
+    fn test_envelope_with_correlation_id() {
+        let payload = TestPayload {
+            message: "test".to_string(),
+            count: 42,
+        };
+
+        let correlation_id = "test-correlation-id".to_string();
+        let envelope = MessageEnvelope::new_with_correlation_id(
+            "test_operation",
+            &payload,
+            correlation_id.clone(),
+        ).unwrap();
+
+        assert_eq!(envelope.correlation_id, Some(correlation_id));
+    }
+
+    #[test]
+    fn test_error_response() {
+        let error_envelope = MessageEnvelope::error_response(
+            "test_operation_response",
+            "TEST_ERROR",
+            "Test error message",
+            Some("correlation-123".to_string()),
+        );
+
+        assert!(error_envelope.is_error());
+        assert_eq!(error_envelope.correlation_id, Some("correlation-123".to_string()));
+        if let Some(error) = &error_envelope.error {
+            assert_eq!(error.code, "TEST_ERROR");
+            assert_eq!(error.message, "Test error message");
+        }
+    }
+
+    #[test]
+    fn test_envelope_serialization() {
+        let payload = TestPayload {
+            message: "test".to_string(),
+            count: 42,
+        };
+
+        let envelope = MessageEnvelope::new("test_operation", &payload).unwrap();
+        let bytes = envelope.to_bytes().unwrap();
+        let deserialized = MessageEnvelope::from_bytes(&bytes).unwrap();
+
+        assert_eq!(envelope.id, deserialized.id);
+        assert_eq!(envelope.operation, deserialized.operation);
+        assert_eq!(envelope.timestamp, deserialized.timestamp);
+    }
+
+    #[test]
+    fn test_response_creation() {
+        let request_payload = TestPayload {
+            message: "request".to_string(),
+            count: 1,
+        };
+
+        let response_payload = TestPayload {
+            message: "response".to_string(),
+            count: 2,
+        };
+
+        let request = MessageEnvelope::new_with_correlation_id(
+            "test_request",
+            &request_payload,
+            "test-correlation".to_string(),
+        ).unwrap();
+
+        let response = request.create_response("test_response", &response_payload).unwrap();
+
+        assert_eq!(response.operation, "test_response");
+        assert_eq!(response.correlation_id, request.correlation_id);
+
+        let extracted: TestPayload = response.extract_payload().unwrap();
+        assert_eq!(extracted, response_payload);
+    }
+
+    #[test]
+    fn test_headers_and_auth() {
+        let payload = TestPayload {
+            message: "test".to_string(),
+            count: 42,
+        };
+
+        let mut auth_headers = HashMap::new();
+        auth_headers.insert("Authorization".to_string(), "Bearer token123".to_string());
+
+        let envelope = MessageEnvelope::new("test_operation", &payload)
+            .unwrap()
+            .with_auth_headers(auth_headers)
+            .with_header("Custom-Header".to_string(), "custom-value".to_string());
+
+        assert!(envelope.headers.is_some());
+        let headers = envelope.headers.unwrap();
+        assert_eq!(headers.get("Authorization"), Some(&"Bearer token123".to_string()));
+        assert_eq!(headers.get("Custom-Header"), Some(&"custom-value".to_string()));
+    }
+}
+`;
+}
+;// ../common/src/models-ts.js
+/* eslint-disable no-unused-vars */
+
+
+/**
+ * Generate TypeScript models from AsyncAPI specification
+ * This helper extracts the common schema processing logic used by TypeScript templates
+ *
+ * @param {Object} asyncapi - AsyncAPI document
+ * @param {Object} options - Generation options
+ * @param {Function} options.toTypeScriptTypeName - Function to convert names to TypeScript type names
+ * @param {Function} options.toTypeScriptIdentifier - Function to convert names to TypeScript identifiers
+ * @param {boolean} options.includeMessageTypes - Whether to include message type constants
+ * @returns {Object} Generated models data and functions
+ */
+function generateTypeScriptModels(asyncapi, options = {}) {
+  const {
+    toTypeScriptTypeName,
+    toTypeScriptIdentifier,
+    includeMessageTypes = true
+  } = options;
+
+  // Helper functions for TypeScript identifier generation
+  function defaultToTypeScriptIdentifier(str) {
+    if (!str) return 'unknown';
+    let identifier = str.replace(/[^a-zA-Z0-9_]/g, '_').replace(/^[0-9]/, '_$&').replace(/_+/g, '_').replace(/^_+|_+$/g, '');
+    if (/^[0-9]/.test(identifier)) {
+      identifier = 'item_' + identifier;
+    }
+    if (!identifier) {
+      identifier = 'unknown';
+    }
+    return identifier;
+  }
+  function defaultToTypeScriptTypeName(str) {
+    if (!str) return 'Unknown';
+    // Handle camelCase and PascalCase properly
+    const identifier = str.replace(/[^a-zA-Z0-9]/g, '_').replace(/^[0-9]/, '_$&').replace(/_+/g, '_').replace(/^_+|_+$/g, '');
+
+    // Split on underscores and camelCase boundaries
+    const parts = identifier.split(/[_\s]+|(?=[A-Z])/);
+    return parts.filter(part => part.length > 0).map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+  }
+
+  // Use provided functions or defaults
+  const toTSTypeName = toTypeScriptTypeName || defaultToTypeScriptTypeName;
+  const toTSIdentifier = toTypeScriptIdentifier || defaultToTypeScriptIdentifier;
+
+  // Extract message schemas and build channel mapping
+  const components = asyncapi.components();
+  const messageSchemas = [];
+  const componentSchemas = [];
+  const messageToChannels = new Map();
+  const generatedTypes = new Set();
+  const schemaRegistry = new Map();
+
+  // Build schema registry from components.schemas
+  // Try to access the raw AsyncAPI document
+  let rawDoc = null;
+  try {
+    if (asyncapi.json && typeof asyncapi.json === 'function') {
+      rawDoc = asyncapi.json();
+    } else if (asyncapi._json) {
+      rawDoc = asyncapi._json;
+    }
+  } catch (e) {
+    // Ignore
+  }
+
+  // Extract schemas from raw document if available
+  if (rawDoc && rawDoc.components && rawDoc.components.schemas) {
+    Object.entries(rawDoc.components.schemas).forEach(([name, schema]) => {
+      if (name && typeof name === 'string' && schema && typeof schema === 'object') {
+        schemaRegistry.set(name, schema);
+        componentSchemas.push({
+          name,
+          typeName: toTSTypeName(name),
+          schema: schema,
+          description: schema.description
+        });
+      }
+    });
+  }
+
+  // Fallback: try the components.schemas() method
+  if (componentSchemas.length === 0 && components && components.schemas) {
+    try {
+      const schemas = components.schemas();
+      if (schemas) {
+        // Try different ways to access schemas
+        let schemaEntries = [];
+        if (schemas instanceof Map) {
+          schemaEntries = Array.from(schemas.entries());
+        } else if (typeof schemas === 'object') {
+          schemaEntries = Object.entries(schemas);
+        } else if (schemas.all && typeof schemas.all === 'function') {
+          // AsyncAPI parser might have an all() method
+          const allSchemas = schemas.all();
+          if (Array.isArray(allSchemas)) {
+            schemaEntries = allSchemas.map(schema => {
+              const name = schema.uid ? schema.uid() : schema.id ? schema.id() : null;
+              return [name, schema];
+            }).filter(([name]) => name);
+          }
+        }
+        schemaEntries.forEach(([name, schema]) => {
+          // Skip internal AsyncAPI parser objects and numeric keys
+          if (!name || name === 'collections' || name === '_meta' || name.startsWith('_') || /^\d+$/.test(name)) {
+            return;
+          }
+          let schemaData = null;
+          let description = null;
+          try {
+            // Handle different schema object types
+            if (schema && typeof schema.json === 'function') {
+              schemaData = schema.json();
+            } else if (schema && typeof schema === 'object') {
+              schemaData = schema;
+            }
+            if (schema && typeof schema.description === 'function') {
+              description = schema.description();
+            } else if (schema && schema.description) {
+              description = schema.description;
+            }
+          } catch (e) {
+            // Ignore schema extraction errors
+            console.warn(`Failed to extract schema for ${name}:`, e.message);
+          }
+          if (schemaData && typeof name === 'string' && name.length > 0) {
+            schemaRegistry.set(name, schemaData);
+            componentSchemas.push({
+              name,
+              typeName: toTSTypeName(name),
+              schema: schemaData,
+              description
+            });
+          }
+        });
+      }
+    } catch (e) {
+      console.warn('Failed to extract component schemas:', e.message);
+    }
+  }
+
+  // First, build channel to message mapping
+  if (asyncapi.channels) {
+    const channels = asyncapi.channels();
+    if (channels) {
+      Object.entries(channels).forEach(([channelName, channel]) => {
+        try {
+          // Handle AsyncAPI 3.x format
+          if (channel.messages) {
+            const messages = channel.messages();
+            if (messages) {
+              Object.entries(messages).forEach(([msgKey, message]) => {
+                if (message) {
+                  let messageName = null;
+                  if (message.$ref) {
+                    messageName = message.$ref.split('/').pop();
+                  } else if (message.name) {
+                    messageName = typeof message.name === 'function' ? message.name() : message.name;
+                  }
+                  if (messageName) {
+                    if (!messageToChannels.has(messageName)) {
+                      messageToChannels.set(messageName, []);
+                    }
+                    messageToChannels.get(messageName).push(channelName);
+                  }
+                }
+              });
+            }
+          }
+        } catch (e) {
+          // Ignore channel processing errors
+        }
+      });
+    }
+  }
+
+  // Extract messages from components
+  if (components && components.messages) {
+    const messages = components.messages();
+    if (messages) {
+      Object.entries(messages).forEach(([name, message]) => {
+        // Skip internal AsyncAPI parser objects
+        if (name === 'collections' || name === '_meta' || name.startsWith('_')) {
+          return;
+        }
+        let payload = null;
+        let description = null;
+        let title = null;
+        let messageName = name;
+        try {
+          if (message.payload && typeof message.payload === 'function') {
+            const payloadSchema = message.payload();
+            payload = payloadSchema && payloadSchema.json ? payloadSchema.json() : payloadSchema;
+          }
+          description = message.description && typeof message.description === 'function' ? message.description() : message.description;
+          title = message.title && typeof message.title === 'function' ? message.title() : message.title;
+
+          // Try to get the actual message name
+          if (message.name && typeof message.name === 'function') {
+            messageName = message.name();
+          } else if (message.name) {
+            messageName = message.name;
+          }
+        } catch (e) {
+          // Ignore payload extraction errors
+        }
+        const channels = messageToChannels.get(messageName) || messageToChannels.get(name) || [];
+        messageSchemas.push({
+          name: messageName,
+          typeName: toTSTypeName(messageName),
+          payload,
+          description: description || title,
+          channels
+        });
+      });
+    }
+  }
+
+  // Helper function to convert JSON schema to TypeScript type
+  function jsonSchemaToTypeScriptType(schema, fieldName = '') {
+    if (!schema) return 'any';
+
+    // Handle $ref - resolve from schema registry
+    if (schema.$ref) {
+      const refName = schema.$ref.split('/').pop();
+      // Always return the type name for $ref, since we generate all component schemas
+      const typeName = toTSTypeName(refName);
+      return typeName;
+    }
+
+    // Handle resolved $ref - check for x-parser-schema-id which indicates original schema name
+    if (schema['x-parser-schema-id'] && typeof schema['x-parser-schema-id'] === 'string') {
+      const schemaId = schema['x-parser-schema-id'];
+      // Check if this matches a known component schema
+      if (schemaRegistry.has(schemaId)) {
+        const typeName = toTSTypeName(schemaId);
+        return typeName;
+      }
+    }
+    if (!schema.type) {
+      // If no type specified, check for properties (object) or items (array)
+      if (schema.properties) {
+        schema.type = 'object';
+      } else if (schema.items) {
+        schema.type = 'array';
+      } else {
+        return 'any';
+      }
+    }
+    switch (schema.type) {
+      case 'string':
+        if (schema.enum && schema.enum.length > 0) {
+          return schema.enum.map(val => `'${val}'`).join(' | ');
+        }
+        return 'string';
+      case 'integer':
+      case 'number':
+        return 'number';
+      case 'boolean':
+        return 'boolean';
+      case 'array':
+        {
+          if (schema.items) {
+            const itemType = jsonSchemaToTypeScriptType(schema.items, fieldName);
+            return `${itemType}[]`;
+          }
+          return 'any[]';
+        }
+      case 'object':
+        // For objects with properties, we should generate inline types or check if it's a known schema
+        if (schema.properties) {
+          // This is a complex object - for now return Record<string, any>
+          // In a more sophisticated implementation, we could generate inline types
+          return 'Record<string, any>';
+        }
+        return 'Record<string, any>';
+      default:
+        return 'any';
+    }
+  }
+
+  // Generate message interfaces
+  function generateMessageInterface(schema, messageName) {
+    if (!schema || !schema.properties) {
+      return '  [key: string]: any;';
+    }
+    const fields = Object.entries(schema.properties).map(([fieldName, fieldSchema]) => {
+      const tsType = jsonSchemaToTypeScriptType(fieldSchema, fieldName);
+      const optional = !schema.required || !schema.required.includes(fieldName);
+      const optionalMarker = optional ? '?' : '';
+      let fieldDoc = '';
+      if (fieldSchema.description) {
+        fieldDoc = `  /** ${fieldSchema.description} */\n`;
+      }
+      return `${fieldDoc}  ${fieldName}${optionalMarker}: ${tsType};`;
+    }).join('\n');
+    return fields;
+  }
+
+  // Return the processed data and generation functions
+  return {
+    messageSchemas,
+    componentSchemas,
+    messageToChannels,
+    generatedTypes,
+    schemaRegistry,
+    // Generation functions
+    generateMessageInterface,
+    jsonSchemaToTypeScriptType,
+    // Generate interfaces for component schemas
+    generateComponentSchemas() {
+      let content = '';
+      componentSchemas.forEach(schema => {
+        const doc = schema.description ? `/** ${schema.description} */\n` : `/** ${schema.name} */\n`;
+
+        // Check if this is a standalone enum schema
+        if (schema.schema.type === 'string' && schema.schema.enum && Array.isArray(schema.schema.enum)) {
+          // Generate union type for enum
+          const enumValues = schema.schema.enum.map(val => `'${val}'`).join(' | ');
+          content += `${doc}export type ${schema.typeName} = ${enumValues};\n\n`;
+        } else {
+          // Generate interface for object schema
+          content += `${doc}export interface ${schema.typeName} {\n`;
+          content += generateMessageInterface(schema.schema, schema.typeName);
+          content += '\n}\n\n';
+        }
+
+        // Track generated types to avoid duplicates
+        generatedTypes.add(schema.typeName);
+      });
+      return content;
+    },
+    // Generate interfaces for each message
+    generateMessageSchemas() {
+      let content = '';
+      messageSchemas.forEach(schema => {
+        const interfaceName = `${schema.typeName}Payload`;
+
+        // Check if this is a duplicate of a component schema
+        // For message payloads that match component schema names, skip the payload version
+        if (generatedTypes.has(schema.typeName) || generatedTypes.has(interfaceName)) {
+          // Skip generating the payload version if we already have the component schema
+          return;
+        }
+        const doc = schema.description ? `/** ${schema.description} */\n` : `/** ${schema.name} message payload */\n`;
+        content += `${doc}export interface ${interfaceName} {\n`;
+        content += generateMessageInterface(schema.payload, schema.typeName);
+        content += '\n}\n\n';
+        generatedTypes.add(interfaceName);
+      });
+      return content;
+    },
+    // Generate message type constants and unions
+    generateMessageTypes() {
+      if (!includeMessageTypes || messageSchemas.length === 0) {
+        return '';
+      }
+      let content = '';
+
+      // Generate a union type for all message payloads
+      const payloadTypes = messageSchemas.map(schema => `${schema.typeName}Payload`).join(' | ');
+      content += '/** Union type for all message payloads */\n';
+      content += `export type MessagePayload = ${payloadTypes};\n\n`;
+
+      // Generate message type constants
+      content += '/** Message type constants */\n';
+      content += 'export const MessageTypes = {\n';
+      messageSchemas.forEach(schema => {
+        content += `  ${schema.typeName.toUpperCase()}: '${schema.name}',\n`;
+      });
+      content += '} as const;\n\n';
+      content += '/** Message type union */\n';
+      content += 'export type MessageType = typeof MessageTypes[keyof typeof MessageTypes];\n\n';
+      return content;
+    }
+  };
+}
 ;// ../common/src/index.js
 /**
  * AsyncAPI Common Template Utilities
@@ -1909,6 +3373,11 @@ function generateOperationHandlerName(operation, suffix = 'Handler') {
 // Operation utilities
 
 
+// Model generation utilities
+
+
+
+
 // Re-export all utilities
 
 
@@ -1998,7 +3467,12 @@ function getAllUtilities() {
       operationHasTraits: operationHasTraits,
       getOperationTags: getOperationTags,
       generateOperationHandlerName: generateOperationHandlerName
+    },
+    models: {
+      generateRustModels: generateRustModels,
+      generateMessageEnvelope: generateMessageEnvelope,
+      generateTypeScriptModels: generateTypeScriptModels
     }
   };
 }
-export { VERSION, analyzeChannelServerMappings, analyzeOperationSecurity, channelHasParameters, extractAllOperations, extractAsyncApiInfo, extractChannelParameters, extractChannelVariables, extractOperationSecurityMap, extractServerNameFromRef, formatGenerationDate, generateChannelFormatting, generateChannelParameterArgs, generateEslintConfig, generateFileHeader, generateOperationHandlerName, generatePackageJson, generateReadmeContent, generateTypeScriptChannelFormatting, generateTypeScriptChannelParameterArgs, generateTypeScriptConfig, getAllSecuritySchemes, getAllUtilities, getChannelAddress, getChannelParameters, getDefaultPort, getMessageContentType, getMessageRustTypeName, getMessageTypeName, getMessageTypeScriptTypeName, getNatsSubject, getOperationAction, getOperationChannel, getOperationDescription, getOperationMessages, getOperationName, getOperationRustFunctionName, getOperationSummary, getOperationTags, getOperationTraits, getOperationTypeScriptMethodName, getPayloadRustTypeName, getPayloadTypeScriptTypeName, getSecuritySchemeLocation, getSecuritySchemeName, getSecuritySchemeType, groupOperationsByAction, hasSecuritySchemes, isChannelAllowedOnServer, isDynamicChannel, isOperationReceive, isOperationSend, isSecuritySchemeType, isTemplateVariable, messageHasPayload, operationHasSecurity, operationHasTraits, operationRequiresAuth, resolveChannelAddress, resolveTemplateParameters, toCamelCase, toKebabCase, toPascalCase, toRustEnumVariant, toRustEnumVariantWithSerde, toRustFieldName, toRustIdentifier, toRustTypeName, toSnakeCase, validateChannelServerReferences, validateTemplateParameters };
+export { VERSION, analyzeChannelServerMappings, analyzeOperationSecurity, channelHasParameters, extractAllOperations, extractAsyncApiInfo, extractChannelParameters, extractChannelVariables, extractOperationSecurityMap, extractServerNameFromRef, formatGenerationDate, generateChannelFormatting, generateChannelParameterArgs, generateEslintConfig, generateFileHeader, generateMessageEnvelope, generateOperationHandlerName, generatePackageJson, generateReadmeContent, generateRustModels, generateTypeScriptChannelFormatting, generateTypeScriptChannelParameterArgs, generateTypeScriptConfig, generateTypeScriptModels, getAllSecuritySchemes, getAllUtilities, getChannelAddress, getChannelParameters, getDefaultPort, getMessageContentType, getMessageRustTypeName, getMessageTypeName, getMessageTypeScriptTypeName, getNatsSubject, getOperationAction, getOperationChannel, getOperationDescription, getOperationMessages, getOperationName, getOperationRustFunctionName, getOperationSummary, getOperationTags, getOperationTraits, getOperationTypeScriptMethodName, getPayloadRustTypeName, getPayloadTypeScriptTypeName, getSecuritySchemeLocation, getSecuritySchemeName, getSecuritySchemeType, groupOperationsByAction, hasSecuritySchemes, isChannelAllowedOnServer, isDynamicChannel, isOperationReceive, isOperationSend, isSecuritySchemeType, isTemplateVariable, messageHasPayload, operationHasSecurity, operationHasTraits, operationRequiresAuth, resolveChannelAddress, resolveTemplateParameters, toCamelCase, toKebabCase, toPascalCase, toRustEnumVariant, toRustEnumVariantWithSerde, toRustFieldName, toRustIdentifier, toRustTypeName, toSnakeCase, validateChannelServerReferences, validateTemplateParameters };