@navios/adapter-xml 0.1.0

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

@@ -0,0 +1,414 @@
+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 { }