@navios/adapter-xml 0.1.0 → 0.7.1

package/lib/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["CDataSymbol","RawXmlSymbol","AsyncComponent","CDataSymbol","ClassComponent","Fragment","RawXmlSymbol","MissingContainerError","Error","componentName","name","renderToXml","node","options","declaration","encoding","pretty","container","xml","renderNode","indent","escapeXml","String","isClassComponentNode","componentClass","instance","get","props","result","render","resolved","Promise","isAsyncNode","promise","isCDataNode","renderCData","content","isRawXmlNode","type","children","renderedChildren","all","filter","c","map","join","prefix","repeat","newline","attrs","Object","entries","_","v","k","escapeAttr","length","childIndent","resolvedChildren","childContent","hasOnlySimpleContent","every","includes","escaped","replace","str","defineTag","name","propsSchema","component","props","children","rest","parse","type","Array","isArray","tagName","getEndpointMetadata","XmlStreamAdapterToken","XmlStream","endpoint","target","context","Error","kind","config","metadata","endpointMetadata","url","method","adapterToken","classMethod","name","httpMethod","declareXmlStream","config","inject","Injectable","StreamAdapterToken","XmlStreamAdapterToken","renderToXml","token","XmlStreamAdapterService","streamAdapter","prepareArguments","handlerMetadata","provideSchema","hasSchema","provideHandler","controller","getters","config","formatArguments","request","argument","promises","getter","res","Promise","push","all","contentType","context","reply","controllerInstance","get","xmlNode","classMethod","xml","declaration","xmlDeclaration","encoding","container","isHttpStandardEnvironment","undefined","headers","key","value","Object","entries","String","Response","status","successStatusCode","header","send","XmlStreamAdapterToken","XmlStreamAdapterService","defineXmlEnvironment","httpTokens","Map"],"sources":["../src/runtime/special-nodes.mts","../src/runtime/render-to-xml.mts","../src/tags/define-tag.mts","../src/decorators/xml-stream.decorator.mts","../src/handlers/xml-stream.mts","../src/adapters/xml-stream-adapter.service.mts","../src/define-environment.mts"],"sourcesContent":["import type { CDataNode, RawXmlNode } from '../types/xml-node.mjs'\nimport { CDataSymbol, RawXmlSymbol } from '../types/xml-node.mjs'\n\n/**\n * CDATA component - wraps content in <![CDATA[...]]>\n * Use for text content that may contain characters like < > &\n * that would otherwise need escaping.\n *\n * Note: If content contains \"]]>\", it will be split into multiple CDATA sections.\n */\nexport function CData({ children }: { children: string }): CDataNode {\n  return {\n    type: CDataSymbol,\n    content: String(children),\n  }\n}\n\n/**\n * DangerouslyInsertRawXml - inserts raw XML/HTML without any escaping or wrapping\n *\n * WARNING: This bypasses all XML escaping. Only use with trusted content!\n * Use cases:\n * - Pre-rendered XML fragments\n * - HTML content in RSS/Atom feeds (in description/content:encoded)\n * - Including XML from external sources that's already valid\n */\nexport function DangerouslyInsertRawXml({ children }: { children: string }): RawXmlNode {\n  return {\n    type: RawXmlSymbol,\n    content: String(children),\n  }\n}\n","import type { Container, ScopedContainer } from '@navios/core'\n\nimport type { XmlComponent } from '../types/component.mjs'\nimport type {\n  AnyXmlNode,\n  AsyncXmlNode,\n  CDataNode,\n  ClassComponentNode,\n  RawXmlNode,\n} from '../types/xml-node.mjs'\n\nimport {\n  AsyncComponent,\n  CDataSymbol,\n  ClassComponent,\n  Fragment,\n  RawXmlSymbol,\n} from '../types/xml-node.mjs'\n\n/**\n * Options for rendering XML from JSX nodes.\n *\n * @example\n * ```ts\n * const xml = await renderToXml(<rss version=\"2.0\">...</rss>, {\n *   declaration: true,\n *   encoding: 'UTF-8',\n *   pretty: true,\n *   container: myContainer, // Required for class components\n * })\n * ```\n */\nexport interface RenderOptions {\n  /** Include XML declaration (<?xml version=\"1.0\"?>) - defaults to true */\n  declaration?: boolean\n  /** XML encoding, defaults to 'UTF-8' */\n  encoding?: string\n  /** Pretty print with indentation */\n  pretty?: boolean\n  /**\n   * DI container for resolving class components.\n   * Required if the tree contains any class components.\n   */\n  container?: Container | ScopedContainer\n}\n\n/**\n * Error thrown when attempting to render a class component without a container.\n *\n * Class components require a dependency injection container to be instantiated.\n * This error is thrown when `renderToXml` is called with a class component in\n * the tree but no container is provided in the options.\n *\n * @example\n * ```ts\n * try {\n *   await renderToXml(<MyClassComponent />)\n * } catch (error) {\n *   if (error instanceof MissingContainerError) {\n *     // Provide a container\n *     await renderToXml(<MyClassComponent />, { container })\n *   }\n * }\n * ```\n */\nexport class MissingContainerError extends Error {\n  constructor(componentName: string) {\n    super(\n      `[@navios/adapter-xml] Cannot render class component \"${componentName}\" without a container. ` +\n        `Pass a container to renderToXml options: renderToXml(node, { container })`,\n    )\n    this.name = 'MissingContainerError'\n  }\n}\n\n/**\n * Renders a JSX XML node tree to an XML string.\n *\n * This function handles:\n * - Regular XML nodes (tags with props and children)\n * - Async components (resolves promises in parallel)\n * - Class components (resolves via DI container)\n * - CDATA sections\n * - Raw XML content\n * - Fragments\n * - Text content with proper escaping\n *\n * @param node - The root XML node (JSX element) to render.\n * @param options - Rendering options including declaration, encoding, pretty printing, and container.\n * @returns A promise that resolves to the XML string.\n *\n * @throws {MissingContainerError} If the tree contains class components but no container is provided.\n *\n * @example\n * ```ts\n * // Simple rendering\n * const xml = await renderToXml(<rss version=\"2.0\"><channel>...</channel></rss>)\n *\n * // With options\n * const xml = await renderToXml(<feed>...</feed>, {\n *   declaration: true,\n *   encoding: 'UTF-8',\n *   pretty: true,\n * })\n *\n * // With class components (requires container)\n * const container = new Container()\n * container.beginRequest('request-id')\n * const xml = await renderToXml(<MyClassComponent />, { container })\n * ```\n */\nexport async function renderToXml(\n  node: AnyXmlNode,\n  options: RenderOptions = {},\n): Promise<string> {\n  const {\n    declaration = true,\n    encoding = 'UTF-8',\n    pretty = false,\n    container,\n  } = options\n\n  let xml = ''\n  if (declaration) {\n    xml += `<?xml version=\"1.0\" encoding=\"${encoding}\"?>`\n    if (pretty) xml += '\\n'\n  }\n\n  xml += await renderNode(node, pretty ? 0 : -1, container)\n  return xml\n}\n\nasync function renderNode(\n  node: AnyXmlNode,\n  indent: number,\n  container: Container | ScopedContainer | undefined,\n): Promise<string> {\n  if (node == null) return ''\n  if (typeof node === 'string') return escapeXml(node)\n  if (typeof node === 'number') return String(node)\n\n  // Handle class components - resolve via DI container\n  if (isClassComponentNode(node)) {\n    if (!container) {\n      throw new MissingContainerError(node.componentClass.name)\n    }\n\n    // Resolve the component instance from the container, passing props as schema args\n    // This validates props via Zod schema if defined on the component\n    const instance = (await container.get(\n      node.componentClass as any,\n      node.props,\n    )) as XmlComponent\n\n    // Call render() - no arguments, props are already in the instance\n    const result = instance.render()\n\n    // Handle async render methods\n    const resolved = result instanceof Promise ? await result : result\n\n    // Recursively render the result\n    return renderNode(resolved, indent, container)\n  }\n\n  // Handle async components - resolve the promise first\n  if (isAsyncNode(node)) {\n    const resolved = await node.promise\n    return renderNode(resolved, indent, container)\n  }\n\n  // Handle CDATA nodes\n  if (isCDataNode(node)) {\n    return renderCData(node.content)\n  }\n\n  // Handle Raw XML nodes - no escaping\n  if (isRawXmlNode(node)) {\n    return node.content\n  }\n\n  const { type, props, children } = node\n\n  if (type === Fragment) {\n    const renderedChildren = await Promise.all(\n      children\n        .filter((c) => c != null)\n        .map((c) => renderNode(c, indent, container)),\n    )\n    return renderedChildren.join('')\n  }\n\n  const prefix = indent >= 0 ? '  '.repeat(indent) : ''\n  const newline = indent >= 0 ? '\\n' : ''\n\n  const attrs = Object.entries(props)\n    .filter(([_, v]) => v != null)\n    .map(([k, v]) => ` ${k}=\"${escapeAttr(String(v))}\"`)\n    .join('')\n\n  if (children.length === 0) {\n    return `${prefix}<${type}${attrs}/>${newline}`\n  }\n\n  const childIndent = indent >= 0 ? indent + 1 : -1\n\n  // Resolve all children (including async and class components) in parallel\n  const resolvedChildren = await Promise.all(\n    children\n      .filter((c) => c != null)\n      .map((c) => renderNode(c, childIndent, container)),\n  )\n  const childContent = resolvedChildren.join('')\n\n  // Check if children are simple (text, numbers, CDATA, or raw XML)\n  const hasOnlySimpleContent = children.every(\n    (c) =>\n      typeof c === 'string' ||\n      typeof c === 'number' ||\n      isCDataNode(c) ||\n      isRawXmlNode(c),\n  )\n  if (hasOnlySimpleContent) {\n    return `${prefix}<${type}${attrs}>${childContent}</${type}>${newline}`\n  }\n\n  return `${prefix}<${type}${attrs}>${newline}${childContent}${prefix}</${type}>${newline}`\n}\n\nfunction isClassComponentNode(node: unknown): node is ClassComponentNode {\n  return (\n    node !== null &&\n    typeof node === 'object' &&\n    'type' in node &&\n    node.type === ClassComponent\n  )\n}\n\nfunction isAsyncNode(node: unknown): node is AsyncXmlNode {\n  return (\n    node !== null &&\n    typeof node === 'object' &&\n    'type' in node &&\n    node.type === AsyncComponent\n  )\n}\n\nfunction isCDataNode(node: any): node is CDataNode {\n  return node && typeof node === 'object' && node.type === CDataSymbol\n}\n\nfunction isRawXmlNode(node: any): node is RawXmlNode {\n  return node && typeof node === 'object' && node.type === RawXmlSymbol\n}\n\n/**\n * Renders content as CDATA section.\n * If content contains \"]]>\", splits into multiple CDATA sections.\n * The technique is to end the CDATA section before ]]>, then start a new one.\n */\nfunction renderCData(content: string): string {\n  // Handle the edge case where content contains \"]]>\"\n  // We split on \"]]>\" and join with \"]]]]><![CDATA[>\" which effectively\n  // ends the CDATA section after \"]]\" and starts a new one for \">\"\n  if (content.includes(']]>')) {\n    // Replace ]]> with ]]]]><![CDATA[> which closes CDATA before > and reopens it\n    const escaped = content.replace(/]]>/g, ']]]]><![CDATA[>')\n    return `<![CDATA[${escaped}]]>`\n  }\n  return `<![CDATA[${content}]]>`\n}\n\nfunction escapeXml(str: string): string {\n  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')\n}\n\nfunction escapeAttr(str: string): string {\n  return str\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\"/g, '&quot;')\n}\n","import type { ZodObject, ZodRawShape } from 'zod/v4'\nimport type { z } from 'zod/v4'\n\nimport type { AnyXmlNode, XmlNode } from '../types/xml-node.mjs'\n\n/**\n * Type for XML tag components created by `defineTag`.\n *\n * Tag components are functions that accept props and children, and return\n * an XML node. They also have a `tagName` property for identification.\n *\n * @template Props - The props type for the tag component.\n */\nexport interface TagComponent<Props extends Record<string, unknown>> {\n  (props: Props & { children?: AnyXmlNode | AnyXmlNode[] }): XmlNode\n  tagName: string\n}\n\n/**\n * Creates a type-safe XML tag component with optional Zod schema validation.\n *\n * @param name - The tag name (supports namespace prefixes like 'atom:link')\n * @param propsSchema - Optional Zod schema for validating props\n * @returns A component function that can be used in JSX\n *\n * @example\n * ```tsx\n * // Simple tag\n * const item = defineTag('item')\n * <item>Content</item>\n *\n * // Namespaced tag with Zod validation\n * const atomLink = defineTag('atom:link', z.object({\n *   href: z.string().url(),\n *   rel: z.enum(['self', 'alternate']),\n *   type: z.string().optional(),\n * }))\n * <atomLink href=\"https://example.com/feed\" rel=\"self\" />\n * ```\n */\nexport function defineTag<T extends ZodRawShape>(\n  name: string,\n  propsSchema?: ZodObject<T>,\n): TagComponent<T extends ZodRawShape ? z.infer<ZodObject<T>> : Record<string, never>> {\n  const component = (props: any): XmlNode => {\n    const { children, ...rest } = props ?? {}\n\n    // Validate props if schema provided\n    if (propsSchema) {\n      propsSchema.parse(rest)\n    }\n\n    return {\n      type: name,\n      props: rest,\n      children: Array.isArray(children) ? children : children ? [children] : [],\n    }\n  }\n\n  component.tagName = name\n  return component as any\n}\n","import type { EndpointFunctionArgs, HttpMethod, Util_FlatObject } from '@navios/builder'\nimport type { ZodObject, ZodType } from 'zod/v4'\n\nimport { getEndpointMetadata, XmlStreamAdapterToken } from '@navios/core'\n\nimport type { BaseXmlStreamConfig } from '../types/config.mjs'\n\n/**\n * Type helper that extracts the parameter types for an XML Stream endpoint handler.\n *\n * This type automatically infers the correct parameter types based on the endpoint\n * configuration, including URL parameters, query parameters, and request body.\n *\n * @template EndpointDeclaration - The endpoint declaration type from `declareXmlStream`.\n * @template Url - The URL path pattern.\n * @template QuerySchema - The query parameter schema type.\n *\n * @example\n * ```typescript\n * const getFeed = declareXmlStream({\n *   method: 'GET',\n *   url: '/feed/:category',\n *   querySchema: z.object({ page: z.string() }),\n * })\n *\n * // XmlStreamParams<typeof getFeed> resolves to:\n * // { urlParams: { category: string }, query: { page: string } }\n * ```\n */\nexport type XmlStreamParams<\n  EndpointDeclaration extends {\n    config: BaseXmlStreamConfig<any, any, any, any>\n  },\n  Url extends string = EndpointDeclaration['config']['url'],\n  QuerySchema = EndpointDeclaration['config']['querySchema'],\n> = QuerySchema extends ZodObject\n  ? EndpointDeclaration['config']['requestSchema'] extends ZodType\n    ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema'], true>>\n    : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>>\n  : EndpointDeclaration['config']['requestSchema'] extends ZodType\n    ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema'], true>>\n    : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>\n\n/**\n * Decorator for XML Stream endpoints that return JSX-based XML responses.\n *\n * This decorator marks controller methods that return JSX elements, which will be\n * automatically rendered to XML and sent with the appropriate Content-Type header.\n * The method can be async and can contain async components, class components, and\n * regular JSX elements.\n *\n * @template Method - The HTTP method (GET, POST, etc.).\n * @template Url - The URL path pattern (supports parameters like `/posts/:id`).\n * @template QuerySchema - Optional Zod schema for query parameter validation.\n * @template RequestSchema - Optional Zod schema for request body validation.\n *\n * @param endpoint - The endpoint declaration created with `declareXmlStream`.\n * @returns A method decorator function.\n *\n * @throws {Error} If used on a non-function or non-method.\n * @throws {Error} If the endpoint URL already exists.\n *\n * @example\n * ```typescript\n * import { XmlStream, declareXmlStream } from '@navios/adapter-xml'\n * import { Controller } from '@navios/core'\n *\n * const getRssFeed = declareXmlStream({\n *   method: 'GET',\n *   url: '/feed.xml',\n *   contentType: 'application/rss+xml',\n * })\n *\n * @Controller('/api')\n * class FeedController {\n *   @XmlStream(getRssFeed)\n *   async getFeed() {\n *     return (\n *       <rss version=\"2.0\">\n *         <channel>\n *           <title>My Feed</title>\n *         </channel>\n *       </rss>\n *     )\n *   }\n * }\n * ```\n *\n * @example\n * ```typescript\n * // With query parameters\n * const getSitemap = declareXmlStream({\n *   method: 'GET',\n *   url: '/sitemap.xml',\n *   querySchema: z.object({ page: z.string().optional() }),\n * })\n *\n * @Controller()\n * class SitemapController {\n *   @XmlStream(getSitemap)\n *   async getSitemap(params: { query?: { page?: string } }) {\n *     const page = params.query?.page\n *     return <urlset>...</urlset>\n *   }\n * }\n * ```\n */\nexport function XmlStream<\n  Method extends HttpMethod = HttpMethod,\n  Url extends string = string,\n  QuerySchema = undefined,\n  RequestSchema = ZodType,\n>(endpoint: { config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema> }) {\n  return (\n    target: (\n      params: QuerySchema extends ZodObject\n        ? RequestSchema extends ZodType\n          ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>>\n          : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>>\n        : RequestSchema extends ZodType\n          ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, RequestSchema, true>>\n          : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>,\n    ) => Promise<any>, // Returns XmlNode\n    context: ClassMethodDecoratorContext,\n  ) => {\n    if (typeof target !== 'function') {\n      throw new Error('[Navios] XmlStream decorator can only be used on functions.')\n    }\n    if (context.kind !== 'method') {\n      throw new Error('[Navios] XmlStream decorator can only be used on methods.')\n    }\n\n    const config = endpoint.config\n    if (context.metadata) {\n      const endpointMetadata = getEndpointMetadata<BaseXmlStreamConfig>(target, context)\n      if (endpointMetadata.config && endpointMetadata.config.url) {\n        throw new Error(`[Navios] Endpoint ${config.method} ${config.url} already exists.`)\n      }\n      // @ts-expect-error We don't need to set correctly in the metadata\n      endpointMetadata.config = config\n      endpointMetadata.adapterToken = XmlStreamAdapterToken\n      endpointMetadata.classMethod = target.name\n      endpointMetadata.httpMethod = config.method\n      endpointMetadata.url = config.url\n    }\n    return target\n  }\n}\n","import type { HttpMethod } from '@navios/builder'\n\nimport type { BaseXmlStreamConfig } from '../types/config.mjs'\n\n/**\n * Declares an XML Stream endpoint configuration for use with `@XmlStream` decorator.\n *\n * This function creates an endpoint declaration that can be used with the `@XmlStream`\n * decorator to mark controller methods that return JSX-based XML responses.\n *\n * @template Method - The HTTP method (GET, POST, etc.).\n * @template Url - The URL path pattern (supports parameters like `/posts/:id`).\n * @template QuerySchema - Optional Zod schema for query parameter validation.\n * @template RequestSchema - Optional Zod schema for request body validation.\n *\n * @param config - The endpoint configuration including method, URL, schemas, and XML options.\n * @returns An endpoint declaration object to be used with `@XmlStream` decorator.\n *\n * @example\n * ```typescript\n * import { declareXmlStream } from '@navios/adapter-xml'\n * import { z } from 'zod/v4'\n *\n * // Simple endpoint\n * export const getRssFeed = declareXmlStream({\n *   method: 'GET',\n *   url: '/feed.xml',\n *   contentType: 'application/rss+xml',\n * })\n *\n * // With query parameters\n * export const getSitemap = declareXmlStream({\n *   method: 'GET',\n *   url: '/sitemap.xml',\n *   querySchema: z.object({\n *     page: z.string().optional(),\n *   }),\n *   contentType: 'application/xml',\n *   xmlDeclaration: true,\n *   encoding: 'UTF-8',\n * })\n * ```\n */\nexport function declareXmlStream<\n  Method extends HttpMethod,\n  Url extends string,\n  QuerySchema = undefined,\n  RequestSchema = undefined,\n>(\n  config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>,\n): { config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema> } {\n  return { config }\n}\n","import type {\n  AbstractHttpHandlerAdapterInterface,\n  ClassType,\n  HandlerMetadata,\n  ScopedContainer,\n} from '@navios/core'\n\nimport {\n  inject,\n  Injectable,\n  StreamAdapterToken,\n  XmlStreamAdapterToken,\n} from '@navios/core'\n\nimport type { BaseXmlStreamConfig } from '../types/config.mjs'\nimport type { AnyXmlNode } from '../types/xml-node.mjs'\n\nimport { renderToXml } from '../runtime/render-to-xml.mjs'\n\n/**\n * Adapter service for handling XML Stream endpoints in Navios.\n *\n * This service integrates with the base stream adapter (Fastify or Bun) to handle\n * XML endpoints that return JSX-based XML responses. It automatically renders JSX\n * nodes to XML strings and sends them with the appropriate Content-Type headers.\n *\n * The service supports:\n * - Async components (resolved in parallel)\n * - Class components (resolved via DI container)\n * - Regular JSX elements\n * - CDATA sections\n * - Raw XML content\n *\n * @implements {AbstractHttpHandlerAdapterInterface}\n *\n * @example\n * ```ts\n * // This service is automatically registered when using defineXmlEnvironment()\n * // and is used by endpoints decorated with @XmlStream()\n * ```\n */\n@Injectable({\n  token: XmlStreamAdapterToken,\n})\nexport class XmlStreamAdapterService implements AbstractHttpHandlerAdapterInterface {\n  /** Base stream adapter - we proxy hasSchema, prepareArguments, provideSchema to it */\n  protected streamAdapter = inject(StreamAdapterToken)\n\n  /**\n   * Prepares argument getters for parsing request data.\n   *\n   * Proxies to the base stream adapter to reuse existing argument preparation logic\n   * that handles query parameters, request body, and URL parameters for both\n   * Fastify and Bun adapters.\n   *\n   * @param handlerMetadata - The handler metadata with schemas and configuration.\n   * @returns An array of getter functions that populate request arguments.\n   */\n  prepareArguments(handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>) {\n    return this.streamAdapter.prepareArguments?.(handlerMetadata) ?? []\n  }\n\n  /**\n   * Provides schema information for the handler.\n   *\n   * Proxies to the base stream adapter to reuse existing schema generation logic.\n   * For Fastify, this enables built-in validation. For Bun, this returns an empty object.\n   *\n   * @param handlerMetadata - The handler metadata containing configuration and schemas.\n   * @returns Schema information (Fastify route schema or empty object for Bun).\n   */\n  provideSchema(\n    handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>,\n  ): Record<string, any> {\n    if (\n      'provideSchema' in this.streamAdapter &&\n      typeof this.streamAdapter.provideSchema === 'function'\n    ) {\n      return this.streamAdapter.provideSchema(handlerMetadata)\n    }\n    return {}\n  }\n\n  /**\n   * Checks if the handler has any validation schemas defined.\n   *\n   * Proxies to the base stream adapter to check for query or request schemas.\n   *\n   * @param handlerMetadata - The handler metadata containing configuration.\n   * @returns `true` if the handler has any schemas (query or request).\n   */\n  hasSchema(handlerMetadata: HandlerMetadata<any>): boolean {\n    if (\n      'hasSchema' in this.streamAdapter &&\n      typeof this.streamAdapter.hasSchema === 'function'\n    ) {\n      return this.streamAdapter.hasSchema(handlerMetadata)\n    }\n    return false\n  }\n\n  /**\n   * Creates a request handler function for XML Stream endpoints.\n   *\n   * This method generates a handler that:\n   * 1. Parses and validates request data (body, query, URL params) using the base adapter\n   * 2. Invokes the controller method with validated arguments (returns JSX)\n   * 3. Renders the JSX tree to XML string (resolves async and class components)\n   * 4. Sends the XML response with appropriate Content-Type header\n   *\n   * The handler automatically detects the environment (Fastify vs Bun) and uses the\n   * appropriate response mechanism (reply object vs Response object).\n   *\n   * @param controller - The controller class containing the handler method.\n   * @param handlerMetadata - The handler metadata with configuration and schemas.\n   * @returns A function that handles incoming requests and sends XML responses.\n   */\n  provideHandler(\n    controller: ClassType,\n    handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>,\n  ): (context: ScopedContainer, request: any, reply: any) => Promise<any> {\n    const getters = this.prepareArguments(handlerMetadata)\n    const config = handlerMetadata.config\n\n    const formatArguments = async (request: any) => {\n      const argument: Record<string, any> = {}\n      const promises: Promise<void>[] = []\n      for (const getter of getters) {\n        const res = getter(argument, request)\n        if (res instanceof Promise) {\n          promises.push(res)\n        }\n      }\n      await Promise.all(promises)\n      return argument\n    }\n\n    const contentType = config.contentType ?? 'application/xml'\n\n    return async (context: ScopedContainer, request: any, reply: any) => {\n      const controllerInstance = await context.get(controller)\n      const argument = await formatArguments(request)\n\n      // Call controller method - returns XmlNode (JSX), may contain async/class components\n      const xmlNode: AnyXmlNode =\n        await controllerInstance[handlerMetadata.classMethod](argument)\n\n      // Render JSX to XML string (async - resolves all async and class components)\n      const xml = await renderToXml(xmlNode, {\n        declaration: config.xmlDeclaration ?? true,\n        encoding: config.encoding ?? 'UTF-8',\n        container: context,\n      })\n\n      // Environment detection: Bun doesn't have reply\n      const isHttpStandardEnvironment = reply === undefined\n\n      if (isHttpStandardEnvironment) {\n        // Bun: return Response object\n        const headers: Record<string, string> = {\n          'Content-Type': contentType,\n        }\n        for (const [key, value] of Object.entries(handlerMetadata.headers)) {\n          if (value != null) {\n            headers[key] = String(value)\n          }\n        }\n        return new Response(xml, {\n          status: handlerMetadata.successStatusCode,\n          headers,\n        })\n      } else {\n        // Fastify: use reply object\n        reply\n          .status(handlerMetadata.successStatusCode)\n          .header('Content-Type', contentType)\n          .headers(handlerMetadata.headers)\n          .send(xml)\n      }\n    }\n  }\n}\n","import type { AnyInjectableType } from '@navios/core'\n\nimport { InjectionToken, XmlStreamAdapterToken } from '@navios/core'\n\nimport { XmlStreamAdapterService } from './adapters/index.mjs'\n\n/**\n * Creates the XML environment configuration to be merged with base adapter (Fastify/Bun).\n *\n * @example\n * ```typescript\n * import { defineFastifyEnvironment } from '@navios/adapter-fastify'\n * import { defineXmlEnvironment } from '@navios/adapter-xml'\n * import { NaviosFactory } from '@navios/core'\n *\n * const fastifyEnv = defineFastifyEnvironment()\n * const xmlEnv = defineXmlEnvironment()\n *\n * // Merge environments\n * const mergedEnv = {\n *   httpTokens: new Map([\n *     ...fastifyEnv.httpTokens,\n *     ...xmlEnv.httpTokens,\n *   ]),\n * }\n *\n * const app = await NaviosFactory.create(AppModule, {\n *   adapter: mergedEnv,\n * })\n * ```\n */\nexport function defineXmlEnvironment() {\n  const httpTokens = new Map<InjectionToken<any, undefined>, AnyInjectableType>(\n    [[XmlStreamAdapterToken, XmlStreamAdapterService]],\n  )\n  return {\n    httpTokens,\n  }\n}\n"],"mappings":"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"}

package/lib/index.d.cts

@@ -0,0 +1,520 @@
+import { a as CDataSymbol, c as Fragment, d as XmlNode, f as ComponentClass, i as CDataNode, l as RawXmlNode, n as AsyncComponent, o as ClassComponent, p as XmlComponent, r as AsyncXmlNode, s as ClassComponentNode, t as AnyXmlNode, u as RawXmlSymbol } from "./xml-node-CddziLym.cjs";
+import { t as createElement } from "./create-element--Gd2L8UR.cjs";
+import { BaseStreamConfig, EndpointFunctionArgs, HttpMethod, Util_FlatObject } from "@navios/builder";
+import { AbstractHttpHandlerAdapterInterface, AnyInjectableType, ClassType, Container, HandlerMetadata, InjectionToken, Registry, ScopedContainer } from "@navios/core";
+import { ZodObject, ZodRawShape, ZodType, z } from "zod/v4";
+
+//#region src/types/config.d.mts
+
+/**
+ * Configuration interface for XML Stream endpoints.
+ *
+ * Extends the base stream configuration with XML-specific options including
+ * content type, XML declaration, and encoding settings.
+ *
+ * @template Method - The HTTP method (GET, POST, etc.).
+ * @template Url - The URL path pattern (supports parameters like `/posts/:id`).
+ * @template QuerySchema - Optional Zod schema for query parameter validation.
+ * @template RequestSchema - Optional Zod schema for request body validation.
+ *
+ * @example
+ * ```typescript
+ * const config: BaseXmlStreamConfig = {
+ *   method: 'GET',
+ *   url: '/feed.xml',
+ *   contentType: 'application/rss+xml',
+ *   xmlDeclaration: true,
+ *   encoding: 'UTF-8',
+ * }
+ * ```
+ */
+interface BaseXmlStreamConfig<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, RequestSchema = undefined> extends BaseStreamConfig<Method, Url, QuerySchema, RequestSchema> {
+  /** Content-Type header, defaults to 'application/xml' */
+  contentType?: 'application/xml' | 'text/xml' | 'application/rss+xml' | 'application/atom+xml';
+  /** Include XML declaration (<?xml version="1.0"?>) - defaults to true */
+  xmlDeclaration?: boolean;
+  /** XML encoding, defaults to 'UTF-8' */
+  encoding?: string;
+}
+//#endregion
+//#region src/runtime/special-nodes.d.mts
+/**
+ * CDATA component - wraps content in <![CDATA[...]]>
+ * Use for text content that may contain characters like < > &
+ * that would otherwise need escaping.
+ *
+ * Note: If content contains "]]>", it will be split into multiple CDATA sections.
+ */
+declare function CData({
+  children
+}: {
+  children: string;
+}): CDataNode;
+/**
+ * DangerouslyInsertRawXml - inserts raw XML/HTML without any escaping or wrapping
+ *
+ * WARNING: This bypasses all XML escaping. Only use with trusted content!
+ * Use cases:
+ * - Pre-rendered XML fragments
+ * - HTML content in RSS/Atom feeds (in description/content:encoded)
+ * - Including XML from external sources that's already valid
+ */
+declare function DangerouslyInsertRawXml({
+  children
+}: {
+  children: string;
+}): RawXmlNode;
+//#endregion
+//#region src/runtime/render-to-xml.d.mts
+/**
+ * Options for rendering XML from JSX nodes.
+ *
+ * @example
+ * ```ts
+ * const xml = await renderToXml(<rss version="2.0">...</rss>, {
+ *   declaration: true,
+ *   encoding: 'UTF-8',
+ *   pretty: true,
+ *   container: myContainer, // Required for class components
+ * })
+ * ```
+ */
+interface RenderOptions {
+  /** Include XML declaration (<?xml version="1.0"?>) - defaults to true */
+  declaration?: boolean;
+  /** XML encoding, defaults to 'UTF-8' */
+  encoding?: string;
+  /** Pretty print with indentation */
+  pretty?: boolean;
+  /**
+   * DI container for resolving class components.
+   * Required if the tree contains any class components.
+   */
+  container?: Container | ScopedContainer;
+}
+/**
+ * Error thrown when attempting to render a class component without a container.
+ *
+ * Class components require a dependency injection container to be instantiated.
+ * This error is thrown when `renderToXml` is called with a class component in
+ * the tree but no container is provided in the options.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await renderToXml(<MyClassComponent />)
+ * } catch (error) {
+ *   if (error instanceof MissingContainerError) {
+ *     // Provide a container
+ *     await renderToXml(<MyClassComponent />, { container })
+ *   }
+ * }
+ * ```
+ */
+declare class MissingContainerError extends Error {
+  constructor(componentName: string);
+}
+/**
+ * Renders a JSX XML node tree to an XML string.
+ *
+ * This function handles:
+ * - Regular XML nodes (tags with props and children)
+ * - Async components (resolves promises in parallel)
+ * - Class components (resolves via DI container)
+ * - CDATA sections
+ * - Raw XML content
+ * - Fragments
+ * - Text content with proper escaping
+ *
+ * @param node - The root XML node (JSX element) to render.
+ * @param options - Rendering options including declaration, encoding, pretty printing, and container.
+ * @returns A promise that resolves to the XML string.
+ *
+ * @throws {MissingContainerError} If the tree contains class components but no container is provided.
+ *
+ * @example
+ * ```ts
+ * // Simple rendering
+ * const xml = await renderToXml(<rss version="2.0"><channel>...</channel></rss>)
+ *
+ * // With options
+ * const xml = await renderToXml(<feed>...</feed>, {
+ *   declaration: true,
+ *   encoding: 'UTF-8',
+ *   pretty: true,
+ * })
+ *
+ * // With class components (requires container)
+ * const container = new Container()
+ * container.beginRequest('request-id')
+ * const xml = await renderToXml(<MyClassComponent />, { container })
+ * ```
+ */
+declare function renderToXml(node: AnyXmlNode, options?: RenderOptions): Promise<string>;
+//#endregion
+//#region src/tags/define-tag.d.mts
+/**
+ * Type for XML tag components created by `defineTag`.
+ *
+ * Tag components are functions that accept props and children, and return
+ * an XML node. They also have a `tagName` property for identification.
+ *
+ * @template Props - The props type for the tag component.
+ */
+interface TagComponent<Props extends Record<string, unknown>> {
+  (props: Props & {
+    children?: AnyXmlNode | AnyXmlNode[];
+  }): XmlNode;
+  tagName: string;
+}
+/**
+ * Creates a type-safe XML tag component with optional Zod schema validation.
+ *
+ * @param name - The tag name (supports namespace prefixes like 'atom:link')
+ * @param propsSchema - Optional Zod schema for validating props
+ * @returns A component function that can be used in JSX
+ *
+ * @example
+ * ```tsx
+ * // Simple tag
+ * const item = defineTag('item')
+ * <item>Content</item>
+ *
+ * // Namespaced tag with Zod validation
+ * const atomLink = defineTag('atom:link', z.object({
+ *   href: z.string().url(),
+ *   rel: z.enum(['self', 'alternate']),
+ *   type: z.string().optional(),
+ * }))
+ * <atomLink href="https://example.com/feed" rel="self" />
+ * ```
+ */
+declare function defineTag<T extends ZodRawShape>(name: string, propsSchema?: ZodObject<T>): TagComponent<T extends ZodRawShape ? z.infer<ZodObject<T>> : Record<string, never>>;
+//#endregion
+//#region src/decorators/xml-stream.decorator.d.mts
+/**
+ * Type helper that extracts the parameter types for an XML Stream endpoint handler.
+ *
+ * This type automatically infers the correct parameter types based on the endpoint
+ * configuration, including URL parameters, query parameters, and request body.
+ *
+ * @template EndpointDeclaration - The endpoint declaration type from `declareXmlStream`.
+ * @template Url - The URL path pattern.
+ * @template QuerySchema - The query parameter schema type.
+ *
+ * @example
+ * ```typescript
+ * const getFeed = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/feed/:category',
+ *   querySchema: z.object({ page: z.string() }),
+ * })
+ *
+ * // XmlStreamParams<typeof getFeed> resolves to:
+ * // { urlParams: { category: string }, query: { page: string } }
+ * ```
+ */
+type XmlStreamParams<EndpointDeclaration extends {
+  config: BaseXmlStreamConfig<any, any, any, any>;
+}, Url extends string = EndpointDeclaration['config']['url'], QuerySchema = EndpointDeclaration['config']['querySchema']> = QuerySchema extends ZodObject ? EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>;
+/**
+ * Decorator for XML Stream endpoints that return JSX-based XML responses.
+ *
+ * This decorator marks controller methods that return JSX elements, which will be
+ * automatically rendered to XML and sent with the appropriate Content-Type header.
+ * The method can be async and can contain async components, class components, and
+ * regular JSX elements.
+ *
+ * @template Method - The HTTP method (GET, POST, etc.).
+ * @template Url - The URL path pattern (supports parameters like `/posts/:id`).
+ * @template QuerySchema - Optional Zod schema for query parameter validation.
+ * @template RequestSchema - Optional Zod schema for request body validation.
+ *
+ * @param endpoint - The endpoint declaration created with `declareXmlStream`.
+ * @returns A method decorator function.
+ *
+ * @throws {Error} If used on a non-function or non-method.
+ * @throws {Error} If the endpoint URL already exists.
+ *
+ * @example
+ * ```typescript
+ * import { XmlStream, declareXmlStream } from '@navios/adapter-xml'
+ * import { Controller } from '@navios/core'
+ *
+ * const getRssFeed = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/feed.xml',
+ *   contentType: 'application/rss+xml',
+ * })
+ *
+ * @Controller('/api')
+ * class FeedController {
+ *   @XmlStream(getRssFeed)
+ *   async getFeed() {
+ *     return (
+ *       <rss version="2.0">
+ *         <channel>
+ *           <title>My Feed</title>
+ *         </channel>
+ *       </rss>
+ *     )
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With query parameters
+ * const getSitemap = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/sitemap.xml',
+ *   querySchema: z.object({ page: z.string().optional() }),
+ * })
+ *
+ * @Controller()
+ * class SitemapController {
+ *   @XmlStream(getSitemap)
+ *   async getSitemap(params: { query?: { page?: string } }) {
+ *     const page = params.query?.page
+ *     return <urlset>...</urlset>
+ *   }
+ * }
+ * ```
+ */
+declare function XmlStream<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, RequestSchema = ZodType>(endpoint: {
+  config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>;
+}): (target: (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>) => Promise<any>,
+// Returns XmlNode
+context: ClassMethodDecoratorContext) => (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>) => Promise<any>;
+//#endregion
+//#region src/decorators/component.decorator.d.mts
+/**
+ * Decorator for class-based XML components with dependency injection support.
+ *
+ * Class components must implement the `XmlComponent` interface with a `render()` method.
+ * They can optionally accept props via constructor, validated with a Zod schema.
+ *
+ * @overload
+ * Component without props (no schema).
+ *
+ * @example
+ * ```tsx
+ * @Component()
+ * class LatestPostsComponent implements XmlComponent {
+ *   private readonly postService = inject(PostService)
+ *
+ *   async render() {
+ *     const posts = await this.postService.getLatestPosts()
+ *     return <>{posts.map(post => <item>...</item>)}</>
+ *   }
+ * }
+ * ```
+ *
+ * @overload
+ * Component with props schema for type-safe props.
+ *
+ * @param options - Configuration object with schema and optional registry.
+ * @param options.schema - Zod schema for validating and typing component props.
+ * @param options.registry - Optional custom DI registry (defaults to global registry).
+ *
+ * @example
+ * ```tsx
+ * const DescriptionSchema = z.object({
+ *   content: z.string(),
+ *   wrapInCData: z.boolean().optional(),
+ * })
+ *
+ * @Component({ schema: DescriptionSchema })
+ * class DescriptionComponent implements XmlComponent {
+ *   constructor(private props: z.output<typeof DescriptionSchema>) {}
+ *
+ *   async render() {
+ *     return <description>{this.props.wrapInCData ? <CData>{this.props.content}</CData> : this.props.content}</description>
+ *   }
+ * }
+ * ```
+ *
+ * @overload
+ * Component with custom registry only (no props).
+ *
+ * @param options - Configuration object with registry.
+ * @param options.registry - Custom DI registry to use for this component.
+ */
+declare function Component(): <T extends ComponentClass>(target: T, context?: ClassDecoratorContext) => T;
+declare function Component<Schema extends ZodObject<ZodRawShape>>(options: {
+  schema: Schema;
+  registry?: Registry;
+}): <T extends new (props: z.output<Schema>, ...args: any[]) => XmlComponent>(target: T, context?: ClassDecoratorContext) => T;
+declare function Component(options: {
+  registry: Registry;
+}): <T extends ComponentClass>(target: T, context?: ClassDecoratorContext) => T;
+/**
+ * Type guard to check if a value is a component class.
+ *
+ * Component classes are classes decorated with `@Component` that implement
+ * the `XmlComponent` interface.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a component class, `false` otherwise.
+ *
+ * @example
+ * ```ts
+ * if (isComponentClass(MyClass)) {
+ *   // MyClass is a component class
+ *   const instance = await container.get(MyClass)
+ * }
+ * ```
+ */
+declare function isComponentClass(value: unknown): value is ComponentClass;
+//#endregion
+//#region src/handlers/xml-stream.d.mts
+/**
+ * Declares an XML Stream endpoint configuration for use with `@XmlStream` decorator.
+ *
+ * This function creates an endpoint declaration that can be used with the `@XmlStream`
+ * decorator to mark controller methods that return JSX-based XML responses.
+ *
+ * @template Method - The HTTP method (GET, POST, etc.).
+ * @template Url - The URL path pattern (supports parameters like `/posts/:id`).
+ * @template QuerySchema - Optional Zod schema for query parameter validation.
+ * @template RequestSchema - Optional Zod schema for request body validation.
+ *
+ * @param config - The endpoint configuration including method, URL, schemas, and XML options.
+ * @returns An endpoint declaration object to be used with `@XmlStream` decorator.
+ *
+ * @example
+ * ```typescript
+ * import { declareXmlStream } from '@navios/adapter-xml'
+ * import { z } from 'zod/v4'
+ *
+ * // Simple endpoint
+ * export const getRssFeed = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/feed.xml',
+ *   contentType: 'application/rss+xml',
+ * })
+ *
+ * // With query parameters
+ * export const getSitemap = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/sitemap.xml',
+ *   querySchema: z.object({
+ *     page: z.string().optional(),
+ *   }),
+ *   contentType: 'application/xml',
+ *   xmlDeclaration: true,
+ *   encoding: 'UTF-8',
+ * })
+ * ```
+ */
+declare function declareXmlStream<Method extends HttpMethod, Url extends string, QuerySchema = undefined, RequestSchema = undefined>(config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>): {
+  config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>;
+};
+//#endregion
+//#region src/adapters/xml-stream-adapter.service.d.mts
+/**
+ * Adapter service for handling XML Stream endpoints in Navios.
+ *
+ * This service integrates with the base stream adapter (Fastify or Bun) to handle
+ * XML endpoints that return JSX-based XML responses. It automatically renders JSX
+ * nodes to XML strings and sends them with the appropriate Content-Type headers.
+ *
+ * The service supports:
+ * - Async components (resolved in parallel)
+ * - Class components (resolved via DI container)
+ * - Regular JSX elements
+ * - CDATA sections
+ * - Raw XML content
+ *
+ * @implements {AbstractHttpHandlerAdapterInterface}
+ *
+ * @example
+ * ```ts
+ * // This service is automatically registered when using defineXmlEnvironment()
+ * // and is used by endpoints decorated with @XmlStream()
+ * ```
+ */
+declare class XmlStreamAdapterService implements AbstractHttpHandlerAdapterInterface {
+  /** Base stream adapter - we proxy hasSchema, prepareArguments, provideSchema to it */
+  protected streamAdapter: AbstractHttpHandlerAdapterInterface;
+  /**
+   * Prepares argument getters for parsing request data.
+   *
+   * Proxies to the base stream adapter to reuse existing argument preparation logic
+   * that handles query parameters, request body, and URL parameters for both
+   * Fastify and Bun adapters.
+   *
+   * @param handlerMetadata - The handler metadata with schemas and configuration.
+   * @returns An array of getter functions that populate request arguments.
+   */
+  prepareArguments(handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): ((target: Record<string, any>, request: any) => Promise<void> | void)[];
+  /**
+   * Provides schema information for the handler.
+   *
+   * Proxies to the base stream adapter to reuse existing schema generation logic.
+   * For Fastify, this enables built-in validation. For Bun, this returns an empty object.
+   *
+   * @param handlerMetadata - The handler metadata containing configuration and schemas.
+   * @returns Schema information (Fastify route schema or empty object for Bun).
+   */
+  provideSchema(handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): Record<string, any>;
+  /**
+   * Checks if the handler has any validation schemas defined.
+   *
+   * Proxies to the base stream adapter to check for query or request schemas.
+   *
+   * @param handlerMetadata - The handler metadata containing configuration.
+   * @returns `true` if the handler has any schemas (query or request).
+   */
+  hasSchema(handlerMetadata: HandlerMetadata<any>): boolean;
+  /**
+   * Creates a request handler function for XML Stream endpoints.
+   *
+   * This method generates a handler that:
+   * 1. Parses and validates request data (body, query, URL params) using the base adapter
+   * 2. Invokes the controller method with validated arguments (returns JSX)
+   * 3. Renders the JSX tree to XML string (resolves async and class components)
+   * 4. Sends the XML response with appropriate Content-Type header
+   *
+   * The handler automatically detects the environment (Fastify vs Bun) and uses the
+   * appropriate response mechanism (reply object vs Response object).
+   *
+   * @param controller - The controller class containing the handler method.
+   * @param handlerMetadata - The handler metadata with configuration and schemas.
+   * @returns A function that handles incoming requests and sends XML responses.
+   */
+  provideHandler(controller: ClassType, handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): (context: ScopedContainer, request: any, reply: any) => Promise<any>;
+}
+//#endregion
+//#region src/define-environment.d.mts
+/**
+ * Creates the XML environment configuration to be merged with base adapter (Fastify/Bun).
+ *
+ * @example
+ * ```typescript
+ * import { defineFastifyEnvironment } from '@navios/adapter-fastify'
+ * import { defineXmlEnvironment } from '@navios/adapter-xml'
+ * import { NaviosFactory } from '@navios/core'
+ *
+ * const fastifyEnv = defineFastifyEnvironment()
+ * const xmlEnv = defineXmlEnvironment()
+ *
+ * // Merge environments
+ * const mergedEnv = {
+ *   httpTokens: new Map([
+ *     ...fastifyEnv.httpTokens,
+ *     ...xmlEnv.httpTokens,
+ *   ]),
+ * }
+ *
+ * const app = await NaviosFactory.create(AppModule, {
+ *   adapter: mergedEnv,
+ * })
+ * ```
+ */
+declare function defineXmlEnvironment(): {
+  httpTokens: Map<InjectionToken<any, undefined, false>, AnyInjectableType>;
+};
+//#endregion
+export { type AnyXmlNode, AsyncComponent, type AsyncXmlNode, type BaseXmlStreamConfig, CData, type CDataNode, CDataSymbol, ClassComponent, type ClassComponentNode, Component, type ComponentClass, DangerouslyInsertRawXml, Fragment, MissingContainerError, type RawXmlNode, RawXmlSymbol, type RenderOptions, type TagComponent, type XmlComponent, type XmlNode, XmlStream, XmlStreamAdapterService, type XmlStreamParams, createElement, declareXmlStream, defineTag, defineXmlEnvironment, isComponentClass, renderToXml };
+//# sourceMappingURL=index.d.cts.map

package/lib/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types/config.mts","../src/runtime/special-nodes.mts","../src/runtime/render-to-xml.mts","../src/tags/define-tag.mts","../src/decorators/xml-stream.decorator.mts","../src/decorators/component.decorator.mts","../src/handlers/xml-stream.mts","../src/adapters/xml-stream-adapter.service.mts","../src/define-environment.mts"],"sourcesContent":[],"mappings":"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"}