@routecraft/routecraft 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,1454 @@
+import { Logger } from 'pino';
+export { Logger } from 'pino';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+/**
+ * Create a context-aware logger with appropriate metadata.
+ *
+ * This function creates a logger that includes relevant context information:
+ * - For CraftContext: Includes contextId
+ * - For Route: Includes contextId and routeId
+ * - For Exchange: Includes contextId, routeId, exchangeId, and correlationId
+ *
+ * @param context The context to create a logger for
+ * @returns A configured logger instance
+ *
+ * @example
+ * ```typescript
+ * // Create a logger for a context
+ * const contextLogger = createLogger(myContext);
+ * contextLogger.info('Context starting');
+ *
+ * // Create a logger for a route
+ * const routeLogger = createLogger(myRoute);
+ * routeLogger.debug('Processing route');
+ *
+ * // Create a logger for an exchange
+ * const exchangeLogger = createLogger(exchange);
+ * exchangeLogger.info('Processing data', { data: exchange.body });
+ * ```
+ */
+declare function createLogger(context?: CraftContext | Route | Exchange): Logger;
+/**
+ * Default global logger instance.
+ *
+ * Use this for application-level logging when no specific context is available.
+ * For context-specific logging, create a logger using createLogger().
+ *
+ * @example
+ * ```typescript
+ * // Log application-level messages
+ * logger.info('Application starting');
+ * logger.error(error, 'Unexpected error occurred');
+ * ```
+ */
+declare const logger: Logger;
+
+interface Adapter {
+}
+interface Step<T extends Adapter> {
+    operation: OperationType;
+    adapter: T;
+    execute(exchange: Exchange, remainingSteps: Step<Adapter>[], queue: {
+        exchange: Exchange;
+        steps: Step<Adapter>[];
+    }[]): Promise<void>;
+}
+type ConsumerType<T extends Consumer, O = unknown> = new (context: CraftContext, definition: RouteDefinition, channel: unknown, options: O) => T;
+type Message = {
+    message: unknown;
+    headers?: ExchangeHeaders;
+};
+interface Consumer<O = unknown> {
+    context: CraftContext;
+    channel: unknown;
+    definition: RouteDefinition;
+    options: O;
+    register(handler: (message: unknown, headers?: ExchangeHeaders) => Promise<Exchange>): void;
+}
+interface ProcessingQueue<T = unknown> {
+    enqueue(message: T): Promise<Exchange>;
+    setHandler(handler: (message: T) => Promise<Exchange>): Promise<void> | void;
+    clear(): Promise<void> | void;
+}
+type ContextEventName = "contextStarting" | "contextStarted" | "contextStopping" | "contextStopped";
+type RouteEventName = "routeRegistered" | "routeStarting" | "routeStarted" | "routeStopping" | "routeStopped";
+type SystemEventName = "error";
+type EventName = ContextEventName | RouteEventName | SystemEventName;
+type EventDetailsMapping = {
+    contextStarting: Record<string, never>;
+    contextStarted: Record<string, never>;
+    contextStopping: {
+        reason?: unknown;
+    };
+    contextStopped: Record<string, never>;
+    routeRegistered: {
+        route: Route;
+    };
+    routeStarting: {
+        route: Route;
+    };
+    routeStarted: {
+        route: Route;
+    };
+    routeStopping: {
+        route: Route;
+        reason?: unknown;
+        exchange?: Exchange;
+    };
+    routeStopped: {
+        route: Route;
+        exchange?: Exchange;
+    };
+    error: {
+        error: unknown;
+        route?: Route;
+        exchange?: Exchange;
+    };
+};
+type EventPayload<K extends EventName> = {
+    ts: string;
+    context: CraftContext;
+    details: EventDetailsMapping[K];
+};
+type EventHandler<K extends EventName> = (payload: EventPayload<K>) => void | Promise<void>;
+
+type CallableSource<T = unknown> = (context: CraftContext, handler: (message: T, headers?: ExchangeHeaders) => Promise<Exchange>, abortController: AbortController) => Promise<void> | void;
+interface Source<T = unknown> extends Adapter {
+    subscribe: CallableSource<T>;
+}
+
+/**
+ * Defines the configuration for a route including its source, steps, and consumer.
+ *
+ * A route definition describes how data flows from a source through processing steps
+ * to one or more destinations.
+ *
+ * @template T The type of data produced by the source
+ */
+type RouteDefinition<T = unknown> = {
+    /** Unique identifier for the route */
+    readonly id: string;
+    /** The source that provides data to the route */
+    readonly source: Source<T>;
+    /** Processing steps that transform, filter, or direct the data */
+    readonly steps: Step<Adapter>[];
+    /** Consumer configuration that determines how data is processed */
+    readonly consumer: {
+        /** The type of consumer to use */
+        type: ConsumerType<Consumer>;
+        /** Options for the consumer */
+        options: unknown;
+    };
+};
+/**
+ * Represents a runnable route that processes data.
+ *
+ * Routes handle the flow of data from a source through processing steps
+ * and can be started and stopped.
+ */
+interface Route {
+    /** The context this route belongs to */
+    readonly context: CraftContext;
+    /** The route's configuration */
+    readonly definition: RouteDefinition;
+    /** Signal that indicates when the route has been aborted */
+    readonly signal: AbortSignal;
+    /** Logger for this route */
+    logger: Logger;
+    /**
+     * Start processing data on this route.
+     * @returns A promise that resolves when the route has started
+     */
+    start(): Promise<void>;
+    /**
+     * Stop processing data on this route.
+     */
+    stop(): void;
+}
+/**
+ * Default implementation of the Route interface.
+ *
+ * Handles the lifecycle of a route, managing the message flow from
+ * the source through the defined steps.
+ */
+declare class DefaultRoute implements Route {
+    readonly context: CraftContext;
+    readonly definition: RouteDefinition;
+    /** Controls aborting the route's operations */
+    private abortController;
+    /** Logger for this route */
+    readonly logger: Logger;
+    /** Internal queue for passing messages between the source and consumer */
+    private messageChannel;
+    /** Processes messages from the message channel */
+    private consumer;
+    /**
+     * Create a new route instance.
+     *
+     * @param context The context this route belongs to
+     * @param definition The route's configuration
+     * @param abortController Optional controller for aborting the route
+     */
+    constructor(context: CraftContext, definition: RouteDefinition, abortController?: AbortController);
+    /**
+     * Get the abort signal for this route.
+     */
+    get signal(): AbortSignal;
+    /**
+     * Create a new exchange object from a message and optional headers.
+     *
+     * @param message The message data
+     * @param headers Optional headers to include
+     * @returns A new Exchange object
+     * @private
+     */
+    private buildExchange;
+    /**
+     * Start processing data on this route.
+     *
+     * This method:
+     * 1. Registers the consumer to process messages
+     * 2. Subscribes to the source to receive data
+     *
+     * @returns A promise that resolves when the route has started
+     * @throws {RouteCraftError} If the route has been aborted
+     */
+    start(): Promise<void>;
+    /**
+     * Stop processing data on this route.
+     *
+     * This method:
+     * 1. Unsubscribes from the internal processing queue
+     * 2. Aborts the route's controller
+     */
+    stop(): void;
+    /**
+     * Process an exchange through the route's steps.
+     *
+     * This is the main processing logic that:
+     * 1. Takes an initial exchange from the source
+     * 2. Processes it through each step in sequence
+     * 3. Handles errors that occur during processing
+     *
+     * @param exchange The initial exchange to process
+     * @returns A promise that resolves when processing is complete
+     * @private
+     */
+    private handler;
+    /**
+     * Check if the route has been aborted, and throw an error if it has.
+     *
+     * @throws {RouteCraftError} If the route has been aborted
+     * @private
+     */
+    private assertNotAborted;
+    /**
+     * Create a RouteCraftError from an operation error.
+     *
+     * @param operation The operation that caused the error
+     * @param code The error code
+     * @param error The original error
+     * @returns A formatted RouteCraftError
+     * @private
+     */
+    private processError;
+}
+
+/**
+ * Base store registry that can be extended by adapters
+ *
+ * @example
+ * ```typescript
+ * // Extend the store registry with channel adapter types
+ * declare module "@routecraft/routecraft" {
+ *   interface StoreRegistry {
+ *     "routecraft.adapter.channel.store": Map<string, import("./adapters/channel.ts").MessageChannel>;
+ *     "routecraft.adapter.channel.config" Partial<ChannelAdapterOptions>;
+ *   }
+ * }
+ * ```
+ */
+interface StoreRegistry {
+    [key: `${string}.${string}.${string}`]: unknown;
+}
+/**
+ * Options with merged configuration support.
+ * This type is used for adapters that support both direct options and
+ * options that can be merged with context configuration.
+ */
+type MergedOptions<T> = {
+    /** Direct options for configuration */
+    options: Partial<T>;
+    /**
+     * Function to merge options with context configuration
+     * @param context The CraftContext instance
+     * @returns Merged options
+     */
+    mergedOptions(context: CraftContext): T;
+};
+/**
+ * Configuration options for creating a CraftContext.
+ */
+type CraftConfig = {
+    /** Initial values for the context store */
+    store?: Map<keyof StoreRegistry, StoreRegistry[keyof StoreRegistry]>;
+    /** Event handlers to register on context creation */
+    on?: Partial<Record<EventName, EventHandler<EventName> | EventHandler<EventName>[]>>;
+};
+/**
+ * The main context for running and managing routes.
+ *
+ * CraftContext is the central runtime environment that:
+ * - Manages the lifecycle of routes
+ * - Provides a storage system for adapters
+ * - Handles startup and shutdown of the application
+ *
+ * @example
+ * ```typescript
+ * // Create a context with routes and event handlers
+ * const context = new CraftContext({
+ *   on: {
+ *     contextStarting: async () => {
+ *       console.log('Starting application');
+ *     },
+ *     contextStopping: async () => {
+ *       console.log('Shutting down application');
+ *     }
+ *   }
+ * });
+ *
+ * // Register routes
+ * context.registerRoutes(myRoute1, myRoute2);
+ *
+ * // Start processing routes
+ * await context.start();
+ *
+ * // Later, stop all routes
+ * await context.stop();
+ * ```
+ */
+declare class CraftContext {
+    /** Unique identifier for this context instance */
+    readonly contextId: string;
+    /** Routes registered with this context */
+    private routes;
+    /** Abort controllers for each route */
+    private controllers;
+    /** Storage for adapter configuration and state */
+    private store;
+    /** Logger for this context */
+    readonly logger: Logger;
+    /** Registered event handlers */
+    private readonly handlers;
+    /**
+     * Create a new CraftContext instance.
+     *
+     * @param config Optional configuration for the context
+     */
+    constructor(config?: CraftConfig);
+    /**
+     * Subscribe to lifecycle and system events.
+     *
+     * Handlers receive payloads with shape { ts, context, details }.
+     */
+    on<K extends EventName>(event: K, handler: EventHandler<K>): () => void;
+    /**
+     * Emit an event to registered handlers. Public for internal use by routes/adapters.
+     */
+    emit<K extends EventName>(event: K, details: EventPayload<K>["details"]): void;
+    /**
+     * Register routes with this context.
+     *
+     * @param definitions Route definitions to register
+     * @throws {RouteCraftError} If there are duplicate route IDs or invalid route definitions
+     *
+     * @example
+     * ```typescript
+     * // Register a single route
+     * context.registerRoutes(myRoute);
+     *
+     * // Register multiple routes
+     * context.registerRoutes(route1, route2, route3);
+     * ```
+     */
+    registerRoutes(...definitions: RouteDefinition[]): void;
+    /**
+     * Get all routes registered with this context.
+     *
+     * @returns Array of routes
+     */
+    getRoutes(): Route[];
+    /**
+     * Get a value from the context store.
+     *
+     * @template K Store key type
+     * @param key The store key to retrieve
+     * @returns The stored value or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * // Get channel store
+     * const channelStore = context.getStore('routecraft.adapter.channel.store');
+     * ```
+     */
+    getStore<K extends keyof StoreRegistry>(key: K): StoreRegistry[K] | undefined;
+    /**
+     * Set a value in the context store.
+     *
+     * @template K Store key type
+     * @param key The store key
+     * @param value The value to store
+     *
+     * @example
+     * ```typescript
+     * // Set channel store
+     * context.setStore('routecraft.adapter.channel.store', new Map());
+     * ```
+     */
+    setStore<K extends keyof StoreRegistry>(key: K, value: StoreRegistry[K]): void;
+    /**
+     * Find a route by its ID.
+     *
+     * @param id The route ID to find
+     * @returns The matching route or undefined if not found
+     */
+    getRouteById(id: string): Route | undefined;
+    /**
+     * Start all routes registered with this context.
+     *
+     * This will:
+     * 1. Run the onStartup handler if defined
+     * 2. Start all routes in parallel
+     * 3. Wait for all routes to complete if they're not indefinite
+     * 4. Automatically stop the context if all routes complete
+     *
+     * @returns A promise that resolves when all routes have started
+     * @throws If any route fails to start
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await context.start();
+     *   console.log('All routes started successfully');
+     * } catch (error) {
+     *   console.error('Failed to start routes:', error);
+     * }
+     * ```
+     */
+    start(): Promise<void>;
+    /**
+     * Stop all routes and shut down the context.
+     *
+     * This will:
+     * 1. Abort all route controllers
+     * 2. Run the onShutdown handler if defined
+     *
+     * @returns A promise that resolves when all shutdown operations complete
+     *
+     * @example
+     * ```typescript
+     * // Handle shutdown signals
+     * process.on('SIGINT', async () => {
+     *   console.log('Shutting down...');
+     *   await context.stop();
+     *   process.exit(0);
+     * });
+     * ```
+     */
+    stop(): Promise<void>;
+}
+
+/**
+ * Types of operations that can be performed on an exchange.
+ * These values are used in exchange headers to track the current operation.
+ */
+declare enum OperationType {
+    /** The exchange was created from a source */
+    FROM = "from",
+    /** The exchange was processed by a processor */
+    PROCESS = "process",
+    /** The exchange was sent to a destination */
+    TO = "to",
+    /** The exchange was split into multiple exchanges */
+    SPLIT = "split",
+    /** The exchange was aggregated from multiple exchanges */
+    AGGREGATE = "aggregate",
+    /** Modify the body of the exchange */
+    TRANSFORM = "transform",
+    /** Tap an exchange without modifying it */
+    TAP = "tap",
+    /** Filter an exchange based on a condition and reject the message if the condition is not met */
+    FILTER = "filter",
+    /** Validate the exchange against a schema and reject the message if the schema is not met */
+    VALIDATE = "validate",
+    /** Enrich the exchange with data from another exchange */
+    ENRICH = "enrich",
+    /** Set or override a header on the exchange */
+    HEADER = "header"
+}
+/**
+ * Standard header keys used in exchanges.
+ * These keys provide metadata and context for processing exchanges.
+ */
+declare enum HeadersKeys {
+    /** The operation type (from, process, to) */
+    OPERATION = "routecraft.operation",
+    /** The route id */
+    ROUTE_ID = "routecraft.route",
+    /** The correlation id */
+    CORRELATION_ID = "routecraft.correlation_id",
+    /** The hierarchy of split groups this exchange belongs to */
+    SPLIT_HIERARCHY = "routecraft.split_hierarchy",
+    /** The exact timestamp when the timer fired, in ISO 8601 format */
+    TIMER_TIME = "routecraft.timer.time",
+    /** The timestamp when the exchange was created, in ISO 8601 format */
+    TIMER_FIRED_TIME = "routecraft.timer.firedTime",
+    /** The period in milliseconds between timer firings */
+    TIMER_PERIOD_MS = "routecraft.timer.periodMs",
+    /** The number of times the timer has fired */
+    TIMER_COUNTER = "routecraft.timer.counter",
+    /** The next timestamp when the timer will fire, in ISO 8601 format */
+    TIMER_NEXT_RUN = "routecraft.timer.nextRun"
+}
+/**
+ * Standard headers used by the Routecraft framework.
+ * These headers provide critical metadata for processing exchanges.
+ */
+interface RouteCraftHeaders {
+    /** The current operation being performed */
+    [HeadersKeys.OPERATION]: OperationType;
+    /** The ID of the route processing this exchange */
+    [HeadersKeys.ROUTE_ID]: string;
+    /** Unique identifier for correlating related exchanges */
+    [HeadersKeys.CORRELATION_ID]: string;
+    /** Hierarchy path for split operations */
+    [HeadersKeys.SPLIT_HIERARCHY]?: string[];
+    /** Timer-specific headers */
+    [HeadersKeys.TIMER_TIME]?: string;
+    [HeadersKeys.TIMER_FIRED_TIME]?: string;
+    [HeadersKeys.TIMER_PERIOD_MS]?: number;
+    [HeadersKeys.TIMER_COUNTER]?: number;
+    [HeadersKeys.TIMER_NEXT_RUN]?: string;
+}
+/**
+ * Possible types for header values.
+ */
+type HeaderValue = string | number | boolean | undefined | string[];
+/**
+ * Complete set of headers for an exchange.
+ * Includes both standard Routecraft headers and custom headers.
+ */
+type ExchangeHeaders = Partial<RouteCraftHeaders> & Record<string, HeaderValue>;
+/**
+ * Represents a message being processed through a route.
+ *
+ * An exchange encapsulates:
+ * - The data being processed (body)
+ * - Metadata about the processing (headers)
+ * - A unique identifier
+ * - Logging capabilities
+ *
+ * @template T The type of data in the body
+ */
+type Exchange<T = unknown> = {
+    /** Unique identifier for this exchange */
+    readonly id: string;
+    /** Headers containing metadata */
+    readonly headers: ExchangeHeaders;
+    /** The data being processed */
+    body: T;
+    /** Logger for this exchange */
+    logger: Logger;
+};
+/**
+ * Default implementation of the Exchange interface.
+ *
+ * Provides standard exchange functionality with automatic
+ * ID generation and header initialization.
+ *
+ * @template T The type of data in the body
+ *
+ * @example
+ * ```typescript
+ * // Create a simple exchange with a string body
+ * const exchange = new DefaultExchange<string>(context, {
+ *   body: "Hello, World!"
+ * });
+ *
+ * // Access exchange properties
+ * console.log(exchange.id);        // Unique UUID
+ * console.log(exchange.body);      // "Hello, World!"
+ * console.log(exchange.headers);   // Headers object with standard fields
+ * ```
+ */
+declare class DefaultExchange<T = unknown> implements Exchange<T> {
+    readonly context: CraftContext;
+    /** Unique identifier for this exchange */
+    readonly id: string;
+    /** Headers containing metadata */
+    readonly headers: ExchangeHeaders;
+    /** The data being processed */
+    body: T;
+    /** Logger for this exchange */
+    readonly logger: Logger;
+    /**
+     * Create a new exchange.
+     *
+     * @param context The CraftContext this exchange belongs to
+     * @param options Optional configuration for the exchange
+     */
+    constructor(context: CraftContext, options?: Partial<Exchange<T>>);
+}
+
+/**
+ * Processor: mutate or derive a new Exchange from the current one.
+ * - May change body, headers, and type
+ * - Prefer pure logic; avoid side effects (use `.to(...)` for IO)
+ * - Use when you need access to headers or want to replace the whole exchange
+ */
+type CallableProcessor<T = unknown, R = T> = (exchange: Exchange<T>) => Promise<Exchange<R>> | Exchange<R>;
+interface Processor<T = unknown, R = T> extends Adapter {
+    process: CallableProcessor<T, R>;
+}
+
+/**
+ * To (Destination): side effects/output only.
+ * - Sends or persists the current exchange
+ * - Must not modify the message; downstream continues unchanged
+ * - Use for IO boundaries (DB writes, HTTP emits, queues)
+ */
+type CallableDestination<T = unknown> = (exchange: Exchange<T>) => Promise<void> | void;
+interface Destination<T = unknown> extends Adapter {
+    send: CallableDestination<T>;
+}
+
+type CallableSplitter<T = unknown, R = unknown> = (body: T) => Promise<R[]> | R[];
+interface Splitter<T = unknown, R = unknown> extends Adapter {
+    split: CallableSplitter<T, R>;
+}
+
+type CallableAggregator<T = unknown, R = T> = (exchanges: Exchange<T>[]) => Promise<Exchange<R>> | Exchange<R>;
+interface Aggregator<T = unknown, R = unknown> extends Adapter {
+    aggregate: CallableAggregator<T, R>;
+}
+
+/**
+ * Transform: body-only pure conversion.
+ * - Returns a new body; headers and metadata remain unchanged
+ * - Prefer this for simple mapping/scalar conversions
+ * - Use `.process` instead if you need to modify headers or other Exchange fields
+ */
+type CallableTransformer<T = unknown, R = T> = (message: T) => Promise<R> | R;
+interface Transformer<T = unknown, R = T> extends Adapter {
+    transform: CallableTransformer<T, R>;
+}
+
+type CallableTap<T = unknown> = (exchange: Exchange<T>) => Promise<void> | void;
+interface Tap<T = unknown> extends Adapter {
+    tap: CallableTap<T>;
+}
+
+type CallableFilter<T = unknown> = (exchange: Exchange<T>) => Promise<boolean> | boolean;
+interface Filter<T = unknown> extends Adapter {
+    filter: CallableFilter<T>;
+}
+
+/**
+ * Function that produces enrichment data based on the original exchange.
+ * Returns only the enrichment payload (body) which will be combined with the
+ * original exchange by the aggregator.
+ */
+type CallableEnricher<T = unknown, R = unknown> = (exchange: Exchange<T>) => Promise<R> | R;
+/**
+ * Enricher: produce data to merge into the existing exchange.
+ * - Does not return a new Exchange; only the enrichment payload
+ * - Combine with default or custom aggregator in `.enrich(adapter, aggregator)`
+ */
+interface Enricher<T = unknown, R = unknown> extends Adapter {
+    enrich: CallableEnricher<T, R>;
+    adapterId: string;
+}
+/**
+ * Function that aggregates the original exchange with the enrichment data
+ * Similar to CallableAggregator but specifically for the enrich operation
+ */
+type EnrichAggregator<T = unknown, R = unknown> = (original: Exchange<T>, enrichmentData: R) => Promise<Exchange<T>> | Exchange<T>;
+/**
+ * Default aggregator that merges the enrichment data with the original exchange body.
+ *
+ * This aggregator:
+ * 1. Converts the original body to an object if it's not already one (using {value: originalBody})
+ * 2. Converts the enrichment data to an object if it's not already one (using {value: enrichmentData})
+ * 3. Merges these objects using spread syntax ({...originalBody, ...enrichmentObject})
+ *
+ * Note: If both the original body and enrichment data have a 'value' property,
+ * the enrichment data's 'value' will overwrite the original's 'value'.
+ */
+declare const defaultEnrichAggregator: <T = unknown, R = unknown>(original: Exchange<T>, enrichmentData: R) => Exchange<T>;
+
+/**
+ * Builder for creating a RouteCraft context with routes and configuration.
+ *
+ * This builder provides a fluent API for configuring and creating a CraftContext
+ * with routes, startup/shutdown handlers, and initial store values.
+ *
+ * @example
+ * ```typescript
+ * // Create a context with routes and handlers
+ * const context = new ContextBuilder()
+ *   .with({ store: new Map() })
+ *   .on('contextStarting', ({ ts }) => console.log('Starting at', ts))
+ *   .store('routecraft.adapter.channel.store', new Map())
+ *   .routes(routes1)
+ *   .routes([routes2, routes3])
+ *   .build();
+ *
+ * // Start the context to begin processing
+ * await context.start();
+ * ```
+ */
+declare class ContextBuilder {
+    protected config?: CraftConfig;
+    protected definitions: RouteDefinition[];
+    protected initialStores: Map<`${string}.${string}.${string}`, unknown>;
+    protected eventHandlers: Map<EventName, Set<EventHandler<EventName>>>;
+    constructor();
+    /**
+     * Configure the context with the provided config object.
+     *
+     * @param config The configuration object for the context
+     * @returns This builder instance for method chaining
+     */
+    with(config: CraftConfig): this;
+    /**
+     * Register an event listener to be attached to the built context.
+     */
+    on<K extends EventName>(event: K, handler: EventHandler<K>): this;
+    /**
+     * Add an initial value to the context store.
+     *
+     * @template K The store key type
+     * @param key The store key
+     * @param value The initial value for the store
+     * @returns This builder instance for method chaining
+     *
+     * @example
+     * ```typescript
+     * // Add an initial channel store
+     * builder.store('routecraft.adapter.channel.store', new Map());
+     * ```
+     */
+    store<K extends keyof StoreRegistry>(key: K, value: StoreRegistry[K]): this;
+    /**
+     * Add routes to the context.
+     *
+     * Routes can be added as individual RouteDefinitions, RouteBuilders, or arrays of either.
+     *
+     * @param routes Individual or array of route definitions/builders to add
+     * @returns This builder instance for method chaining
+     *
+     * @example
+     * ```typescript
+     * // Add a single route
+     * builder.routes(myRoute);
+     *
+     * // Add multiple routes
+     * builder.routes([route1, route2, route3]);
+     *
+     * // Add a route builder
+     * builder.routes(
+     *   craft()
+     *     .from(simple("hello"))
+     *     .to(log())
+     * );
+     * ```
+     */
+    routes(routes: RouteDefinition[] | RouteBuilder<unknown>[] | RouteDefinition | RouteBuilder<unknown>): this;
+    /**
+     * Build and return a configured CraftContext instance.
+     *
+     * This finalizes the configuration and creates a ready-to-use context
+     * with all the configured routes, handlers, and store values.
+     *
+     * @returns A new CraftContext instance
+     */
+    build(): CraftContext;
+}
+/**
+ * Options for configuring a route.
+ */
+type RouteOptions = Partial<Pick<RouteDefinition, "consumer">> & {
+    /**
+     * Unique identifier for the route.
+     */
+    id: string;
+};
+/**
+ * Builder for creating route definitions with a fluent API.
+ *
+ * This builder provides methods for defining the steps in a route,
+ * including sources, transformations, filters, destinations, and more.
+ *
+ * The type parameter tracks the data type flowing through the route
+ * at each step, providing type safety throughout the route definition.
+ *
+ * @template Current The type of data currently flowing through the route
+ *
+ * @example
+ * ```typescript
+ * // Create a simple route that processes a string
+ * const route = craft()
+ *   .from(simple("Hello, World!"))
+ *   .transform(msg => msg.toUpperCase())
+ *   .to(log())
+ * ```
+ */
+declare class RouteBuilder<Current = unknown> {
+    protected currentRoute?: RouteDefinition;
+    protected routes: RouteDefinition[];
+    protected pendingOptions?: {
+        id?: string;
+        consumer?: {
+            type: ConsumerType<Consumer>;
+            options?: unknown;
+        };
+    } | undefined;
+    constructor();
+    /**
+     * Internal method to create a new RouteBuilder with an updated type parameter.
+     * This is used to propagate type information through the method chain.
+     *
+     * @template T The new type to use for the RouteBuilder
+     * @returns A new RouteBuilder instance with the updated type
+     * @private
+     */
+    private withType;
+    /**
+     * Set the route id for the next route to be created.
+     * This stages the id and does not affect the current route if one exists.
+     */
+    id(id: string): this;
+    /**
+     * Configure batch processing for the next route to be created.
+     * This stages the batch consumer and does not affect the current route if one exists.
+     */
+    batch(options?: {
+        size?: number;
+        flushIntervalMs?: number;
+    }): this;
+    /**
+     * Define the source of data for this route.
+     * This is typically the first step in defining a route.
+     *
+     * @template T The type of data produced by the source
+     * @param source A source adapter or function
+     * @returns A RouteBuilder with the specified type T
+     * @example
+     * // Simple source with inferred type
+     * .from<string[]>(httpServer({ path: '/api/data' }))
+     *
+     * // Source with callable function
+     * .from<User[]>(async () => {
+     *   const response = await fetch('https://api.example.com/users');
+     *   return response.json();
+     * })
+     */
+    from<T>(source: Source<T> | CallableSource<T>): RouteBuilder<T>;
+    /**
+     * Internal method to ensure a source has been defined for the current route.
+     * Throws an error if no source has been defined.
+     *
+     * @returns The current route definition
+     * @throws Error if no source has been defined
+     * @private
+     */
+    private requireSource;
+    /**
+     * Internal method to add a step to the current route.
+     * This is used by the public methods to build up the route definition.
+     *
+     * @template T The type of adapter used by the step
+     * @param step The step definition to add
+     * @returns The current RouteBuilder instance
+     * @private
+     */
+    private addStep;
+    /**
+     * Process the data with a custom function.
+     *
+     * @template Return The resulting type after processing (defaults to Current if not specified)
+     * @param processor A function that transforms the current exchange to a new exchange with the Return
+     * @returns A RouteBuilder with the new type Return
+     * @example
+     * // Transform string data to number
+     * .process<number>((exchange) => {
+     *   return { ...exchange, body: parseInt(exchange.body) };
+     * })
+     */
+    process<Return = Current>(processor: Processor<Current, Return> | CallableProcessor<Current, Return>): RouteBuilder<Return>;
+    /**
+     * Send the processed data to a destination.
+     * This is typically the final step in a route.
+     * The type remains the same after this operation.
+     *
+     * @param destination A function or adapter that consumes the data
+     * @returns A RouteBuilder with the same type
+     * @example
+     * // Send data to a database
+     * .to(async ({ body }) => {
+     *   await db.users.insert(body);
+     * })
+     *
+     * // Send to a predefined destination
+     * .to(kafkaProducer({ topic: 'processed-data' }))
+     */
+    to(destination: Destination<Current> | CallableDestination<Current>): RouteBuilder<Current>;
+    /**
+     * Split an array into individual items for processing.
+     * Each item becomes a separate exchange with a new UUID and copied headers.
+     * If no splitter is provided and the current data is an array, it will automatically
+     * split the array into individual items.
+     *
+     * Similar to Apache Camel's Splitter EIP: accepts body, returns array of body items.
+     * The framework automatically creates new exchanges for each item.
+     *
+     * @template ItemType The type of items in the array (inferred from array if not specified)
+     * @param splitter Optional function that receives the body and returns an array of items
+     * @returns A RouteBuilder with the item type
+     * @example
+     * // Automatically split an array of numbers
+     * .from<number[]>(source)
+     * .split() // ItemType is inferred as number
+     *
+     * // Custom splitting logic - extract nested array
+     * .from(source)
+     * .split<User>((body) => body.users)
+     *
+     * // Split a string by delimiter
+     * .split<string>((body) => body.split(","))
+     */
+    split<ItemType = Current extends Array<infer U> ? U : never>(splitter?: Splitter<Current, ItemType> | CallableSplitter<Current, ItemType>): RouteBuilder<ItemType>;
+    /**
+     * Aggregate multiple items into a single result.
+     * This is often used after a split operation to collect and combine the results.
+     *
+     * @template ResultType The resulting type after aggregation
+     * @param aggregator A function that combines multiple items into a single result
+     * @returns A RouteBuilder with the new aggregated type
+     * @example
+     * // Aggregate an array of numbers into a sum
+     * .split() // Working with individual numbers
+     * .process((exchange) => ({ ...exchange, body: exchange.body * 2 })) // Double each number
+     * .aggregate<number>((exchanges) => {
+     *   const sum = exchanges.reduce((acc, ex) => acc + ex.body, 0);
+     *   return { body: sum, headers: exchanges[0].headers };
+     * })
+     */
+    aggregate<ResultType>(aggregator: Aggregator<Current, ResultType> | CallableAggregator<Current, ResultType>): RouteBuilder<ResultType>;
+    /**
+     * Transform the current data to a new type using a transformer function.
+     * Unlike process, this operates only on the body of the exchange, not the entire exchange.
+     *
+     * @template Return The resulting type after transformation
+     * @param transformer A function that transforms the current body to a new body of type Return
+     * @returns A RouteBuilder with the new type Return
+     * @example
+     * // Transform a string to an object
+     * .transform<{ value: string }>((str) => ({ value: str }))
+     */
+    transform<Return>(transformer: Transformer<Current, Return> | CallableTransformer<Current, Return>): RouteBuilder<Return>;
+    /**
+     * Set or override a header on the current exchange.
+     * The body type remains unchanged.
+     *
+     * @param key Header key to set
+     * @param valueOrFn A static value or a function returning the value from exchange data
+     * @returns A RouteBuilder with the same type
+     * @example
+     * // Static value
+     * .header('x-env', 'prod')
+     *
+     * // Derived from body
+     * .header('user.id', (exchange) => exchange.body.id)
+     *
+     * // Derived from headers
+     * .header('correlation', (exchange) => exchange.headers['x-request-id'])
+     */
+    header(key: string, valueOrFn: HeaderValue | ((exchange: Exchange<Current>) => HeaderValue | Promise<HeaderValue>)): RouteBuilder<Current>;
+    /**
+     * Map fields from the current data to create a new object of a specified type.
+     * This is a specialized transformer that creates a new object by mapping fields
+     * from the source object.
+     *
+     * @template Return The resulting type after mapping
+     * @param fieldMappings An object where keys are field names in the output type and values are
+     *                      functions that extract the corresponding values from the source
+     * @returns A RouteBuilder with the new type Return
+     * @example
+     * // Map from API response to database model
+     * .map<DbUser>({
+     *   id: (apiUser) => apiUser.userId,
+     *   name: (apiUser) => apiUser.fullName,
+     *   email: (apiUser) => apiUser.emailAddress
+     * })
+     */
+    map<Return>(fieldMappings: Record<keyof Return, (src: Current) => Return[keyof Return]>): RouteBuilder<Return>;
+    /**
+     * Execute a side effect without changing the data.
+     * This is useful for logging, metrics, or other operations that don't modify the data.
+     * The type remains the same after tapping.
+     *
+     * @param tap A function that performs a side effect
+     * @returns A RouteBuilder with the same type
+     * @example
+     * // Log the current data
+     * .tap((exchange) => console.log('Processing:', exchange.body))
+     *
+     * // Send metrics
+     * .tap((exchange) => {
+     *   metrics.increment('items_processed');
+     *   metrics.gauge('item_size', JSON.stringify(exchange.body).length);
+     * })
+     */
+    tap(tap: Tap<Current> | CallableTap<Current>): RouteBuilder<Current>;
+    /**
+     * Filter data based on a predicate function.
+     * Exchanges that don't match the predicate will be dropped.
+     *
+     * @param filter A function that returns true to keep the exchange, false to drop it
+     * @returns A RouteBuilder with the same type
+     * @example
+     * // Keep only numbers greater than 10
+     * .filter((num) => num > 10)
+     *
+     * // Filter based on a complex condition
+     * .filter((user) => user.age >= 18 && user.status === 'active')
+     */
+    filter(filter: Filter<Current> | CallableFilter<Current>): RouteBuilder<Current>;
+    /**
+     * Validate data against a schema.
+     * Throws an error if validation fails.
+     *
+     * @param schema A JSON schema to validate against
+     * @returns A RouteBuilder with the same type
+     * @example
+     * // Validate with JSON schema
+     * .validate({
+     *   type: 'object',
+     *   properties: {
+     *     name: { type: 'string' },
+     *     age: { type: 'number', minimum: 0 }
+     *   },
+     *   required: ['name', 'age']
+     * })
+     */
+    validate(schema: StandardSchemaV1): RouteBuilder<Current>;
+    /**
+     * Enrich the current data with additional information.
+     * This is useful for adding context or fetching related data.
+     *
+     * @template R The resulting type after enrichment (defaults to Current if not specified)
+     * @param enricher Function that returns additional data to be merged
+     * @param aggregator Optional function to control how data is combined
+     * @returns A RouteBuilder with the combined type
+     * @example
+     * // Add user details from an API
+     * .enrich<User & { profile: Profile }>(async (user) => {
+     *   const details = await fetchUserDetails(user.id);
+     *   return details;
+     * })
+     *
+     * // Custom aggregation strategy
+     * .enrich<CustomType>(
+     *   async (exchange) => ({ extraData: "value" }),
+     *   (original, enrichmentData) => ({
+     *     ...original,
+     *     body: customMergeFunction(original.body, enrichmentData)
+     *   })
+     * )
+     */
+    enrich<R = Current>(enricher: Enricher<Current, Partial<R>> | CallableEnricher<Current, Partial<R>>, aggregator?: EnrichAggregator<Current, Partial<R>>): RouteBuilder<R>;
+    /**
+     * Finalize the route definition and return it.
+     * This method should be called after all steps have been defined.
+     *
+     * @returns An array of RouteDefinition objects
+     * @example
+     * // Define a complete route and build it
+     * const route = craft()
+     *   .from<string[]>(source)
+     *   .split()
+     *   .process((exchange) => ({ ...exchange, body: exchange.body.toUpperCase() }))
+     *   .to(destination)
+     *
+     * // Add the route to a context
+     * context()
+     *   .routes(route)
+     *   .build();
+     */
+    build(): RouteDefinition[];
+}
+
+type RCCode = "RC1001" | "RC1002" | "RC2001" | "RC2002" | "RC3001" | "RC3002" | "RC5001" | "RC5002" | "RC5003" | "RC5004" | "RC5005" | "RC5006" | "RC5007" | "RC5008" | "RC5009" | "RC9901";
+type RCMeta = {
+    category: "Definition" | "DSL" | "Lifecycle" | "Adapter" | "Runtime";
+    message: string;
+    suggestion?: string;
+    docs: string;
+};
+declare const RC: Record<RCCode, RCMeta>;
+declare class RouteCraftError extends Error {
+    readonly rc: RCCode;
+    readonly meta: RCMeta;
+    constructor(rc: RCCode, meta: RCMeta, cause?: unknown);
+    toString(): string;
+    static parse(cause: unknown): {
+        message: string;
+        error: Error;
+    };
+}
+declare function error(rc: RCCode, cause?: unknown, overrides?: Partial<Pick<RCMeta, "message" | "suggestion" | "docs">>): RouteCraftError;
+
+declare class SimpleConsumer implements Consumer<never> {
+    readonly context: CraftContext;
+    readonly definition: RouteDefinition;
+    readonly channel: ProcessingQueue<Message>;
+    readonly options: never;
+    constructor(context: CraftContext, definition: RouteDefinition, channel: ProcessingQueue<Message>, options: never);
+    register(handler: (message: unknown, headers?: ExchangeHeaders) => Promise<Exchange>): Promise<void>;
+}
+
+type BatchOptions = {
+    /**
+     * The size of the batch.
+     */
+    size?: number;
+    /**
+     * The timeout between batches in milliseconds.
+     */
+    time?: number;
+    /**
+     * The function to merge the produced messages.
+     */
+    merge?: (exchanges: {
+        message: unknown;
+        headers?: ExchangeHeaders;
+    }[]) => {
+        message: unknown;
+        headers?: ExchangeHeaders;
+    };
+};
+declare class BatchConsumer implements Consumer<BatchOptions> {
+    readonly context: CraftContext;
+    readonly definition: RouteDefinition;
+    readonly channel: ProcessingQueue<Message>;
+    readonly options: BatchOptions;
+    constructor(context: CraftContext, definition: RouteDefinition, channel: ProcessingQueue<Message>, options: BatchOptions);
+    register(handler: (message: unknown, headers?: ExchangeHeaders) => Promise<Exchange>): Promise<void>;
+}
+
+declare class SimpleAdapter<T = unknown> implements Source<T> {
+    private producer;
+    readonly adapterId = "routecraft.adapter.simple";
+    constructor(producer: () => T | Promise<T>);
+    subscribe(context: CraftContext, handler: (message: T, headers?: ExchangeHeaders) => Promise<Exchange>, abortController: AbortController): Promise<void>;
+}
+
+declare class NoopAdapter<T = unknown> implements Destination<T> {
+    readonly adapterId = "routecraft.adapter.noop";
+    send(exchange: Exchange<T>): Promise<void>;
+}
+
+declare class LogAdapter<T = unknown> implements Destination<T>, Tap<T> {
+    private readonly formatter?;
+    readonly adapterId = "routecraft.adapter.log";
+    constructor(formatter?: ((exchange: Exchange<T>) => unknown) | undefined);
+    send(exchange: Exchange<T>): Promise<void>;
+    tap(exchange: Exchange<T>): Promise<void>;
+    private baseExchange;
+}
+
+type DirectChannelType<T extends DirectChannel> = new (endpoint: string) => T;
+/**
+ * DirectChannel interface for synchronous inter-route communication.
+ *
+ * Implements Apache Camel's direct: component semantics:
+ * - Single consumer per endpoint (last subscriber wins)
+ * - Synchronous blocking behavior (sender waits for response)
+ * - Point-to-point messaging (not pub/sub)
+ */
+interface DirectChannel<T = unknown> {
+    send(endpoint: string, message: T): Promise<T>;
+    subscribe(context: CraftContext, endpoint: string, handler: (message: T) => Promise<T>): Promise<void>;
+    unsubscribe(context: CraftContext, endpoint: string): Promise<void>;
+}
+interface DirectAdapterOptions {
+    channelType?: DirectChannelType<DirectChannel>;
+}
+declare module "@routecraft/routecraft" {
+    interface StoreRegistry {
+        [DirectAdapter.ADAPTER_DIRECT_STORE]: Map<string, DirectChannel<Exchange>>;
+        [DirectAdapter.ADAPTER_DIRECT_OPTIONS]: Partial<DirectAdapterOptions>;
+    }
+}
+declare class DirectAdapter<T = unknown> implements Source<T>, Destination<T>, MergedOptions<DirectAdapterOptions> {
+    options: Partial<DirectAdapterOptions>;
+    readonly adapterId = "routecraft.adapter.direct";
+    static readonly ADAPTER_DIRECT_STORE: "routecraft.adapter.direct.store";
+    static readonly ADAPTER_DIRECT_OPTIONS: "routecraft.adapter.direct.options";
+    private rawEndpoint;
+    constructor(rawEndpoint: string, options?: Partial<DirectAdapterOptions>);
+    private get sanitizedEndpoint();
+    subscribe(context: CraftContext, handler: (message: T, headers?: ExchangeHeaders) => Promise<Exchange>, abortController: AbortController): Promise<void>;
+    private directChannel;
+    send(exchange: Exchange<T>): Promise<void>;
+    mergedOptions(context: CraftContext): DirectAdapterOptions;
+}
+
+interface TimerOptions {
+    /**
+     * Time between executions in milliseconds
+     * @default 1000
+     */
+    intervalMs?: number;
+    /**
+     * Delay before the first execution in milliseconds
+     * @default 0
+     */
+    delayMs?: number;
+    /**
+     * Number of times to trigger before stopping
+     * @default Infinity
+     */
+    repeatCount?: number;
+    /**
+     * Ensures execution happens at exact intervals (ignoring execution time)
+     * @default false
+     */
+    fixedRate?: boolean;
+    /**
+     * Executes at an exact time of day (ISO HH:mm:ss)
+     * @default null
+     */
+    exactTime?: string;
+    /**
+     * Allows custom date formats for execution times
+     * @default null
+     */
+    timePattern?: string;
+    /**
+     * Adds random delay to prevent synchronized execution spikes
+     * @default 0
+     */
+    jitterMs?: number;
+}
+declare class TimerAdapter implements Source<undefined> {
+    private options?;
+    readonly adapterId = "routecraft.adapter.timer";
+    constructor(options?: TimerOptions | undefined);
+    subscribe(_context: CraftContext, handler: (message: undefined, headers?: ExchangeHeaders) => Promise<Exchange>, abortController: AbortController): Promise<void>;
+}
+
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+type QueryParams = Record<string, string | number | boolean>;
+interface FetchOptions<T = unknown> {
+    method?: HttpMethod;
+    url: string | ((exchange: Exchange<T>) => string);
+    headers?: Record<string, string> | ((exchange: Exchange<T>) => Record<string, string>);
+    query?: QueryParams | ((exchange: Exchange<T>) => QueryParams);
+    body?: unknown | ((exchange: Exchange<T>) => unknown);
+    timeoutMs?: number;
+    throwOnHttpError?: boolean;
+}
+type FetchResult<T = string | unknown> = {
+    status: number;
+    headers: Record<string, string>;
+    body: T;
+    url: string;
+};
+/**
+ * FetchAdapter can act as a Processor, Enricher, or Destination.
+ * - process: replaces body with FetchResult
+ * - enrich: returns FetchResult for aggregation
+ * - send: performs request as side effect (ignores body)
+ */
+declare class FetchAdapter<T = unknown, R = FetchResult> implements Enricher<T, R>, Destination<T> {
+    private readonly options;
+    readonly adapterId = "routecraft.adapter.fetch";
+    constructor(options: FetchOptions<T>);
+    enrich(exchange: Exchange<T>): Promise<R>;
+    send(exchange: Exchange<T>): Promise<void>;
+    private performFetch;
+    private resolve;
+    private resolveRequired;
+    private appendQuery;
+    private base;
+}
+
+/**
+ * Create a new context builder.
+ *
+ * This is the entry point for creating a new application context.
+ *
+ * @returns A new ContextBuilder instance
+ *
+ * @example
+ * ```typescript
+ * // Create and configure a context
+ * const ctx = context()
+ *   .routes(myRoute)
+ *   .on('contextStarting', () => console.log('Starting...'))
+ *   .build();
+ *
+ * // Start processing
+ * await ctx.start();
+ * ```
+ */
+declare function context(): ContextBuilder;
+/**
+ * Create a new route builder.
+ *
+ * This is the entry point for defining routes in a fluent way.
+ *
+ * @returns A new RouteBuilder instance
+ *
+ * @example
+ * ```typescript
+ * // Define a route that processes data
+ * const myRoute = craft()
+ *   .from(simple("Hello, World!"))
+ *   .transform(data => data.toUpperCase())
+ *   .to(log())
+ * ```
+ */
+declare function craft(): RouteBuilder;
+/**
+ * Create a simple adapter that produces static or dynamically generated data.
+ *
+ * This adapter can be used as a source in a route to provide data.
+ *
+ * @template T The type of data to produce
+ * @param producer A static value or function that produces a value
+ * @returns A SimpleAdapter instance
+ *
+ * @example
+ * ```typescript
+ * // Static data
+ * craft().from(simple("Hello, World!"))
+ *
+ * // Dynamic data from a function
+ * craft().from(simple(() => new Date().toISOString()))
+ *
+ * // Dynamic data from an async function
+ * craft().from(simple(async () => {
+ *   const response = await fetch('https://api.example.com/data');
+ *   return response.json();
+ * }))
+ * ```
+ */
+declare function simple<T = unknown>(producer: (() => T | Promise<T>) | T): SimpleAdapter<T>;
+/**
+ * Create a no-operation adapter that does nothing.
+ *
+ * This can be useful for testing or as a placeholder.
+ *
+ * @template T The type of data this adapter processes
+ * @returns A NoopAdapter instance
+ *
+ * @example
+ * ```typescript
+ * // Send to a no-op destination during development
+ * craft()
+ *   .from(source)
+ *   .to(process.env.PROD ? realDestination() : noop())
+ * ```
+ */
+declare function noop<T = unknown>(): NoopAdapter<T>;
+/**
+ * Create a logging adapter that logs messages to the console.
+ *
+ * This is useful for debugging and monitoring data flow in routes.
+ *
+ * @template T The type of data this adapter processes
+ * @param formatter Optional function that takes an exchange and returns the value to log.
+ *                  If not provided, logs exchange ID, body, and headers.
+ * @returns A LogAdapter instance
+ *
+ * @example
+ * ```typescript
+ * // Log data at different points in the route
+ * craft()
+ *   .from(source)
+ *   .tap(log()) // Log input data
+ *   .transform(data => processData(data))
+ *   .tap(log()) // Log transformed data
+ *   .to(destination)
+ *
+ * // Log with custom formatter
+ * craft()
+ *   .from(source)
+ *   .tap(log((ex) => `Exchange with id: ${ex.id}`))
+ *   .tap(log((ex) => `Body: ${JSON.stringify(ex.body)}`))
+ *   .to(destination)
+ * ```
+ */
+declare function log<T = unknown>(formatter?: (exchange: Exchange<T>) => unknown): LogAdapter<T>;
+/**
+ * Create a direct adapter for synchronous inter-route communication.
+ *
+ * Direct adapters allow routes to communicate with each other
+ * synchronously with single consumer semantics (Apache Camel style).
+ *
+ * @template T The type of data this adapter processes
+ * @param endpoint The name of the direct endpoint to use
+ * @param options Optional configuration for the direct adapter
+ * @returns A DirectAdapter instance
+ *
+ * @example
+ * ```typescript
+ * // Producer route sends to a direct endpoint
+ * const producerRoute = craft()
+ *   .from(source)
+ *   .to(direct('my-endpoint'))
+ *
+ * // Consumer route reads from the same endpoint
+ * const consumerRoute = craft()
+ *   .from(direct('my-endpoint'))
+ *   .to(destination)
+ *
+ * // Register both routes with the context
+ * context().routes([producerRoute, consumerRoute]);
+ * ```
+ */
+declare function direct<T = unknown>(endpoint: string, options?: Partial<DirectAdapterOptions>): DirectAdapter<T>;
+/**
+ * Create a timer adapter that produces messages at regular intervals.
+ *
+ * This adapter can be used as a source in a route to trigger processing
+ * on a schedule.
+ *
+ * @param options Configuration for the timer
+ * @returns A TimerAdapter instance
+ *
+ * @example
+ * ```typescript
+ * // Run every 5 seconds
+ * craft()
+ *   .from(timer({ intervalMs: 5000 }))
+ *   .to(periodicTask)
+ *
+ * // Run 10 times, once per second
+ * craft()
+ *   .from(timer({ intervalMs: 1000, repeatCount: 10 }))
+ *   .to(batchTask)
+ * ```
+ */
+declare function timer(options?: TimerOptions): TimerAdapter;
+/**
+ * Create an HTTP client adapter for making requests.
+ * Acts as processor, enricher, or destination depending on usage site.
+ */
+declare function fetch<T = unknown, R = unknown>(options: FetchOptions<T>): FetchAdapter<T, R>;
+
+export { type Adapter, type Aggregator, BatchConsumer, type BatchOptions, type CallableAggregator, type CallableDestination, type CallableEnricher, type CallableFilter, type CallableProcessor, type CallableSource, type CallableSplitter, type CallableTap, type CallableTransformer, type Consumer, type ConsumerType, ContextBuilder, type CraftConfig, CraftContext, DefaultExchange, DefaultRoute, type Destination, DirectAdapter, type DirectAdapterOptions, type DirectChannel, type DirectChannelType, type EnrichAggregator, type Enricher, type Exchange, type ExchangeHeaders, FetchAdapter, type FetchOptions, type FetchResult, type Filter, type HeaderValue, HeadersKeys, LogAdapter, type MergedOptions, type Message, NoopAdapter, OperationType, type Processor, RC, type RCCode, type RCMeta, type Route, RouteBuilder, RouteCraftError, type RouteDefinition, type RouteOptions, SimpleAdapter, SimpleConsumer, type Source, type Splitter, type Step, type StoreRegistry, type Tap, TimerAdapter, type TimerOptions, type Transformer, context, craft, createLogger, defaultEnrichAggregator, direct, error, fetch, log, logger, noop, simple, timer };