@ioka-technologies/asyncapi-rust-client-template 0.0.21 → 0.0.23

package/dist/common/index.js

@@ -0,0 +1,3478 @@
+import "@asyncapi/generator-react-sdk";
+/******/ // The require scope
+/******/ var __webpack_require__ = {};
+/******/ 
+/************************************************************************/
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ 	// define getter functions for harmony exports
+/******/ 	__webpack_require__.d = (exports, definition) => {
+/******/ 		for(var key in definition) {
+/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 			}
+/******/ 		}
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/ 
+/************************************************************************/
+var __webpack_exports__ = {};
+
+;// ../common/src/string-utils.js
+/**
+ * String conversion utilities for AsyncAPI template generation
+ *
+ * This module provides consistent string conversion functions used across
+ * multiple AsyncAPI templates to ensure naming conventions are standardized.
+ */
+
+/**
+ * Converts a string to a valid Rust identifier
+ * Handles special characters, keywords, and ensures valid Rust naming conventions
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} Valid Rust identifier
+ */
+function toRustIdentifier(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';
+  }
+  const rustKeywords = ['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'];
+  if (rustKeywords.includes(identifier)) {
+    identifier = identifier + '_';
+  }
+  return identifier;
+}
+
+/**
+ * Converts a string to PascalCase Rust type name
+ * Handles camelCase, snake_case, and kebab-case inputs
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} PascalCase Rust type name
+ */
+function toRustTypeName(str) {
+  if (!str) return 'Unknown';
+
+  // Ensure str is a string
+  const strValue = String(str);
+  const identifier = toRustIdentifier(strValue);
+
+  // Handle camelCase and PascalCase inputs by splitting on capital letters too
+  const parts = identifier.replace(/([a-z])([A-Z])/g, '$1_$2') // Insert underscore before capital letters
+  .split(/[_\s-]+/) // Split on underscores, spaces, and hyphens
+  .filter(part => part.length > 0);
+  return parts.map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+}
+
+/**
+ * Converts a string to snake_case Rust field name
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} snake_case Rust field name
+ */
+function toRustFieldName(str) {
+  if (!str) return 'unknown';
+  const identifier = toRustIdentifier(str);
+  return identifier.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '').replace(/_+/g, '_');
+}
+
+/**
+ * Converts a string to Rust enum variant name (PascalCase)
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} PascalCase enum variant name
+ */
+function toRustEnumVariant(str) {
+  if (!str) return 'Unknown';
+  return str.split(/[-_\s]+/).map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+}
+
+/**
+ * Converts a string to Rust enum variant with serde rename for lowercase serialization
+ *
+ * @param {string} str - Input string to convert
+ * @returns {object} Object with rustName (PascalCase) and serializedName (lowercase)
+ */
+function toRustEnumVariantWithSerde(str) {
+  if (!str) return {
+    rustName: 'Unknown',
+    serializedName: 'unknown'
+  };
+  const rustName = str.split(/[-_\s]+/).map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+  const serializedName = str.toLowerCase();
+  return {
+    rustName,
+    serializedName
+  };
+}
+
+/**
+ * Converts a string to kebab-case
+ * Useful for package names and file names
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} kebab-case string
+ */
+function toKebabCase(str) {
+  if (!str) return '';
+  return str.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+}
+
+/**
+ * Converts a string to PascalCase
+ * Useful for class names and type names
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} PascalCase string
+ */
+function toPascalCase(str) {
+  if (!str) return '';
+  return str.replace(/[^a-zA-Z0-9]/g, ' ').split(' ').map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join('');
+}
+
+/**
+ * Converts a string to snake_case
+ * Useful for Rust identifiers and file names
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} snake_case string
+ */
+function toSnakeCase(str) {
+  if (!str) return '';
+  return str.toLowerCase().replace(/[^a-z0-9]/g, '_').replace(/_+/g, '_').replace(/^_|_$/g, '');
+}
+
+/**
+ * Converts a string to camelCase
+ * Useful for JavaScript/TypeScript identifiers
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} camelCase string
+ */
+function toCamelCase(str) {
+  if (!str) return '';
+  const pascalCase = toPascalCase(str);
+  return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
+}
+;// ../common/src/message-utils.js
+/**
+ * Message processing utilities for AsyncAPI template generation
+ *
+ * This module provides functions for extracting and processing message information
+ * from AsyncAPI specifications, handling various AsyncAPI versions and formats.
+ */
+
+
+
+/**
+ * Gets the message type name from a message object
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string|null} Message type name or null if not found
+ */
+function getMessageTypeName(message) {
+  if (!message) return null;
+  try {
+    // Try AsyncAPI 3.x format first - check _meta and _json properties
+    if (message._meta && message._meta.id) {
+      return message._meta.id;
+    }
+    if (message._json && message._json['x-parser-message-name']) {
+      return message._json['x-parser-message-name'];
+    }
+    if (message._json && message._json['x-parser-unique-object-id']) {
+      return message._json['x-parser-unique-object-id'];
+    }
+
+    // Try different ways to get the message name
+    if (message.name && typeof message.name === 'function') {
+      return message.name();
+    }
+    if (message.name && typeof message.name === 'string') {
+      return message.name;
+    }
+    if (message.title && typeof message.title === 'function') {
+      return message.title();
+    }
+    if (message.title && typeof message.title === 'string') {
+      return message.title;
+    }
+
+    // Try to extract from $ref
+    if (message.$ref) {
+      return message.$ref.split('/').pop();
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Gets the proper Rust type name from a message
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string} Rust type name
+ */
+function getMessageRustTypeName(message) {
+  const messageName = getMessageTypeName(message);
+  return messageName ? toRustTypeName(messageName) : 'UnknownMessage';
+}
+
+/**
+ * Gets the payload component schema Rust type name from a message
+ * This extracts the actual payload type (component schema) rather than the message wrapper
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string} Rust type name for the payload component schema
+ */
+function getPayloadRustTypeName(message) {
+  if (!message) return 'UnknownPayload';
+  try {
+    // First priority: For inline message schemas, get the message name itself
+    // This handles cases where the message is defined inline in channels
+    const messageName = getMessageTypeName(message);
+    if (messageName) {
+      // Check if this is a component message reference (has payload.$ref)
+      let payload = null;
+      if (message.payload && typeof message.payload === 'function') {
+        payload = message.payload();
+      } else if (message.payload) {
+        payload = message.payload;
+      }
+
+      // Check the message's _json for payload information
+      const messageJson = message._json || message;
+      if (!payload && messageJson.payload) {
+        payload = messageJson.payload;
+      }
+
+      // If payload has a $ref, this is a component message - extract the schema name
+      if (payload && payload.$ref) {
+        const refParts = payload.$ref.split('/');
+        const schemaName = refParts[refParts.length - 1];
+        return toRustTypeName(schemaName);
+      }
+
+      // For inline message schemas, use the message name directly as the payload type
+      // This is the correct approach for messages defined inline in channels
+      return toRustTypeName(messageName);
+    }
+
+    // Second priority: Try to get the payload schema reference from the message
+    let payload = null;
+
+    // Try different ways to access the payload
+    if (message.payload && typeof message.payload === 'function') {
+      payload = message.payload();
+    } else if (message.payload) {
+      payload = message.payload;
+    }
+    if (payload) {
+      // Check for $ref in the payload (direct reference to component schema)
+      if (payload.$ref) {
+        const refParts = payload.$ref.split('/');
+        const schemaName = refParts[refParts.length - 1];
+        return toRustTypeName(schemaName);
+      }
+
+      // Check for resolved $ref using x-parser-schema-id
+      if (payload['x-parser-schema-id']) {
+        return toRustTypeName(payload['x-parser-schema-id']);
+      }
+
+      // Check for x-parser-schema-id in _json
+      if (payload._json && payload._json['x-parser-schema-id']) {
+        return toRustTypeName(payload._json['x-parser-schema-id']);
+      }
+
+      // Check for title or name in the payload schema
+      if (payload.title) {
+        const title = typeof payload.title === 'function' ? payload.title() : payload.title;
+        if (title) return toRustTypeName(title);
+      }
+      if (payload.name) {
+        const name = typeof payload.name === 'function' ? payload.name() : payload.name;
+        if (name) return toRustTypeName(name);
+      }
+    }
+
+    // Check the message's _json for payload information
+    const messageJson = message._json || message;
+    if (messageJson.payload) {
+      if (messageJson.payload.$ref) {
+        const refParts = messageJson.payload.$ref.split('/');
+        const schemaName = refParts[refParts.length - 1];
+        return toRustTypeName(schemaName);
+      }
+      if (messageJson.payload['x-parser-schema-id']) {
+        return toRustTypeName(messageJson.payload['x-parser-schema-id']);
+      }
+      if (messageJson.payload.title) {
+        return toRustTypeName(messageJson.payload.title);
+      }
+    }
+
+    // Final fallback: try to extract from message title or name directly
+    if (message.title && typeof message.title === 'function') {
+      const title = message.title();
+      if (title && typeof title === 'string') {
+        return toRustTypeName(title);
+      }
+    } else if (message.title && typeof message.title === 'string') {
+      return toRustTypeName(message.title);
+    }
+    if (message.name && typeof message.name === 'function') {
+      const name = message.name();
+      if (name && typeof name === 'string') {
+        return toRustTypeName(name);
+      }
+    } else if (message.name && typeof message.name === 'string') {
+      return toRustTypeName(message.name);
+    }
+
+    // Check message._json for title/name
+    if (messageJson.title && typeof messageJson.title === 'string') {
+      return toRustTypeName(messageJson.title);
+    }
+    if (messageJson.name && typeof messageJson.name === 'string') {
+      return toRustTypeName(messageJson.name);
+    }
+    return 'UnknownPayload';
+  } catch (e) {
+    console.warn('Error extracting payload type name:', e.message);
+    return 'UnknownPayload';
+  }
+}
+
+/**
+ * Gets the TypeScript type name from a message for TypeScript templates
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string} TypeScript type name
+ */
+function getMessageTypeScriptTypeName(message) {
+  const messageName = getMessageTypeName(message);
+  if (!messageName) return 'UnknownMessage';
+
+  // Convert to PascalCase for TypeScript interfaces
+  return messageName.split(/[-_\s]+/).map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+}
+
+/**
+ * Gets the payload TypeScript type name from a message
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string} TypeScript type name for the payload
+ */
+function getPayloadTypeScriptTypeName(message) {
+  if (!message) return 'unknown';
+  try {
+    // Similar logic to getPayloadRustTypeName but for TypeScript naming
+    const messageName = getMessageTypeName(message);
+    if (messageName) {
+      let payload = null;
+      if (message.payload && typeof message.payload === 'function') {
+        payload = message.payload();
+      } else if (message.payload) {
+        payload = message.payload;
+      }
+      const messageJson = message._json || message;
+      if (!payload && messageJson.payload) {
+        payload = messageJson.payload;
+      }
+      if (payload && payload.$ref) {
+        const refParts = payload.$ref.split('/');
+        const schemaName = refParts[refParts.length - 1];
+        return schemaName.split(/[-_\s]+/).map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+      }
+      return messageName.split(/[-_\s]+/).map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+    }
+    return 'unknown';
+  } catch (e) {
+    console.warn('Error extracting TypeScript payload type name:', e.message);
+    return 'unknown';
+  }
+}
+
+/**
+ * Checks if a message has a payload schema defined
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {boolean} True if message has a payload schema
+ */
+function messageHasPayload(message) {
+  if (!message) return false;
+  try {
+    // Check for payload function
+    if (message.payload && typeof message.payload === 'function') {
+      const payload = message.payload();
+      return payload !== null && payload !== undefined;
+    }
+
+    // Check for payload property
+    if (message.payload) {
+      return true;
+    }
+
+    // Check _json for payload
+    const messageJson = message._json || message;
+    return !!messageJson.payload;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Gets the content type of a message
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string} Content type (e.g., 'application/json')
+ */
+function getMessageContentType(message) {
+  if (!message) return 'application/json';
+  try {
+    // Check for contentType function
+    if (message.contentType && typeof message.contentType === 'function') {
+      return message.contentType() || 'application/json';
+    }
+
+    // Check for contentType property
+    if (message.contentType) {
+      return message.contentType;
+    }
+
+    // Check _json for contentType
+    const messageJson = message._json || message;
+    if (messageJson.contentType) {
+      return messageJson.contentType;
+    }
+    return 'application/json';
+  } catch (e) {
+    return 'application/json';
+  }
+}
+;// ../common/src/channel-utils.js
+/**
+ * Channel processing utilities for AsyncAPI template generation
+ *
+ * This module provides functions for handling channels, parameters, and
+ * dynamic channel address resolution across different AsyncAPI templates.
+ */
+
+
+
+/**
+ * Gets the NATS subject from a channel address
+ *
+ * @param {object} channel - AsyncAPI channel object
+ * @returns {string} NATS subject
+ */
+function getNatsSubject(channel) {
+  try {
+    if (channel.address && typeof channel.address === 'function') {
+      return channel.address();
+    } else if (channel.address) {
+      return channel.address;
+    } else if (channel.id && typeof channel.id === 'function') {
+      return channel.id();
+    } else if (channel.id) {
+      return channel.id;
+    }
+    return 'unknown.subject';
+  } catch (e) {
+    return 'unknown.subject';
+  }
+}
+
+/**
+ * Gets the channel address from a channel object
+ * This is a more generic version of getNatsSubject that works for any protocol
+ *
+ * @param {object} channel - AsyncAPI channel object
+ * @returns {string} Channel address
+ */
+function getChannelAddress(channel) {
+  try {
+    if (channel.address && typeof channel.address === 'function') {
+      return channel.address();
+    } else if (channel.address) {
+      return channel.address;
+    } else if (channel.id && typeof channel.id === 'function') {
+      return channel.id();
+    } else if (channel.id) {
+      return channel.id;
+    }
+    return 'unknown.address';
+  } catch (e) {
+    return 'unknown.address';
+  }
+}
+
+/**
+ * Checks if a channel address contains variables (dynamic channel)
+ *
+ * @param {string} address - Channel address
+ * @returns {boolean} True if the address contains variables
+ */
+function isDynamicChannel(address) {
+  if (!address || typeof address !== 'string') return false;
+  return /\{[^}]+\}/.test(address);
+}
+
+/**
+ * Extracts variable names from a channel address
+ *
+ * @param {string} address - Channel address with variables
+ * @returns {Array<string>} Array of variable names
+ */
+function extractChannelVariables(address) {
+  if (!address || typeof address !== 'string') return [];
+  const matches = address.match(/\{([^}]+)\}/g);
+  if (!matches) return [];
+  return matches.map(match => match.slice(1, -1)); // Remove { and }
+}
+
+/**
+ * Extracts channel parameters from a dynamic channel address
+ *
+ * @param {string} channelAddress - Channel address like "device.{device_id}" or "user.{user_id}.notifications"
+ * @returns {Array} Array of parameter objects with name and rustName
+ */
+function extractChannelParameters(channelAddress) {
+  if (!channelAddress) return [];
+  const parameterRegex = /\{([^}]+)\}/g;
+  const parameters = [];
+  let match;
+  while ((match = parameterRegex.exec(channelAddress)) !== null) {
+    const paramName = match[1];
+    parameters.push({
+      name: paramName,
+      rustName: toRustFieldName(paramName),
+      placeholder: match[0] // The full {param_name} string
+    });
+  }
+  return parameters;
+}
+
+/**
+ * Gets channel parameters from a channel object
+ *
+ * @param {object} channel - AsyncAPI channel object
+ * @returns {Array<object>} Array of parameter objects with name and description
+ */
+function getChannelParameters(channel) {
+  try {
+    const parameters = [];
+
+    // Try to get parameters from the channel
+    let channelParams = null;
+    if (channel.parameters && typeof channel.parameters === 'function') {
+      channelParams = channel.parameters();
+    } else if (channel.parameters) {
+      channelParams = channel.parameters;
+    } else if (channel._json && channel._json.parameters) {
+      channelParams = channel._json.parameters;
+    }
+    if (channelParams) {
+      // Handle different parameter formats
+      if (typeof channelParams === 'object') {
+        for (const [paramName, paramDef] of Object.entries(channelParams)) {
+          // Skip internal AsyncAPI parser properties
+          if (paramName.startsWith('_') || paramName === 'collections' || paramName === 'meta') {
+            continue;
+          }
+          let description = 'Channel parameter';
+          if (paramDef && typeof paramDef === 'object') {
+            if (typeof paramDef.description === 'string') {
+              description = paramDef.description;
+            } else if (typeof paramDef.description === 'function') {
+              try {
+                description = paramDef.description();
+              } catch (e) {
+                description = 'Channel parameter';
+              }
+            } else if (paramDef._json && paramDef._json.description) {
+              description = paramDef._json.description;
+            }
+          } else if (typeof paramDef === 'string') {
+            description = paramDef;
+          }
+          parameters.push({
+            name: paramName,
+            description: description,
+            rustName: toRustFieldName(paramName),
+            rustType: 'String' // For now, assume all parameters are strings
+          });
+        }
+      }
+    }
+    return parameters;
+  } catch (e) {
+    console.warn('Error extracting channel parameters:', e.message);
+    return [];
+  }
+}
+
+/**
+ * Resolves a dynamic channel address with provided variable values
+ *
+ * @param {string} address - Channel address template with variables
+ * @param {object} variables - Object mapping variable names to values
+ * @returns {string} Resolved channel address
+ */
+function resolveChannelAddress(address, variables) {
+  if (!address || typeof address !== 'string') return address;
+  if (!variables || typeof variables !== 'object') return address;
+  let resolved = address;
+  for (const [varName, varValue] of Object.entries(variables)) {
+    const placeholder = `{${varName}}`;
+    resolved = resolved.replace(new RegExp(placeholder.replace(/[{}]/g, '\\$&'), 'g'), varValue);
+  }
+  return resolved;
+}
+
+/**
+ * Checks if a channel has dynamic parameters
+ *
+ * @param {object} channel - AsyncAPI channel object
+ * @returns {boolean} True if the channel has parameters
+ */
+function channelHasParameters(channel) {
+  const address = getChannelAddress(channel);
+  return isDynamicChannel(address);
+}
+
+/**
+ * Generates Rust function parameters for dynamic channel parameters
+ *
+ * @param {Array} channelParameters - Array of channel parameter objects
+ * @returns {string} Rust function parameter string
+ */
+function generateChannelParameterArgs(channelParameters) {
+  if (!channelParameters || channelParameters.length === 0) {
+    return '';
+  }
+  return channelParameters.map(param => `${param.rustName}: String`).join(', ') + ', ';
+}
+
+/**
+ * Generates Rust format string and arguments for dynamic channel resolution
+ *
+ * @param {string} channelAddress - Original channel address with parameters
+ * @param {Array} channelParameters - Array of channel parameter objects
+ * @returns {object} Object with formatString and formatArgs
+ */
+function generateChannelFormatting(channelAddress, channelParameters) {
+  if (!channelParameters || channelParameters.length === 0) {
+    return {
+      formatString: `"${channelAddress}".to_string()`,
+      formatArgs: ''
+    };
+  }
+
+  // Replace parameter placeholders with format placeholders
+  let formatString = channelAddress;
+  const formatArgs = [];
+  for (const param of channelParameters) {
+    formatString = formatString.replace(param.placeholder, '{}');
+    formatArgs.push(param.rustName);
+  }
+  return {
+    formatString: `format!("${formatString}", ${formatArgs.join(', ')})`,
+    formatArgs: formatArgs.join(', ')
+  };
+}
+
+/**
+ * Generates TypeScript function parameters for dynamic channel parameters
+ *
+ * @param {Array} channelParameters - Array of channel parameter objects
+ * @returns {string} TypeScript function parameter string
+ */
+function generateTypeScriptChannelParameterArgs(channelParameters) {
+  if (!channelParameters || channelParameters.length === 0) {
+    return '';
+  }
+  return channelParameters.map(param => `${param.name}: string`).join(', ') + ', ';
+}
+
+/**
+ * Generates TypeScript template literal for dynamic channel resolution
+ *
+ * @param {string} channelAddress - Original channel address with parameters
+ * @param {Array} channelParameters - Array of channel parameter objects
+ * @returns {string} TypeScript template literal string
+ */
+function generateTypeScriptChannelFormatting(channelAddress, channelParameters) {
+  if (!channelParameters || channelParameters.length === 0) {
+    return `'${channelAddress}'`;
+  }
+
+  // Replace parameter placeholders with template literal placeholders
+  let templateString = channelAddress;
+  for (const param of channelParameters) {
+    templateString = templateString.replace(param.placeholder, `\${${param.name}}`);
+  }
+  return `\`${templateString}\``;
+}
+
+/**
+ * Extracts server name from a $ref string
+ *
+ * @param {string} serverRef - Server reference like "#/servers/mqtt-server"
+ * @returns {string|null} Server name or null if invalid
+ */
+function extractServerNameFromRef(serverRef) {
+  if (!serverRef || typeof serverRef !== 'string') return null;
+
+  // Handle $ref format: "#/servers/server-name"
+  const refMatch = serverRef.match(/^#\/servers\/(.+)$/);
+  if (refMatch) {
+    return refMatch[1];
+  }
+  return null;
+}
+
+/**
+ * Analyzes channel server restrictions from AsyncAPI specification
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {Array} Array of channel server mapping objects
+ */
+function analyzeChannelServerMappings(asyncapi) {
+  const mappings = [];
+  try {
+    const channels = asyncapi.channels();
+    if (!channels) return mappings;
+    for (const channel of channels) {
+      const channelName = channel.id();
+      let allowedServers = null; // null means available on all servers
+
+      // Try to get servers from the channel object
+      let channelServers = null;
+
+      // Method 1: Try channel.servers() function
+      if (channel.servers && typeof channel.servers === 'function') {
+        try {
+          channelServers = channel.servers();
+        } catch (e) {
+          // Ignore errors and try other methods
+        }
+      }
+
+      // Method 2: Try channel._json.servers (raw JSON data)
+      if (!channelServers && channel._json && channel._json.servers) {
+        channelServers = channel._json.servers;
+      }
+
+      // Method 3: Try direct property access
+      if (!channelServers && channel.servers && Array.isArray(channel.servers)) {
+        channelServers = channel.servers;
+      }
+      if (channelServers && Array.isArray(channelServers) && channelServers.length > 0) {
+        // Extract server names from $ref strings
+        allowedServers = [];
+        for (const serverRef of channelServers) {
+          let serverName = null;
+
+          // Handle different ways the server reference might be provided
+          if (typeof serverRef === 'string') {
+            serverName = extractServerNameFromRef(serverRef);
+          } else if (serverRef && serverRef.$ref) {
+            serverName = extractServerNameFromRef(serverRef.$ref);
+          } else if (serverRef && typeof serverRef.id === 'function') {
+            serverName = serverRef.id();
+          } else if (serverRef && typeof serverRef.id === 'string') {
+            serverName = serverRef.id;
+          }
+          if (serverName) {
+            allowedServers.push(serverName);
+          }
+        }
+
+        // If no valid server names were extracted, treat as available on all servers
+        if (allowedServers.length === 0) {
+          allowedServers = null;
+        }
+      }
+      mappings.push({
+        channelName: channelName,
+        allowedServers: allowedServers,
+        rustChannelName: toRustIdentifier(channelName),
+        description: channel.description && channel.description() || ''
+      });
+    }
+  } catch (e) {
+    console.warn('Error analyzing channel server mappings:', e.message);
+  }
+  return mappings;
+}
+
+/**
+ * Checks if a channel is allowed on a specific server
+ *
+ * @param {string} channelName - Name of the channel
+ * @param {string} serverName - Name of the server
+ * @param {Array} channelMappings - Array of channel server mappings
+ * @returns {boolean} True if channel is allowed on the server
+ */
+function isChannelAllowedOnServer(channelName, serverName, channelMappings) {
+  const mapping = channelMappings.find(m => m.channelName === channelName);
+  if (!mapping) {
+    // If no mapping found, assume channel is allowed on all servers
+    return true;
+  }
+
+  // If allowedServers is null, channel is available on all servers
+  if (mapping.allowedServers === null) {
+    return true;
+  }
+
+  // Check if server is in the allowed list
+  return mapping.allowedServers.includes(serverName);
+}
+;// ../common/src/security-utils.js
+/**
+ * Security analysis utilities for AsyncAPI template generation
+ *
+ * This module provides functions for analyzing security requirements and
+ * authentication schemes across different AsyncAPI templates.
+ */
+
+/**
+ * Analyzes operation security requirements from AsyncAPI specification
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {object} Security analysis result
+ */
+function analyzeOperationSecurity(operation) {
+  try {
+    // Check AsyncAPI security field
+    const security = operation.security && operation.security();
+    if (security && Array.isArray(security) && security.length > 0) {
+      return {
+        hasSecurityRequirements: true,
+        securitySchemes: security,
+        requiresAuthentication: true
+      };
+    }
+
+    // Check if operation has security defined in AsyncAPI spec
+    const operationJson = operation._json || operation;
+    if (operationJson.security && Array.isArray(operationJson.security) && operationJson.security.length > 0) {
+      return {
+        hasSecurityRequirements: true,
+        securitySchemes: operationJson.security,
+        requiresAuthentication: true
+      };
+    }
+    return {
+      hasSecurityRequirements: false,
+      securitySchemes: [],
+      requiresAuthentication: false
+    };
+  } catch (e) {
+    return {
+      hasSecurityRequirements: false,
+      securitySchemes: [],
+      requiresAuthentication: false
+    };
+  }
+}
+
+/**
+ * Checks if an operation has security requirements
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {boolean} True if operation has security requirements
+ */
+function operationHasSecurity(operation) {
+  const analysis = analyzeOperationSecurity(operation);
+  return analysis.hasSecurityRequirements;
+}
+
+/**
+ * Alias for operationHasSecurity for TypeScript templates
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {boolean} True if operation requires authentication
+ */
+function operationRequiresAuth(operation) {
+  return operationHasSecurity(operation);
+}
+
+/**
+ * Checks if the AsyncAPI specification has security schemes defined
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @param {boolean} enableAuth - Whether auth feature is enabled (optional, defaults to true)
+ * @returns {boolean} True if security schemes are present and auth is enabled
+ */
+function hasSecuritySchemes(asyncapi, enableAuth = true) {
+  if (!enableAuth) return false;
+  try {
+    const components = asyncapi.components();
+    if (!components) return false;
+    const securitySchemes = components.securitySchemes();
+    return securitySchemes && Object.keys(securitySchemes).length > 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Get security scheme type from AsyncAPI security scheme definition
+ *
+ * @param {object} securityScheme - AsyncAPI security scheme object
+ * @returns {string} Security scheme type ('jwt', 'basic', 'apikey', etc.)
+ */
+function getSecuritySchemeType(securityScheme) {
+  try {
+    if (securityScheme.type && typeof securityScheme.type === 'function') {
+      return securityScheme.type();
+    }
+    if (securityScheme.type) {
+      return securityScheme.type;
+    }
+    if (securityScheme._json && securityScheme._json.type) {
+      return securityScheme._json.type;
+    }
+    return 'unknown';
+  } catch (e) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Gets the security scheme name from a security scheme object
+ *
+ * @param {object} securityScheme - AsyncAPI security scheme object
+ * @returns {string} Security scheme name
+ */
+function getSecuritySchemeName(securityScheme) {
+  try {
+    if (securityScheme.name && typeof securityScheme.name === 'function') {
+      return securityScheme.name();
+    }
+    if (securityScheme.name) {
+      return securityScheme.name;
+    }
+    if (securityScheme._json && securityScheme._json.name) {
+      return securityScheme._json.name;
+    }
+    return 'unknown';
+  } catch (e) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Gets the security scheme location (header, query, cookie) for API key schemes
+ *
+ * @param {object} securityScheme - AsyncAPI security scheme object
+ * @returns {string} Security scheme location ('header', 'query', 'cookie')
+ */
+function getSecuritySchemeLocation(securityScheme) {
+  try {
+    if (securityScheme.in && typeof securityScheme.in === 'function') {
+      return securityScheme.in();
+    }
+    if (securityScheme.in) {
+      return securityScheme.in;
+    }
+    if (securityScheme._json && securityScheme._json.in) {
+      return securityScheme._json.in;
+    }
+    return 'header'; // Default to header
+  } catch (e) {
+    return 'header';
+  }
+}
+
+/**
+ * Extract security requirements for all operations in the AsyncAPI spec
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {object} Map of operation names to their security requirements
+ */
+function extractOperationSecurityMap(asyncapi) {
+  const securityMap = {};
+  try {
+    const operations = asyncapi.operations && asyncapi.operations();
+    if (operations) {
+      // Handle AsyncAPI parser collection - use .all() method to get array
+      const operationArray = operations.all ? operations.all() : Object.values(operations);
+      operationArray.forEach(operation => {
+        // Get operation ID
+        let operationId = null;
+        if (operation._meta && operation._meta.id) {
+          operationId = operation._meta.id;
+        } else if (operation.id && typeof operation.id === 'function') {
+          operationId = operation.id();
+        } else if (operation.id) {
+          operationId = operation.id;
+        }
+        if (operationId) {
+          const securityAnalysis = analyzeOperationSecurity(operation);
+          securityMap[operationId] = securityAnalysis;
+        }
+      });
+    }
+  } catch (e) {
+    console.warn('Error extracting operation security map:', e.message);
+  }
+  return securityMap;
+}
+
+/**
+ * Gets all security schemes from the AsyncAPI specification
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {object} Map of security scheme names to their definitions
+ */
+function getAllSecuritySchemes(asyncapi) {
+  try {
+    const components = asyncapi.components();
+    if (!components) return {};
+    const securitySchemes = components.securitySchemes();
+    if (!securitySchemes) return {};
+
+    // Convert to plain object if it's a collection
+    if (typeof securitySchemes === 'object' && securitySchemes.all) {
+      const schemes = {};
+      const schemeArray = securitySchemes.all();
+      schemeArray.forEach(scheme => {
+        const name = scheme.id ? scheme.id() : 'unknown';
+        schemes[name] = scheme;
+      });
+      return schemes;
+    }
+    return securitySchemes;
+  } catch (e) {
+    console.warn('Error extracting security schemes:', e.message);
+    return {};
+  }
+}
+
+/**
+ * Checks if a security scheme is of a specific type
+ *
+ * @param {object} securityScheme - AsyncAPI security scheme object
+ * @param {string} expectedType - Expected security scheme type
+ * @returns {boolean} True if the scheme matches the expected type
+ */
+function isSecuritySchemeType(securityScheme, expectedType) {
+  const actualType = getSecuritySchemeType(securityScheme);
+  return actualType.toLowerCase() === expectedType.toLowerCase();
+}
+
+/**
+ * Gets the default port for a given protocol
+ *
+ * @param {string} protocol - Protocol name
+ * @returns {number} Default port number
+ */
+function getDefaultPort(protocol) {
+  switch (protocol === null || protocol === void 0 ? void 0 : protocol.toLowerCase()) {
+    case 'http':
+      return 80;
+    case 'https':
+      return 443;
+    case 'ws':
+    case 'websocket':
+      return 80;
+    case 'wss':
+    case 'websockets':
+      return 443;
+    case 'mqtt':
+      return 1883;
+    case 'mqtts':
+      return 8883;
+    case 'amqp':
+      return 5672;
+    case 'amqps':
+      return 5671;
+    case 'kafka':
+      return 9092;
+    case 'nats':
+      return 4222;
+    default:
+      return 8080;
+  }
+}
+
+/**
+ * Validates that all server references in channels exist in the servers section
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {object} Validation result with errors if any
+ */
+function validateChannelServerReferences(asyncapi) {
+  const result = {
+    valid: true,
+    errors: []
+  };
+  try {
+    // Try multiple ways to get servers
+    let servers = null;
+    let serverNames = [];
+
+    // Method 1: Try asyncapi.servers() function
+    if (asyncapi.servers && typeof asyncapi.servers === 'function') {
+      try {
+        servers = asyncapi.servers();
+        if (servers) {
+          // Check if this is a collection object (has iterator methods)
+          if (typeof servers[Symbol.iterator] === 'function') {
+            // It's iterable - iterate through the servers
+            serverNames = [];
+            for (const server of servers) {
+              const serverName = server.id && typeof server.id === 'function' ? server.id() : server.id;
+              if (serverName) {
+                serverNames.push(serverName);
+              }
+            }
+          } else {
+            // It's a plain object - use Object.keys
+            serverNames = Object.keys(servers);
+          }
+        }
+      } catch (e) {
+        // Ignore and try other methods
+      }
+    }
+
+    // Method 2: Try asyncapi._json.servers (raw JSON data)
+    if (serverNames.length === 0 && asyncapi._json && asyncapi._json.servers) {
+      servers = asyncapi._json.servers;
+      serverNames = Object.keys(servers);
+    }
+
+    // Method 3: Try direct property access
+    if (serverNames.length === 0 && asyncapi.servers && typeof asyncapi.servers === 'object') {
+      servers = asyncapi.servers;
+      serverNames = Object.keys(servers);
+    }
+
+    // Method 4: Try json() method if available
+    if (serverNames.length === 0 && asyncapi.json && typeof asyncapi.json === 'function') {
+      try {
+        const jsonDoc = asyncapi.json();
+        if (jsonDoc && jsonDoc.servers) {
+          servers = jsonDoc.servers;
+          serverNames = Object.keys(servers);
+        }
+      } catch (e) {
+        // Ignore and try other methods
+      }
+    }
+
+    // Note: We'll skip channel validation here to avoid circular dependency
+    // This function can be enhanced later if needed
+    console.warn('Channel server validation skipped to avoid circular dependency');
+  } catch (e) {
+    result.valid = false;
+    result.errors.push({
+      message: `Error validating channel server references: ${e.message}`
+    });
+  }
+  return result;
+}
+;// ../common/src/template-utils.js
+/**
+ * Template parameter utilities for AsyncAPI template generation
+ *
+ * This module provides functions for handling template parameters and
+ * common template operations across different AsyncAPI templates.
+ */
+
+
+
+/**
+ * Checks if a parameter contains unresolved template variables
+ *
+ * @param {string} value - Parameter value to check
+ * @returns {boolean} True if the value contains template variables
+ */
+function isTemplateVariable(value) {
+  return typeof value === 'string' && value.includes('{{') && value.includes('}}');
+}
+
+/**
+ * Extracts information from AsyncAPI specification with fallbacks
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {object} Object with title, version, and description
+ */
+function extractAsyncApiInfo(asyncapi) {
+  let title, version, description;
+  try {
+    const info = asyncapi.info();
+    title = info.title();
+    version = info.version();
+    description = info.description();
+  } catch (error) {
+    title = 'UnknownAPI';
+    version = '1.0.0';
+    description = 'Generated AsyncAPI client';
+  }
+  return {
+    title,
+    version,
+    description
+  };
+}
+
+/**
+ * Resolves template parameters with fallbacks based on AsyncAPI info
+ *
+ * @param {object} params - Template parameters
+ * @param {object} asyncApiInfo - AsyncAPI info object from extractAsyncApiInfo
+ * @returns {object} Resolved parameters
+ */
+function resolveTemplateParameters(params, asyncApiInfo) {
+  const {
+    title,
+    version
+  } = asyncApiInfo;
+
+  // Resolve parameters, falling back to extracted values if parameters contain template variables
+  const clientName = params.clientName && !isTemplateVariable(params.clientName) ? params.clientName : `${toPascalCase(title)}Client`;
+  const packageName = params.packageName && !isTemplateVariable(params.packageName) ? params.packageName : `${toKebabCase(title)}-client`;
+  const packageVersion = params.packageVersion && !isTemplateVariable(params.packageVersion) ? params.packageVersion : version;
+  const license = params.license && !isTemplateVariable(params.license) ? params.license : 'Apache-2.0';
+  const author = params.author && !isTemplateVariable(params.author) ? params.author : 'AsyncAPI Generator';
+  return {
+    clientName,
+    packageName,
+    packageVersion,
+    license,
+    author
+  };
+}
+
+/**
+ * Generates package.json content for Node.js templates
+ *
+ * @param {object} resolvedParams - Resolved template parameters
+ * @param {object} asyncApiInfo - AsyncAPI info object
+ * @param {object} options - Additional options for package.json generation
+ * @returns {object} Package.json object
+ */
+function generatePackageJson(resolvedParams, asyncApiInfo, options = {}) {
+  const {
+    title,
+    description
+  } = asyncApiInfo;
+  const {
+    packageName,
+    packageVersion,
+    license,
+    author
+  } = resolvedParams;
+  const basePackage = {
+    name: packageName,
+    version: packageVersion,
+    description: `${description || title} - AsyncAPI Client`,
+    author: author,
+    license: license,
+    keywords: ['asyncapi', 'client', title.toLowerCase().replace(/[^a-z0-9]/g, '-'), ...(options.additionalKeywords || [])]
+  };
+
+  // Merge with additional options
+  return {
+    ...basePackage,
+    ...options.additionalFields
+  };
+}
+
+/**
+ * Generates README.md content for templates
+ *
+ * @param {object} resolvedParams - Resolved template parameters
+ * @param {object} asyncApiInfo - AsyncAPI info object
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @param {object} options - Additional options for README generation
+ * @returns {string} README.md content
+ */
+function generateReadmeContent(resolvedParams, asyncApiInfo, asyncapi, options = {}) {
+  const {
+    title,
+    description
+  } = asyncApiInfo;
+  const {
+    packageName,
+    packageVersion,
+    license
+  } = resolvedParams;
+  const sections = {
+    title: `# ${title}`,
+    description: description || 'Generated AsyncAPI client',
+    overview: options.overview || 'This client provides type-safe access to your AsyncAPI service.',
+    installation: options.installation || `\`\`\`bash\nnpm install ${packageName}\n\`\`\``,
+    usage: options.usage || '// Usage examples will be added here',
+    metadata: `## Generated from AsyncAPI
+
+- **AsyncAPI Version**: ${asyncapi.version()}
+- **Generated**: ${new Date().toISOString()}
+- **Title**: ${title}
+- **Version**: ${packageVersion}`,
+    license: `## License
+
+${license}`
+  };
+
+  // Allow overriding sections
+  const finalSections = {
+    ...sections,
+    ...options.sections
+  };
+  return Object.values(finalSections).join('\n\n');
+}
+
+/**
+ * Validates template parameters
+ *
+ * @param {object} params - Template parameters to validate
+ * @param {Array<string>} requiredParams - List of required parameter names
+ * @returns {object} Validation result with errors if any
+ */
+function validateTemplateParameters(params, requiredParams = []) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+
+  // Check required parameters
+  for (const paramName of requiredParams) {
+    if (!params[paramName] || isTemplateVariable(params[paramName])) {
+      result.valid = false;
+      result.errors.push(`Required parameter '${paramName}' is missing or contains unresolved template variables`);
+    }
+  }
+
+  // Check for common issues
+  if (params.packageName && !/^[a-z0-9-]+$/.test(params.packageName)) {
+    result.warnings.push('Package name should only contain lowercase letters, numbers, and hyphens');
+  }
+  if (params.packageVersion && !/^\d+\.\d+\.\d+/.test(params.packageVersion)) {
+    result.warnings.push('Package version should follow semantic versioning (e.g., 1.0.0)');
+  }
+  return result;
+}
+
+/**
+ * Generates TypeScript configuration for TypeScript templates
+ *
+ * @param {object} options - TypeScript configuration options
+ * @returns {object} TypeScript configuration object
+ */
+function generateTypeScriptConfig(options = {}) {
+  const defaultConfig = {
+    compilerOptions: {
+      target: 'ES2020',
+      module: 'ES2020',
+      lib: ['ES2020', 'DOM'],
+      outDir: './dist',
+      rootDir: './src',
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      declaration: true,
+      declarationMap: true,
+      sourceMap: true,
+      moduleResolution: 'node',
+      allowSyntheticDefaultImports: true,
+      experimentalDecorators: true,
+      emitDecoratorMetadata: true,
+      resolveJsonModule: true,
+      typeRoots: ['node_modules/@types']
+    },
+    include: ['src/**/*'],
+    exclude: ['node_modules', 'dist', '**/*.test.ts', '**/*.spec.ts']
+  };
+
+  // Merge with custom options
+  return {
+    ...defaultConfig,
+    compilerOptions: {
+      ...defaultConfig.compilerOptions,
+      ...options.compilerOptions
+    },
+    include: options.include || defaultConfig.include,
+    exclude: options.exclude || defaultConfig.exclude
+  };
+}
+
+/**
+ * Generates ESLint configuration for JavaScript/TypeScript templates
+ *
+ * @param {object} options - ESLint configuration options
+ * @returns {object} ESLint configuration object
+ */
+function generateEslintConfig(options = {}) {
+  const isTypeScript = options.typescript || false;
+  const baseConfig = {
+    env: {
+      node: true,
+      es2021: true
+    },
+    extends: ['eslint:recommended'],
+    parserOptions: {
+      ecmaVersion: 12,
+      sourceType: 'module'
+    },
+    rules: {
+      'indent': ['error', 4],
+      'linebreak-style': ['error', 'unix'],
+      'quotes': ['error', 'single'],
+      'semi': ['error', 'always']
+    }
+  };
+  if (isTypeScript) {
+    baseConfig.extends.push('@typescript-eslint/recommended');
+    baseConfig.parser = '@typescript-eslint/parser';
+    baseConfig.plugins = ['@typescript-eslint'];
+  }
+
+  // Merge with custom options
+  return {
+    ...baseConfig,
+    ...options.additionalConfig
+  };
+}
+
+/**
+ * Formats a date for use in generated files
+ *
+ * @param {Date} date - Date to format (defaults to current date)
+ * @returns {string} Formatted date string
+ */
+function formatGenerationDate(date = new Date()) {
+  return date.toISOString();
+}
+
+/**
+ * Generates a comment header for generated files
+ *
+ * @param {object} options - Header options
+ * @returns {string} Comment header
+ */
+function generateFileHeader(options = {}) {
+  const {
+    title = 'Generated AsyncAPI File',
+    description = 'This file was automatically generated from an AsyncAPI specification.',
+    generator = 'AsyncAPI Generator',
+    date = new Date(),
+    warning = 'Do not modify this file directly.'
+  } = options;
+  return `/**
+ * ${title}
+ *
+ * ${description}
+ *
+ * Generated by: ${generator}
+ * Generated on: ${formatGenerationDate(date)}
+ *
+ * WARNING: ${warning}
+ */`;
+}
+;// ../common/src/operation-utils.js
+/**
+ * Operation processing utilities for AsyncAPI template generation
+ *
+ * This module provides functions for extracting and processing operation information
+ * from AsyncAPI specifications, handling different operation types and patterns.
+ */
+
+
+
+/**
+ * Gets the operation name from an operation object
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string|null} Operation name or null if not found
+ */
+function getOperationName(operation) {
+  if (!operation) return null;
+  try {
+    // Try AsyncAPI 3.x format first - check _meta and _json properties
+    if (operation._meta && operation._meta.id) {
+      return operation._meta.id;
+    }
+    if (operation._json && operation._json['x-parser-operation-id']) {
+      return operation._json['x-parser-operation-id'];
+    }
+
+    // Try different ways to get the operation name
+    if (operation.id && typeof operation.id === 'function') {
+      return operation.id();
+    }
+    if (operation.id && typeof operation.id === 'string') {
+      return operation.id;
+    }
+    if (operation.operationId && typeof operation.operationId === 'function') {
+      return operation.operationId();
+    }
+    if (operation.operationId && typeof operation.operationId === 'string') {
+      return operation.operationId;
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Gets the operation action (send/receive/publish/subscribe)
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string} Operation action
+ */
+function getOperationAction(operation) {
+  if (!operation) return 'unknown';
+  try {
+    if (operation.action && typeof operation.action === 'function') {
+      return operation.action();
+    }
+    if (operation.action && typeof operation.action === 'string') {
+      return operation.action;
+    }
+    if (operation._json && operation._json.action) {
+      return operation._json.action;
+    }
+
+    // Fallback based on operation type
+    if (operation.isSend && typeof operation.isSend === 'function' && operation.isSend()) {
+      return 'send';
+    }
+    if (operation.isReceive && typeof operation.isReceive === 'function' && operation.isReceive()) {
+      return 'receive';
+    }
+    return 'unknown';
+  } catch (e) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Gets the channel associated with an operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {object|null} Channel object or null if not found
+ */
+function getOperationChannel(operation) {
+  if (!operation) return null;
+  try {
+    if (operation.channel && typeof operation.channel === 'function') {
+      return operation.channel();
+    }
+    if (operation.channel && typeof operation.channel === 'object') {
+      return operation.channel;
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Gets the messages associated with an operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {Array} Array of message objects
+ */
+function getOperationMessages(operation) {
+  if (!operation) return [];
+  try {
+    const messages = [];
+
+    // Try to get messages from the operation
+    if (operation.messages && typeof operation.messages === 'function') {
+      const operationMessages = operation.messages();
+      if (operationMessages && Array.isArray(operationMessages)) {
+        messages.push(...operationMessages);
+      } else if (operationMessages && typeof operationMessages === 'object') {
+        // Handle collection object
+        if (operationMessages.all && typeof operationMessages.all === 'function') {
+          messages.push(...operationMessages.all());
+        } else {
+          messages.push(...Object.values(operationMessages));
+        }
+      }
+    } else if (operation.messages && Array.isArray(operation.messages)) {
+      messages.push(...operation.messages);
+    }
+
+    // Try to get message from _json
+    if (messages.length === 0 && operation._json && operation._json.message) {
+      if (Array.isArray(operation._json.message)) {
+        messages.push(...operation._json.message);
+      } else {
+        messages.push(operation._json.message);
+      }
+    }
+    return messages;
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Checks if an operation is a send operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {boolean} True if operation is a send operation
+ */
+function isOperationSend(operation) {
+  const action = getOperationAction(operation);
+  return action === 'send' || action === 'publish';
+}
+
+/**
+ * Checks if an operation is a receive operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {boolean} True if operation is a receive operation
+ */
+function isOperationReceive(operation) {
+  const action = getOperationAction(operation);
+  return action === 'receive' || action === 'subscribe';
+}
+
+/**
+ * Gets the Rust function name for an operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string} Rust function name
+ */
+function getOperationRustFunctionName(operation) {
+  const operationName = getOperationName(operation);
+  if (!operationName) return 'unknown_operation';
+  return toRustIdentifier(operationName);
+}
+
+/**
+ * Gets the TypeScript method name for an operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string} TypeScript method name
+ */
+function getOperationTypeScriptMethodName(operation) {
+  const operationName = getOperationName(operation);
+  if (!operationName) return 'unknownOperation';
+
+  // Convert to camelCase for TypeScript
+  return operationName.split(/[-_\s]+/).map((part, index) => {
+    if (index === 0) {
+      return part.toLowerCase();
+    }
+    return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
+  }).join('');
+}
+
+/**
+ * Gets the operation description
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string} Operation description
+ */
+function getOperationDescription(operation) {
+  if (!operation) return '';
+  try {
+    if (operation.description && typeof operation.description === 'function') {
+      return operation.description() || '';
+    }
+    if (operation.description && typeof operation.description === 'string') {
+      return operation.description;
+    }
+    if (operation._json && operation._json.description) {
+      return operation._json.description;
+    }
+    return '';
+  } catch (e) {
+    return '';
+  }
+}
+
+/**
+ * Gets the operation summary
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string} Operation summary
+ */
+function getOperationSummary(operation) {
+  if (!operation) return '';
+  try {
+    if (operation.summary && typeof operation.summary === 'function') {
+      return operation.summary() || '';
+    }
+    if (operation.summary && typeof operation.summary === 'string') {
+      return operation.summary;
+    }
+    if (operation._json && operation._json.summary) {
+      return operation._json.summary;
+    }
+    return '';
+  } catch (e) {
+    return '';
+  }
+}
+
+/**
+ * Extracts all operations from an AsyncAPI specification
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {Array} Array of operation objects with metadata
+ */
+function extractAllOperations(asyncapi) {
+  const operations = [];
+  try {
+    const asyncApiOperations = asyncapi.operations && asyncapi.operations();
+    if (asyncApiOperations) {
+      // Handle AsyncAPI parser collection - use .all() method to get array
+      const operationArray = asyncApiOperations.all ? asyncApiOperations.all() : Object.values(asyncApiOperations);
+      operationArray.forEach(operation => {
+        const operationName = getOperationName(operation);
+        if (operationName) {
+          const channel = getOperationChannel(operation);
+          const messages = getOperationMessages(operation);
+          operations.push({
+            name: operationName,
+            operation: operation,
+            action: getOperationAction(operation),
+            channel: channel,
+            messages: messages,
+            description: getOperationDescription(operation),
+            summary: getOperationSummary(operation),
+            rustFunctionName: getOperationRustFunctionName(operation),
+            typeScriptMethodName: getOperationTypeScriptMethodName(operation),
+            isSend: isOperationSend(operation),
+            isReceive: isOperationReceive(operation)
+          });
+        }
+      });
+    }
+  } catch (e) {
+    console.warn('Error extracting operations:', e.message);
+  }
+  return operations;
+}
+
+/**
+ * Groups operations by their action type
+ *
+ * @param {Array} operations - Array of operation objects
+ * @returns {object} Object with send and receive operation arrays
+ */
+function groupOperationsByAction(operations) {
+  const grouped = {
+    send: [],
+    receive: [],
+    publish: [],
+    subscribe: [],
+    unknown: []
+  };
+  operations.forEach(operation => {
+    const action = operation.action || 'unknown';
+    if (grouped[action]) {
+      grouped[action].push(operation);
+    } else {
+      grouped.unknown.push(operation);
+    }
+  });
+  return grouped;
+}
+
+/**
+ * Gets the operation trait information
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {Array} Array of trait objects
+ */
+function getOperationTraits(operation) {
+  if (!operation) return [];
+  try {
+    const traits = [];
+    if (operation.traits && typeof operation.traits === 'function') {
+      const operationTraits = operation.traits();
+      if (operationTraits && Array.isArray(operationTraits)) {
+        traits.push(...operationTraits);
+      }
+    } else if (operation.traits && Array.isArray(operation.traits)) {
+      traits.push(...operation.traits);
+    }
+
+    // Try to get traits from _json
+    if (traits.length === 0 && operation._json && operation._json.traits) {
+      if (Array.isArray(operation._json.traits)) {
+        traits.push(...operation._json.traits);
+      }
+    }
+    return traits;
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Checks if an operation has any traits defined
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {boolean} True if operation has traits
+ */
+function operationHasTraits(operation) {
+  const traits = getOperationTraits(operation);
+  return traits.length > 0;
+}
+
+/**
+ * Gets the operation tags
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {Array} Array of tag objects
+ */
+function getOperationTags(operation) {
+  if (!operation) return [];
+  try {
+    const tags = [];
+    if (operation.tags && typeof operation.tags === 'function') {
+      const operationTags = operation.tags();
+      if (operationTags && Array.isArray(operationTags)) {
+        tags.push(...operationTags);
+      }
+    } else if (operation.tags && Array.isArray(operation.tags)) {
+      tags.push(...operation.tags);
+    }
+
+    // Try to get tags from _json
+    if (tags.length === 0 && operation._json && operation._json.tags) {
+      if (Array.isArray(operation._json.tags)) {
+        tags.push(...operation._json.tags);
+      }
+    }
+    return tags;
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Generates operation handler name for server templates
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @param {string} suffix - Optional suffix to add to handler name
+ * @returns {string} Handler function name
+ */
+function generateOperationHandlerName(operation, suffix = 'Handler') {
+  const operationName = getOperationName(operation);
+  if (!operationName) return `unknown${suffix}`;
+  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
+ *
+ * This package provides shared utilities for AsyncAPI template generation,
+ * reducing code duplication across multiple templates.
+ */
+
+// String utilities
+
+
+// Message utilities
+
+
+// Channel utilities
+
+
+// Security utilities
+
+
+// Template utilities
+
+
+// Operation utilities
+
+
+// Model generation utilities
+
+
+
+
+// Re-export all utilities
+
+
+// Version information
+const VERSION = '1.0.0';
+
+// Convenience function to get all utilities in one object
+function getAllUtilities() {
+  return {
+    string: {
+      toRustIdentifier: toRustIdentifier,
+      toRustTypeName: toRustTypeName,
+      toRustFieldName: toRustFieldName,
+      toRustEnumVariant: toRustEnumVariant,
+      toRustEnumVariantWithSerde: toRustEnumVariantWithSerde,
+      toKebabCase: toKebabCase,
+      toPascalCase: toPascalCase,
+      toSnakeCase: toSnakeCase,
+      toCamelCase: toCamelCase
+    },
+    message: {
+      getMessageTypeName: getMessageTypeName,
+      getMessageRustTypeName: getMessageRustTypeName,
+      getPayloadRustTypeName: getPayloadRustTypeName,
+      getMessageTypeScriptTypeName: getMessageTypeScriptTypeName,
+      getPayloadTypeScriptTypeName: getPayloadTypeScriptTypeName,
+      messageHasPayload: messageHasPayload,
+      getMessageContentType: getMessageContentType
+    },
+    channel: {
+      getNatsSubject: getNatsSubject,
+      getChannelAddress: getChannelAddress,
+      isDynamicChannel: isDynamicChannel,
+      extractChannelVariables: extractChannelVariables,
+      extractChannelParameters: extractChannelParameters,
+      getChannelParameters: getChannelParameters,
+      resolveChannelAddress: resolveChannelAddress,
+      channelHasParameters: channelHasParameters,
+      generateChannelParameterArgs: generateChannelParameterArgs,
+      generateChannelFormatting: generateChannelFormatting,
+      generateTypeScriptChannelParameterArgs: generateTypeScriptChannelParameterArgs,
+      generateTypeScriptChannelFormatting: generateTypeScriptChannelFormatting,
+      extractServerNameFromRef: extractServerNameFromRef,
+      analyzeChannelServerMappings: analyzeChannelServerMappings,
+      isChannelAllowedOnServer: isChannelAllowedOnServer
+    },
+    security: {
+      analyzeOperationSecurity: analyzeOperationSecurity,
+      operationHasSecurity: operationHasSecurity,
+      operationRequiresAuth: operationRequiresAuth,
+      hasSecuritySchemes: hasSecuritySchemes,
+      getSecuritySchemeType: getSecuritySchemeType,
+      getSecuritySchemeName: getSecuritySchemeName,
+      getSecuritySchemeLocation: getSecuritySchemeLocation,
+      extractOperationSecurityMap: extractOperationSecurityMap,
+      getAllSecuritySchemes: getAllSecuritySchemes,
+      isSecuritySchemeType: isSecuritySchemeType,
+      getDefaultPort: getDefaultPort,
+      validateChannelServerReferences: validateChannelServerReferences
+    },
+    template: {
+      isTemplateVariable: isTemplateVariable,
+      extractAsyncApiInfo: extractAsyncApiInfo,
+      resolveTemplateParameters: resolveTemplateParameters,
+      generatePackageJson: generatePackageJson,
+      generateReadmeContent: generateReadmeContent,
+      validateTemplateParameters: validateTemplateParameters,
+      generateTypeScriptConfig: generateTypeScriptConfig,
+      generateEslintConfig: generateEslintConfig,
+      formatGenerationDate: formatGenerationDate,
+      generateFileHeader: generateFileHeader
+    },
+    operation: {
+      getOperationName: getOperationName,
+      getOperationAction: getOperationAction,
+      getOperationChannel: getOperationChannel,
+      getOperationMessages: getOperationMessages,
+      isOperationSend: isOperationSend,
+      isOperationReceive: isOperationReceive,
+      getOperationRustFunctionName: getOperationRustFunctionName,
+      getOperationTypeScriptMethodName: getOperationTypeScriptMethodName,
+      getOperationDescription: getOperationDescription,
+      getOperationSummary: getOperationSummary,
+      extractAllOperations: extractAllOperations,
+      groupOperationsByAction: groupOperationsByAction,
+      getOperationTraits: getOperationTraits,
+      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, 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 };