@navios/adapter-xml 0.1.0 → 0.7.0

package/src/runtime/render-to-xml.mts

@@ -1,5 +1,6 @@
-import type { Container } from '@navios/di'
+import type { Container, ScopedContainer } from '@navios/core'
 
+import type { XmlComponent } from '../types/component.mjs'
 import type {
   AnyXmlNode,
   AsyncXmlNode,
@@ -7,7 +8,6 @@ import type {
   ClassComponentNode,
   RawXmlNode,
 } from '../types/xml-node.mjs'
-import type { XmlComponent } from '../types/component.mjs'
 
 import {
   AsyncComponent,
@@ -17,6 +17,19 @@ import {
   RawXmlSymbol,
 } from '../types/xml-node.mjs'
 
+/**
+ * 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
+ * })
+ * ```
+ */
 export interface RenderOptions {
   /** Include XML declaration (<?xml version="1.0"?>) - defaults to true */
   declaration?: boolean
@@ -28,9 +41,28 @@ export interface RenderOptions {
    * DI container for resolving class components.
    * Required if the tree contains any class components.
    */
-  container?: Container
+  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 })
+ *   }
+ * }
+ * ```
+ */
 export class MissingContainerError extends Error {
   constructor(componentName: string) {
     super(
@@ -41,6 +73,42 @@ export class MissingContainerError extends Error {
   }
 }
 
+/**
+ * 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 })
+ * ```
+ */
 export async function renderToXml(
   node: AnyXmlNode,
   options: RenderOptions = {},
@@ -65,7 +133,7 @@ export async function renderToXml(
 async function renderNode(
   node: AnyXmlNode,
   indent: number,
-  container: Container | undefined,
+  container: Container | ScopedContainer | undefined,
 ): Promise<string> {
   if (node == null) return ''
   if (typeof node === 'string') return escapeXml(node)

package/src/tags/define-tag.mts

@@ -3,6 +3,14 @@ import type { z } from 'zod/v4'
 
 import type { AnyXmlNode, XmlNode } from '../types/xml-node.mjs'
 
+/**
+ * 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.
+ */
 export interface TagComponent<Props extends Record<string, unknown>> {
   (props: Props & { children?: AnyXmlNode | AnyXmlNode[] }): XmlNode
   tagName: string

package/src/types/component.mts

@@ -1,15 +1,59 @@
 import type { AnyXmlNode } from './xml-node.mjs'
 
 /**
- * Base interface for class components.
- * The render method takes no arguments - props are received via constructor.
+ * Base interface for class-based XML components.
+ *
+ * Class components are classes decorated with `@Component` that can use
+ * dependency injection and return JSX-based XML nodes. The `render()` method
+ * takes no arguments - props are received via the constructor.
+ *
+ * @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>)}
+ *       </>
+ *     )
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With props
+ * @Component({ schema: MyPropsSchema })
+ * class MyComponent implements XmlComponent {
+ *   constructor(private props: z.output<typeof MyPropsSchema>) {}
+ *
+ *   render() {
+ *     return <div>{this.props.content}</div>
+ *   }
+ * }
+ * ```
  */
 export interface XmlComponent {
+  /**
+   * Renders the component to an XML node.
+   *
+   * This method is called when the component is rendered. It can return
+   * a synchronous XML node or a Promise that resolves to an XML node.
+   *
+   * @returns An XML node or a Promise that resolves to an XML node.
+   */
   render(): AnyXmlNode | Promise<AnyXmlNode>
 }
 
 /**
  * Type for class component constructors.
+ *
+ * This type represents a class constructor that creates instances of
+ * `XmlComponent`. Used for type checking and dependency injection.
  */
 export interface ComponentClass {
   new (...args: any[]): XmlComponent

package/src/types/config.mts

@@ -1,5 +1,27 @@
 import type { BaseStreamConfig, HttpMethod } from '@navios/builder'
 
+/**
+ * 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',
+ * }
+ * ```
+ */
 export interface BaseXmlStreamConfig<
   Method extends HttpMethod = HttpMethod,
   Url extends string = string,

package/tsdown.config.mts

@@ -0,0 +1,39 @@
+import { withFilter } from 'rolldown/filter'
+import { defineConfig } from 'tsdown'
+import swc from 'unplugin-swc'
+
+export default defineConfig({
+  entry: [
+    'src/index.mts',
+    'src/jsx-runtime.mts',
+    'src/jsx-dev-runtime.mts',
+    'src/jsx.mts',
+  ],
+  outDir: 'lib',
+  format: ['esm', 'cjs'],
+  clean: true,
+  tsconfig: 'tsconfig.lib.json',
+  treeshake: true,
+  sourcemap: true,
+  platform: 'node',
+  dts: true,
+  target: 'es2022',
+  plugins: [
+    withFilter(
+      swc.rolldown({
+        jsc: {
+          target: 'es2022',
+          parser: {
+            syntax: 'typescript',
+            decorators: true,
+          },
+          transform: {
+            decoratorVersion: '2022-03',
+          },
+        },
+      }),
+      // Only run this transform if the file contains a decorator.
+      { transform: { code: '@' } },
+    ),
+  ],
+})

package/lib/_tsup-dts-rollup.d.mts

@@ -1,414 +0,0 @@
-import type { AbstractHttpHandlerAdapterInterface } from '@navios/core';
-import type { AnyInjectableType } from '@navios/di';
-import type { BaseStreamConfig } from '@navios/builder';
-import type { ClassType } from '@navios/di';
-import { Container } from '@navios/di';
-import type { EndpointFunctionArgs } from '@navios/builder';
-import type { HandlerMetadata } from '@navios/core';
-import type { HttpMethod } from '@navios/builder';
-import { InjectionToken } from '@navios/di';
-import type { Registry } from '@navios/di';
-import type { RequestContextHolder } from '@navios/di';
-import type { Util_FlatObject } from '@navios/builder';
-import type { z } from 'zod/v4';
-import type { ZodObject } from 'zod/v4';
-import type { ZodRawShape } from 'zod/v4';
-import type { ZodType } from 'zod/v4';
-
-/** Union type for all possible node types */
-declare type AnyXmlNode = XmlNode | AsyncXmlNode | CDataNode | RawXmlNode | ClassComponentNode | string | number | null | undefined;
-export { AnyXmlNode }
-export { AnyXmlNode as AnyXmlNode_alias_1 }
-export { AnyXmlNode as AnyXmlNode_alias_2 }
-
-declare const AsyncComponent: unique symbol;
-export { AsyncComponent }
-export { AsyncComponent as AsyncComponent_alias_1 }
-export { AsyncComponent as AsyncComponent_alias_2 }
-
-declare type AsyncComponentFn = (props: any) => Promise<XmlNode | AsyncXmlNode | ClassComponentNode>;
-
-/** Represents an async component that needs to be resolved before rendering */
-declare interface AsyncXmlNode {
-    type: typeof AsyncComponent;
-    promise: Promise<AnyXmlNode>;
-}
-export { AsyncXmlNode }
-export { AsyncXmlNode as AsyncXmlNode_alias_1 }
-export { AsyncXmlNode as AsyncXmlNode_alias_2 }
-
-declare 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;
-}
-export { BaseXmlStreamConfig }
-export { BaseXmlStreamConfig as BaseXmlStreamConfig_alias_1 }
-export { BaseXmlStreamConfig as BaseXmlStreamConfig_alias_2 }
-
-/**
- * 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;
-export { CData }
-export { CData as CData_alias_1 }
-export { CData as CData_alias_2 }
-
-/** Represents a CDATA section - content is wrapped in <![CDATA[...]]> */
-declare interface CDataNode {
-    type: typeof CDataSymbol;
-    content: string;
-}
-export { CDataNode }
-export { CDataNode as CDataNode_alias_1 }
-export { CDataNode as CDataNode_alias_2 }
-
-declare const CDataSymbol: unique symbol;
-export { CDataSymbol }
-export { CDataSymbol as CDataSymbol_alias_1 }
-export { CDataSymbol as CDataSymbol_alias_2 }
-
-declare const ClassComponent: unique symbol;
-export { ClassComponent }
-export { ClassComponent as ClassComponent_alias_1 }
-export { ClassComponent as ClassComponent_alias_2 }
-
-/** Represents a class component that needs to be resolved via DI */
-declare interface ClassComponentNode {
-    type: typeof ClassComponent;
-    componentClass: ComponentClass;
-    props: Record<string, unknown>;
-}
-export { ClassComponentNode }
-export { ClassComponentNode as ClassComponentNode_alias_1 }
-export { ClassComponentNode as ClassComponentNode_alias_2 }
-
-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;
-export { Component }
-export { Component as Component_alias_1 }
-export { Component as Component_alias_2 }
-
-/**
- * Type for class component constructors.
- */
-declare interface ComponentClass {
-    new (...args: any[]): XmlComponent;
-}
-export { ComponentClass }
-export { ComponentClass as ComponentClass_alias_1 }
-export { ComponentClass as ComponentClass_alias_2 }
-
-declare const ComponentMeta: unique symbol;
-export { ComponentMeta }
-export { ComponentMeta as ComponentMeta_alias_1 }
-
-declare type ComponentType = FunctionalComponent | ComponentClass;
-
-/**
- * Classic createElement for manual usage.
- * Children are passed as rest arguments.
- */
-declare function createElement(type: string | typeof Fragment | ComponentType, props: Record<string, unknown> | null, ...children: any[]): XmlNode | AsyncXmlNode | ClassComponentNode;
-export { createElement }
-export { createElement as createElement_alias_1 }
-export { createElement as createElement_alias_2 }
-
-/**
- * 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;
-export { DangerouslyInsertRawXml }
-export { DangerouslyInsertRawXml as DangerouslyInsertRawXml_alias_1 }
-export { DangerouslyInsertRawXml as DangerouslyInsertRawXml_alias_2 }
-
-/**
- * Declares an XML Stream endpoint configuration for use with @XmlStream decorator.
- *
- * @example
- * ```typescript
- * import { declareXmlStream } from '@navios/adapter-xml'
- *
- * export const getRssFeed = declareXmlStream({
- *   method: 'GET',
- *   url: '/feed.xml',
- *   querySchema: undefined,
- *   requestSchema: undefined,
- *   contentType: 'application/rss+xml',
- *   xmlDeclaration: true,
- * })
- * ```
- */
-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>;
-};
-export { declareXmlStream }
-export { declareXmlStream as declareXmlStream_alias_1 }
-export { declareXmlStream as declareXmlStream_alias_2 }
-
-/**
- * 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>>;
-export { defineTag }
-export { defineTag as defineTag_alias_1 }
-export { defineTag as defineTag_alias_2 }
-
-/**
- * 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>;
-};
-export { defineXmlEnvironment }
-export { defineXmlEnvironment as defineXmlEnvironment_alias_1 }
-
-declare const Fragment: unique symbol;
-export { Fragment }
-export { Fragment as Fragment_alias_1 }
-export { Fragment as Fragment_alias_2 }
-export { Fragment as Fragment_alias_3 }
-export { Fragment as Fragment_alias_4 }
-export { Fragment as Fragment_alias_5 }
-export { Fragment as Fragment_alias_6 }
-export { Fragment as Fragment_alias_7 }
-
-declare type FunctionalComponent = SyncComponent | AsyncComponentFn;
-
-/**
- * Type guard to check if a class is a component
- */
-declare function isComponentClass(value: unknown): value is ComponentClass;
-export { isComponentClass }
-export { isComponentClass as isComponentClass_alias_1 }
-export { isComponentClass as isComponentClass_alias_2 }
-
-/**
- * JSX automatic runtime function.
- * Used by the JSX transformer when jsxImportSource is set.
- * Children are passed as part of props.children.
- */
-declare function jsx(type: string | typeof Fragment | ComponentType, props: Record<string, unknown> | null): XmlNode | AsyncXmlNode | ClassComponentNode;
-export { jsx }
-export { jsx as jsx_alias_1 }
-export { jsx as jsx_alias_2 }
-
-export declare const jsxDEV: typeof jsx;
-
-/**
- * JSX automatic runtime function for static children.
- * Identical to jsx() for XML - React uses this for optimization hints.
- */
-declare const jsxs: typeof jsx;
-export { jsxs }
-export { jsxs as jsxs_alias_1 }
-export { jsxs as jsxs_alias_2 }
-
-declare class MissingContainerError extends Error {
-    constructor(componentName: string);
-}
-export { MissingContainerError }
-export { MissingContainerError as MissingContainerError_alias_1 }
-export { MissingContainerError as MissingContainerError_alias_2 }
-
-/** Represents raw XML content - inserted without any escaping or wrapping */
-declare interface RawXmlNode {
-    type: typeof RawXmlSymbol;
-    content: string;
-}
-export { RawXmlNode }
-export { RawXmlNode as RawXmlNode_alias_1 }
-export { RawXmlNode as RawXmlNode_alias_2 }
-
-declare const RawXmlSymbol: unique symbol;
-export { RawXmlSymbol }
-export { RawXmlSymbol as RawXmlSymbol_alias_1 }
-export { RawXmlSymbol as RawXmlSymbol_alias_2 }
-
-declare 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;
-}
-export { RenderOptions }
-export { RenderOptions as RenderOptions_alias_1 }
-export { RenderOptions as RenderOptions_alias_2 }
-
-declare function renderToXml(node: AnyXmlNode, options?: RenderOptions): Promise<string>;
-export { renderToXml }
-export { renderToXml as renderToXml_alias_1 }
-export { renderToXml as renderToXml_alias_2 }
-
-declare type SyncComponent = (props: any) => XmlNode | AsyncXmlNode | ClassComponentNode;
-
-declare interface TagComponent<Props extends Record<string, unknown>> {
-    (props: Props & {
-        children?: AnyXmlNode | AnyXmlNode[];
-    }): XmlNode;
-    tagName: string;
-}
-export { TagComponent }
-export { TagComponent as TagComponent_alias_1 }
-export { TagComponent as TagComponent_alias_2 }
-
-/**
- * Base interface for class components.
- * The render method takes no arguments - props are received via constructor.
- */
-declare interface XmlComponent {
-    render(): AnyXmlNode | Promise<AnyXmlNode>;
-}
-export { XmlComponent }
-export { XmlComponent as XmlComponent_alias_1 }
-export { XmlComponent as XmlComponent_alias_2 }
-
-declare interface XmlNode {
-    type: string | typeof Fragment;
-    props: Record<string, unknown>;
-    children: AnyXmlNode[];
-}
-export { XmlNode }
-export { XmlNode as XmlNode_alias_1 }
-export { XmlNode as XmlNode_alias_2 }
-
-/**
- * Decorator for XML Stream endpoints that return JSX-based XML responses.
- *
- * @example
- * ```typescript
- * import { XmlStream } from '@navios/adapter-xml'
- * import { Controller } from '@navios/core'
- *
- * const getRssFeed = declareXmlStream({
- *   method: 'GET',
- *   url: '/feed.xml',
- *   querySchema: undefined,
- *   requestSchema: undefined,
- *   contentType: 'application/rss+xml',
- * })
- *
- * @Controller('/api')
- * class FeedController {
- *   @XmlStream(getRssFeed)
- *   async getFeed() {
- *     return (
- *       <rss version="2.0">
- *         <channel>
- *           <title>My Feed</title>
- *         </channel>
- *       </rss>
- *     )
- *   }
- * }
- * ```
- */
-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>;
-export { XmlStream }
-export { XmlStream as XmlStream_alias_1 }
-export { XmlStream as XmlStream_alias_2 }
-
-declare class XmlStreamAdapterService implements AbstractHttpHandlerAdapterInterface {
-    protected container: Container;
-    /** Base stream adapter - we proxy hasSchema, prepareArguments, provideSchema to it */
-    protected streamAdapter: AbstractHttpHandlerAdapterInterface;
-    /**
-     * Proxy to base StreamAdapter - reuses existing argument preparation logic
-     * (handles querySchema, requestSchema, URL params for both Fastify and Bun)
-     */
-    prepareArguments(handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): ((target: Record<string, any>, request: any) => Promise<void> | void)[];
-    provideSchema(handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): Record<string, any>;
-    hasSchema(handlerMetadata: HandlerMetadata<any>): boolean;
-    /**
-     * Custom handler - renders JSX to XML and handles response for both Fastify and Bun
-     */
-    provideHandler(controller: ClassType, handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): (context: RequestContextHolder, request: any, reply: any) => Promise<any>;
-}
-export { XmlStreamAdapterService }
-export { XmlStreamAdapterService as XmlStreamAdapterService_alias_1 }
-export { XmlStreamAdapterService as XmlStreamAdapterService_alias_2 }
-
-declare 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>>;
-export { XmlStreamParams }
-export { XmlStreamParams as XmlStreamParams_alias_1 }
-export { XmlStreamParams as XmlStreamParams_alias_2 }
-
-export { }