@message-in-the-middle/core/dist/cjs/factories.d.ts

Framework-agnostic middleware pattern for message queue processing. Core package with all middlewares.

import { MessageDispatcher, MessageHandlerFn, MessageDispatcherOptions } from './dispatcher';
import type { EncryptionService, DecryptionOptions } from './middlewares/encryption.middleware';
import type { DeduplicationStore } from './middlewares/deduplication.middleware';
import type { JsonParseOptions, JsonStringifyOptions } from './middlewares/json.middleware';
import type { LogInboundMiddlewareOptions } from './middlewares/logging.middleware';
import type { RetryOptions } from './middlewares/immediate-retry.middleware';
import type { RateLimiter } from './middlewares/throttling.middleware';
import type { SchemaRegistry } from './middlewares/schema-registry.middleware';
import type { CorrelationIdOptions } from './middlewares/correlation-id.middleware';
import type { CircuitBreakerOptions } from './middlewares/circuit-breaker.middleware';
import type { BatchingOptions } from './middlewares/batching.middleware';
import type { ErrorHandler } from './middlewares/error-handler.middleware';
import type { MessageContext } from './types';
import { ParseJsonInboundMiddleware, StringifyJsonOutboundMiddleware } from './middlewares/json.middleware';
import { LogInboundMiddleware, LogOutboundMiddleware } from './middlewares/logging.middleware';
import { ValidateInboundMiddleware, ValidateOutboundMiddleware } from './middlewares/validation.middleware';
import { DeduplicateInboundMiddleware } from './middlewares/deduplication.middleware';
import { ImmediateRetryInboundMiddleware } from './middlewares/immediate-retry.middleware';
import { DecryptInboundMiddleware, EncryptOutboundMiddleware } from './middlewares/encryption.middleware';
import { TransformInboundMiddleware, TransformOutboundMiddleware } from './middlewares/transformation.middleware';
import { ErrorHandlerInboundMiddleware } from './middlewares/error-handler.middleware';
import { MetricsInboundMiddleware, MetricsOutboundMiddleware } from './middlewares/metrics.middleware';
import { TracingInboundMiddleware, TracingOutboundMiddleware } from './middlewares/tracing.middleware';
import { CorrelationIdInboundMiddleware, CorrelationIdOutboundMiddleware } from './middlewares/correlation-id.middleware';
import { CircuitBreakerInboundMiddleware } from './middlewares/circuit-breaker.middleware';
import { BatchingInboundMiddleware } from './middlewares/batching.middleware';
import { SchemaRegistryMiddleware } from './middlewares/schema-registry.middleware';
import { ThrottlingOutboundMiddleware } from './middlewares/throttling.middleware';
import { DispatcherMiddleware } from './dispatcher';
export declare function parseJson<T = any>(options?: JsonParseOptions): ParseJsonInboundMiddleware<T>;
export declare function log<T = any>(logger: {
    log: (message: string, context?: any) => void;
}, options?: LogInboundMiddlewareOptions): LogInboundMiddleware<T>;
export declare function validate<T = any>(validator: (data: any) => Promise<T> | T, options?: {
    throwOnError?: boolean;
}): ValidateInboundMiddleware<T>;
export declare function deduplicate<T = any>(store: DeduplicationStore, options?: {
    keyExtractor?: (context: MessageContext<T>) => string;
    ttlSeconds?: number;
    throwOnDuplicate?: boolean;
}): DeduplicateInboundMiddleware<T>;
export declare function retry<T = any>(options: RetryOptions): ImmediateRetryInboundMiddleware<T>;
export declare function decrypt<T = any>(encryptionService: EncryptionService, fields?: string[], options?: DecryptionOptions): DecryptInboundMiddleware<T>;
export declare function transform<TIn = any, TOut = any>(transformer: (data: TIn) => Promise<TOut> | TOut): TransformInboundMiddleware<TIn, TOut>;
export declare function handleErrors<T = any>(errorHandler: ErrorHandler<T>, maxRetries?: number): ErrorHandlerInboundMiddleware<T>;
export declare function collectMetrics<T = any>(collector: any, options?: {
    prefix?: string;
}): MetricsInboundMiddleware<T>;
export declare function trace<T = any>(tracer: any, options?: any): TracingInboundMiddleware<T>;
export declare function correlationId<T = any>(options?: CorrelationIdOptions): CorrelationIdInboundMiddleware<T>;
export declare function circuitBreaker<T = any>(options: CircuitBreakerOptions): CircuitBreakerInboundMiddleware<T>;
export declare function batch<T = any>(options: BatchingOptions<T>): BatchingInboundMiddleware<T>;
export declare function schemaRegistry(registry: SchemaRegistry): SchemaRegistryMiddleware<any>;
export declare function stringifyJson<T = any>(options?: JsonStringifyOptions): StringifyJsonOutboundMiddleware<T>;
export declare function logOutbound<T = any>(logger: {
    log: (message: string, context?: any) => void;
}): LogOutboundMiddleware<T>;
export declare function validateOutbound<T = any>(validator: (data: any) => Promise<boolean> | boolean): ValidateOutboundMiddleware<T>;
export declare function encrypt<T = any>(encryptionService: EncryptionService, fields?: string[]): EncryptOutboundMiddleware<T>;
export declare function transformOutbound<TIn = any, TOut = any>(transformer: (data: TIn) => Promise<TOut> | TOut): TransformOutboundMiddleware<TIn, TOut>;
export declare function throttle<T = any>(limiter: RateLimiter, options?: any): ThrottlingOutboundMiddleware<T>;
export declare function collectMetricsOutbound<T = any>(collector: any, options?: {
    prefix?: string;
}): MetricsOutboundMiddleware<T>;
export declare function traceOutbound<T = any>(tracer: any, options?: any): TracingOutboundMiddleware<T>;
export declare function correlationIdOutbound<T = any>(options?: CorrelationIdOptions): CorrelationIdOutboundMiddleware<T>;
export declare function dispatch<T = any>(dispatcher: MessageDispatcher<T>): DispatcherMiddleware<T>;
export declare function createDispatcher<T = any>(options?: MessageDispatcherOptions, handlers?: Record<string, MessageHandlerFn<T>>): MessageDispatcher<T>;