import { EventAttributes, EventSubscriber, EventTrackingOptions, FunnelStatus, OutcomeStatus } from "autotel/event-subscriber";

//#region src/middleware.d.ts
/** Normalized event for middleware processing */
type EventsEvent = {
  type: 'event';
  name: string;
  attributes?: EventAttributes;
  options?: EventTrackingOptions;
} | {
  type: 'funnel';
  funnel: string;
  step: FunnelStatus;
  attributes?: EventAttributes;
  options?: EventTrackingOptions;
} | {
  type: 'outcome';
  operation: string;
  outcome: OutcomeStatus;
  attributes?: EventAttributes;
  options?: EventTrackingOptions;
} | {
  type: 'value';
  name: string;
  value: number;
  attributes?: EventAttributes;
  options?: EventTrackingOptions;
};
type SendEventRecord = {
  subscriberName: string;
  eventType: EventsEvent['type'];
  eventName: string;
  status: 'success' | 'error';
  durationMs: number;
  startedAt: Date;
  endedAt: Date;
  error?: {
    name: string;
    message: string;
    code?: string;
  };
};
type SendEventSink = {
  write(event: SendEventRecord): Promise<void>;
};
type RateLimitAlgorithm = 'fixed' | 'sliding';
type RateLimitRecord = {
  count: number;
  resetAtMs: number;
};
type RateLimitStore = {
  record(key: string, windowMs: number, algorithm: RateLimitAlgorithm): Promise<RateLimitRecord>;
};
type IdempotencyStore<TResult = unknown> = {
  get(key: string): Promise<TResult | null>;
  set(key: string, result: TResult, ttlMs: number): Promise<void>;
};
type SubscriberMiddleware<TCtxIn = Record<string, unknown>, TCtxOut = TCtxIn> = (params: {
  event: EventsEvent;
  ctx: TCtxIn;
  subscriber: Pick<EventSubscriber, 'name' | 'version'>;
  next: (update?: {
    event?: EventsEvent;
    ctxPatch?: Partial<TCtxOut>;
  }) => Promise<void>;
}) => Promise<void>;
/** Type-safe middleware factory helper */
declare const createMiddleware: <TCtxIn = Record<string, unknown>, TCtxOut = TCtxIn>(fn: SubscriberMiddleware<TCtxIn, TCtxOut>) => SubscriberMiddleware<TCtxIn, TCtxOut>;
/**
 * Apply middleware to a subscriber
 *
 * Chains middleware in order, each can transform events or context before passing to next
 *
 * @example
 * ```typescript
 * const enriched = applyMiddleware(
 *   subscriber,
 *   [enrichmentMiddleware(event => ({ ...event, timestamp: Date.now() }))]
 * )
 * ```
 */
declare function applyMiddleware<TCtx = Record<string, unknown>>(subscriber: EventSubscriber, middlewares: Array<SubscriberMiddleware<TCtx, TCtx>>, options?: {
  initialContext?: () => TCtx;
}): EventSubscriber;
/**
 * Retry middleware with exponential backoff
 *
 * Automatically retries failed events with exponential backoff delay
 */
declare function retryMiddleware(options: {
  maxRetries?: number;
  delayMs?: number;
  onRetry?: (attempt: number, error: Error, event: EventsEvent) => void;
}): SubscriberMiddleware;
/**
 * Sampling middleware to reduce event volume
 *
 * Only passes through a percentage of events based on the rate (0.0 to 1.0)
 */
declare function samplingMiddleware(rate: number): SubscriberMiddleware;
/**
 * Enrichment middleware to add or modify event data
 *
 * Apply a transformation function to each event before sending
 */
declare function enrichmentMiddleware(enricher: (event: EventsEvent) => EventsEvent): SubscriberMiddleware;
/**
 * Logging middleware for debugging event flow
 *
 * Logs event type and name (optionally full event) to console
 */
declare function loggingMiddleware(options?: {
  prefix?: string;
  logAttributes?: boolean;
}): SubscriberMiddleware;
/**
 * Filter middleware to selectively process events
 *
 * Only forwards events that match the predicate
 */
declare function filterMiddleware(predicate: (event: EventsEvent) => boolean): SubscriberMiddleware;
/**
 * Transform middleware to modify event structure
 *
 * Similar to enrichment but replaces entire event
 */
declare function transformMiddleware(transformer: (event: EventsEvent) => EventsEvent): SubscriberMiddleware;
/**
 * Batching middleware to group events for bulk sending
 *
 * Collects events into batches before forwarding
 */
declare function batchingMiddleware(options: {
  batchSize?: number;
  flushInterval?: number;
}): SubscriberMiddleware;
/**
 * Rate limit middleware to control event sending rate
 *
 * Enforces a maximum rate of events sent per second
 */
declare function rateLimitMiddleware(options: {
  requestsPerSecond: number;
}): SubscriberMiddleware;
/**
 * Circuit breaker middleware for fault tolerance
 *
 * Prevents cascading failures by stopping requests when error rate exceeds threshold
 */
declare function circuitBreakerMiddleware(options: {
  failureThreshold?: number;
  timeout?: number;
  onOpen?: () => void;
  onClose?: () => void;
}): SubscriberMiddleware;
/**
 * Timeout middleware to prevent hanging requests
 *
 * Rejects the event if processing exceeds the specified timeout
 */
declare function timeoutMiddleware(options: {
  timeoutMs: number;
}): SubscriberMiddleware;
/**
 * Create an idempotency store with custom get/set operations
 *
 * Used with withIdempotency middleware to prevent duplicate event processing
 */
declare function createIdempotencyStore<TResult = unknown>(options: {
  get: (key: string) => Promise<TResult | null>;
  set: (key: string, result: TResult, ttlMs: number) => Promise<void>;
}): IdempotencyStore<TResult>;
/**
 * In-memory idempotency store
 *
 * Useful for testing or single-process applications
 */
declare function inMemoryIdempotencyStore<TResult = unknown>(): IdempotencyStore<TResult>;
/**
 * Create a rate limit store with custom record operation
 *
 * Used with withRateLimit middleware for distributed rate limiting
 */
declare function createRateLimitStore(options: {
  record: (key: string, windowMs: number, algorithm: RateLimitAlgorithm) => Promise<RateLimitRecord>;
}): RateLimitStore;
/**
 * In-memory rate limit store
 *
 * Supports fixed and sliding window algorithms
 */
declare function inMemoryRateLimitStore(): RateLimitStore;
/**
 * Idempotency middleware to prevent duplicate processing
 *
 * Skips processing if the same event (by key) was processed within TTL
 *
 * @example
 * ```typescript
 * const middleware = withIdempotency({
 *   store: inMemoryIdempotencyStore(),
 *   key: event => event.name,
 *   ttlMs: 60000
 * })
 * ```
 */
declare function withIdempotency(options: {
  store: IdempotencyStore<boolean>;
  key: string | ((event: EventsEvent) => string);
  ttlMs: number;
}): SubscriberMiddleware;
/**
 * Rate limiting middleware with store-based tracking
 *
 * Enforces rate limits across distributed systems using a store backend
 *
 * @example
 * ```typescript
 * const middleware = withRateLimit({
 *   store: inMemoryRateLimitStore(),
 *   key: event => 'global',
 *   max: 1000,
 *   windowMs: 60000
 * })
 * ```
 */
declare function withRateLimit(options: {
  store: RateLimitStore;
  key: string | ((event: EventsEvent) => string);
  max: number;
  windowMs: number;
  algorithm?: RateLimitAlgorithm;
}): SubscriberMiddleware;
/**
 * Event logger middleware for observability
 *
 * Writes event records to a sink for monitoring, audit logging, or analytics
 *
 * @example
 * ```typescript
 * const middleware = withEventLogger({
 *   sink: {
 *     write: async (record) => {
 *       await db.eventLogs.insert(record)
 *     }
 *   }
 * })
 * ```
 */
declare function withEventLogger(options: {
  sink: SendEventSink;
}): SubscriberMiddleware;
//#endregion
export { EventsEvent, IdempotencyStore, RateLimitAlgorithm, RateLimitRecord, RateLimitStore, SendEventRecord, SendEventSink, SubscriberMiddleware, applyMiddleware, batchingMiddleware, circuitBreakerMiddleware, createIdempotencyStore, createMiddleware, createRateLimitStore, enrichmentMiddleware, filterMiddleware, inMemoryIdempotencyStore, inMemoryRateLimitStore, loggingMiddleware, rateLimitMiddleware, retryMiddleware, samplingMiddleware, timeoutMiddleware, transformMiddleware, withEventLogger, withIdempotency, withRateLimit };
//# sourceMappingURL=middleware.d.ts.map