@burdenoff/be-sdk 2026.510.79

package/dist/index-Cq_xNjcv.d.ts

@@ -0,0 +1,602 @@
+import { S as ServiceLayer } from './layer-DDip18KY.js';
+import { E as EntityEventRbacMetadata, a as EntityEventType$1, G as GraphEventEmitter$1, N as NatsGraphEventEmitter, c as createGraphEventEmitter$1, g as getGraphEventEmitter, r as resetGraphEventEmitter } from './graph-emitter-Bk0FqD53.js';
+import { B as BurdenoffGraphQLClient } from './graphql-BAVrUgBF.js';
+import { S as SDKContext } from './index-CHbVw5M7.js';
+
+interface EventMessage$1<T = unknown> {
+    id: string;
+    subject: string;
+    data: T;
+    metadata: EventMetadata;
+    timestamp: string;
+    sequence?: number;
+}
+interface EventMetadata {
+    correlationId: string;
+    tenantId?: string;
+    workspaceId?: string;
+    userId?: string;
+    source?: string;
+    version?: string;
+    [key: string]: unknown;
+}
+interface AcknowledgeableEvent<T = unknown> extends EventMessage$1<T> {
+    ack(): Promise<void>;
+    nak(delay?: number): Promise<void>;
+    term(): Promise<void>;
+    isRedelivered(): boolean;
+    getDeliveryAttempt(): number;
+}
+type EventHandler<T = unknown> = (event: AcknowledgeableEvent<T>) => Promise<void>;
+interface StreamConfig {
+    name: string;
+    subjects: string[];
+    description?: string;
+    retention?: 'limits' | 'interest' | 'workqueue';
+    maxAge?: number;
+    maxMsgs?: number;
+    maxBytes?: number;
+    storage?: 'file' | 'memory';
+    replicas?: number;
+    maxConsumers?: number;
+    duplicateWindow?: number;
+}
+interface NATSConsumerOptions {
+    name: string;
+    stream: string;
+    filterSubject?: string;
+    deliverPolicy?: 'all' | 'last' | 'new' | 'byStartSequence' | 'byStartTime';
+    ackPolicy?: 'explicit' | 'all' | 'none';
+    ackWait?: number;
+    maxDeliver?: number;
+    maxAckPending?: number;
+}
+interface SubscriptionOptions {
+    stream?: string;
+    consumer?: string;
+    maxConcurrent?: number;
+    maxRetries?: number;
+    retryBackoff?: 'exponential' | 'linear' | 'fixed';
+    retryDelay?: number;
+    timeout?: number;
+    useLocking?: boolean;
+    lockTTL?: number;
+    ackPolicy?: 'explicit' | 'all' | 'none';
+    deliverPolicy?: 'all' | 'last' | 'new' | 'byStartSequence' | 'byStartTime';
+    maxDeliver?: number;
+    ackWait?: number;
+    maxAckPending?: number;
+    streamSubjects?: string[];
+    retention?: 'limits' | 'interest' | 'workqueue';
+    storage?: 'file' | 'memory';
+}
+
+declare enum QueueType {
+    NATS = "nats",
+    RABBITMQ = "rabbitmq",
+    KAFKA = "kafka",
+    SQS = "sqs"
+}
+interface BaseQueueConfig {
+    type: QueueType | string;
+    url: string;
+    user?: string;
+    password?: string;
+    token?: string;
+    maxReconnectAttempts?: number;
+    reconnectTimeWait?: number;
+    connectionTimeout?: number;
+    name?: string;
+}
+interface PublisherConfig extends BaseQueueConfig {
+    defaultTTL?: number;
+    enableDeduplication?: boolean;
+    defaultPriority?: 'low' | 'normal' | 'high';
+}
+interface ConsumerConfig extends Partial<BaseQueueConfig> {
+    stream: string;
+    consumer: string;
+    filterSubject?: string;
+    maxConcurrent?: number;
+    maxDeliver?: number;
+    ackWait?: number;
+    ackPolicy?: 'explicit' | 'all' | 'none';
+    deliverPolicy?: 'all' | 'last' | 'new' | 'byStartSequence' | 'byStartTime';
+    maxAckPending?: number;
+}
+interface EventQueueHealthCheckResult {
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    timestamp: string;
+    connected?: boolean;
+    latencyMs?: number;
+    details?: Record<string, unknown>;
+    error?: string;
+}
+interface QueueStatistics {
+    messagesPublished?: number;
+    messagesConsumed?: number;
+    messagesPending?: number;
+    queueSize?: number;
+    messagesFailed?: number;
+    activeConsumers?: number;
+    activePublishers?: number;
+    avgProcessingTimeMs?: number;
+    lastActivity?: string | null;
+    details?: Record<string, unknown>;
+}
+
+interface IEventQueue {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    healthCheck(): Promise<EventQueueHealthCheckResult>;
+    getStatistics(): Promise<QueueStatistics>;
+}
+
+interface ISubscription {
+    id: string;
+    subject: string;
+    unsubscribe(): Promise<void>;
+    isActive(): boolean;
+    getStats(): {
+        messagesReceived: number;
+        messagesProcessed: number;
+        messagesFailed: number;
+        lastActivity: string;
+    };
+}
+interface IEventConsumer extends IEventQueue {
+    ensureStream(config: StreamConfig): Promise<void>;
+    ensureConsumer(config: ConsumerConfig): Promise<void>;
+    subscribe<T = unknown>(options: {
+        subject: string;
+        handler: EventHandler<T>;
+        options?: SubscriptionOptions;
+    }): Promise<ISubscription>;
+    subscribeMultiple<T = unknown>(subjects: string[], handler: EventHandler<T>, options?: SubscriptionOptions): Promise<ISubscription[]>;
+    pull<T = unknown>(options: {
+        subject: string;
+        batch?: number;
+        timeout?: number;
+    }): Promise<AcknowledgeableEvent<T>[]>;
+    unsubscribeAll(): Promise<void>;
+    getSubscriptions(): ISubscription[];
+    processDLQ<T = unknown>(handler: EventHandler<T>): Promise<void>;
+    listSubjects?(stream?: string): Promise<string[]>;
+}
+
+interface PublishOptions {
+    messageId?: string;
+    priority?: 'low' | 'normal' | 'high';
+    ttl?: number;
+    delay?: number;
+    expectedStream?: string;
+    stream?: string;
+    streamSubjects?: string[];
+    retention?: 'limits' | 'interest' | 'workqueue';
+    storage?: 'file' | 'memory';
+}
+interface IEventPublisher extends IEventQueue {
+    ensureStream(config: StreamConfig): Promise<void>;
+    publish<T = unknown>(options: {
+        subject: string;
+        data: T;
+        metadata?: Partial<EventMetadata>;
+        options?: PublishOptions;
+    }): Promise<number | string>;
+    publishBatch<T = unknown>(events: Array<{
+        subject: string;
+        data: T;
+        metadata?: Partial<EventMetadata>;
+        options?: PublishOptions;
+    }>): Promise<Array<number | string>>;
+    publishWithAck<T = unknown, R = unknown>(options: {
+        subject: string;
+        data: T;
+        metadata?: Partial<EventMetadata>;
+        timeout?: number;
+    }): Promise<R>;
+}
+
+declare class EventQueueFactory {
+    static createPublisher(config: PublisherConfig): IEventPublisher;
+    static createConsumer(config: ConsumerConfig): IEventConsumer;
+    static createPublisherFromEnv(): IEventPublisher;
+    static createConsumerFromEnv(stream: string, consumer: string): IEventConsumer;
+    static createPublisherForLayer(layer: ServiceLayer, serviceName: string): IEventPublisher;
+    static createConsumerForLayer(layer: ServiceLayer, serviceName: string, stream: string, consumer: string): IEventConsumer;
+}
+
+declare class NatsEventPublisher implements IEventPublisher {
+    private config;
+    private connectionManager;
+    private publishCount;
+    private lastPublishTime;
+    constructor(config: PublisherConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    healthCheck(): Promise<EventQueueHealthCheckResult>;
+    getStatistics(): Promise<QueueStatistics>;
+    ensureStream(config: StreamConfig): Promise<void>;
+    private deriveStreamSubjects;
+    private deriveStreamName;
+    publish<T = unknown>(options: {
+        subject: string;
+        data: T;
+        metadata?: Partial<EventMetadata>;
+        options?: PublishOptions;
+    }): Promise<number | string>;
+    publishBatch<T = unknown>(events: Array<{
+        subject: string;
+        data: T;
+        metadata?: Partial<EventMetadata>;
+        options?: PublishOptions;
+    }>): Promise<Array<number | string>>;
+    publishWithAck<T = unknown, R = unknown>(options: {
+        subject: string;
+        data: T;
+        metadata?: Partial<EventMetadata>;
+        timeout?: number;
+    }): Promise<R>;
+    private mapRetentionPolicy;
+    private mapStorageType;
+    private generateMessageId;
+    private generateCorrelationId;
+}
+
+declare class NatsEventConsumer implements IEventConsumer {
+    private config;
+    private connectionManager;
+    private subscriptions;
+    constructor(config: ConsumerConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    healthCheck(): Promise<EventQueueHealthCheckResult>;
+    getStatistics(): Promise<QueueStatistics>;
+    ensureStream(config: StreamConfig): Promise<void>;
+    ensureConsumer(config: ConsumerConfig): Promise<void>;
+    private deriveStreamSubjects;
+    subscribe<T = unknown>(options: {
+        subject: string;
+        handler: EventHandler<T>;
+        options?: SubscriptionOptions;
+    }): Promise<ISubscription>;
+    subscribeMultiple<T = unknown>(subjects: string[], handler: EventHandler<T>, options?: SubscriptionOptions): Promise<ISubscription[]>;
+    pull<T = unknown>(options: {
+        subject: string;
+        batch?: number;
+        timeout?: number;
+    }): Promise<AcknowledgeableEvent<T>[]>;
+    unsubscribeAll(): Promise<void>;
+    getSubscriptions(): ISubscription[];
+    processDLQ<T = unknown>(_handler: EventHandler<T>): Promise<void>;
+    listSubjects(streamName?: string): Promise<string[]>;
+    private consumeMessages;
+    private wrapMessage;
+    private mapRetentionPolicy;
+    private mapStorageType;
+    private mapAckPolicy;
+    private mapDeliverPolicy;
+}
+
+type EntityEventType = 'entity.created' | 'entity.updated' | 'entity.deleted';
+interface GraphEventEmitter {
+    publishEntityEvent(eventType: EntityEventType, entity: {
+        id: string;
+        type: string;
+        data: Record<string, unknown>;
+    }, context: {
+        productName: string;
+        organizationId: string;
+        userId?: string;
+        workspaceId?: string;
+    }): Promise<void>;
+}
+declare class MemoryEventBus {
+    private handlers;
+    emit<T>(event: string, data: T): void;
+    on<T>(event: string, handler: EventHandler<T>): void;
+    off<T>(event: string, handler: EventHandler<T>): void;
+    private matchesPattern;
+    clear(): void;
+}
+declare class MemoryEventQueue implements GraphEventEmitter {
+    private queue;
+    private processing;
+    private handlers;
+    private maxRetries;
+    private retryDelay;
+    constructor(options?: {
+        maxRetries?: number;
+        retryDelay?: number;
+    });
+    publishEntityEvent(eventType: EntityEventType, entity: {
+        id: string;
+        type: string;
+        data: Record<string, unknown>;
+    }, context: {
+        productName: string;
+        organizationId: string;
+        userId?: string;
+        workspaceId?: string;
+    }): Promise<void>;
+    enqueue<T>(subject: string, data: T, metadata?: Record<string, unknown>): string;
+    registerHandler<T>(subject: string, handler: EventHandler<T>): void;
+    private processQueue;
+    get length(): number;
+    clear(): void;
+    publish<T>(subject: string, data: T, metadata?: Record<string, unknown>): Promise<void>;
+    close(): Promise<void>;
+}
+declare class MemoryEventPublisher implements IEventPublisher {
+    private queue;
+    private _connected;
+    private publishCount;
+    constructor();
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    ensureStream(): Promise<void>;
+    publish<T = unknown>(options: {
+        subject: string;
+        data: T;
+        metadata?: Record<string, unknown>;
+        options?: PublishOptions;
+    }): Promise<string>;
+    publishBatch<T = unknown>(events: Array<{
+        subject: string;
+        data: T;
+        metadata?: Record<string, unknown>;
+        options?: PublishOptions;
+    }>): Promise<string[]>;
+    publishWithAck<T = unknown, R = unknown>(options: {
+        subject: string;
+        data: T;
+        metadata?: Partial<EventMetadata>;
+        timeout?: number;
+    }): Promise<R>;
+    healthCheck(): Promise<EventQueueHealthCheckResult>;
+    getStatistics(): Promise<QueueStatistics>;
+    getQueue(): MemoryEventQueue;
+}
+declare class MemoryEventConsumer implements IEventConsumer {
+    private streamName;
+    private consumerName;
+    private queue;
+    private bus;
+    private _connected;
+    private _subscriptions;
+    private consumeCount;
+    private subIdCounter;
+    constructor(streamName: string, consumerName: string);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    ensureStream(): Promise<void>;
+    ensureConsumer(): Promise<void>;
+    subscribe<T = unknown>(options: {
+        subject: string;
+        handler: EventHandler<T>;
+        queueGroup?: string;
+    }): Promise<ISubscription>;
+    subscribeMultiple<T = unknown>(subjects: string[], handler: EventHandler<T>): Promise<ISubscription[]>;
+    pull<T = unknown>(): Promise<AcknowledgeableEvent<T>[]>;
+    unsubscribeAll(): Promise<void>;
+    getSubscriptions(): ISubscription[];
+    processDLQ<T = unknown>(_handler: EventHandler<T>): Promise<void>;
+    healthCheck(): Promise<EventQueueHealthCheckResult>;
+    getStatistics(): Promise<QueueStatistics>;
+    getBus(): MemoryEventBus;
+    getQueue(): MemoryEventQueue;
+}
+declare function createMemoryPublisher(): IEventPublisher;
+declare function createMemoryConsumer(stream: string, consumer: string): IEventConsumer;
+declare function createGraphEventEmitter(): GraphEventEmitter;
+
+interface ModuleEventPayload {
+    id: string;
+    type: string;
+    action: 'created' | 'updated' | 'deleted' | 'assigned' | 'removed' | string;
+    data: Record<string, unknown>;
+    metadata: {
+        tenantId?: string;
+        workspaceId?: string;
+        userId: string;
+        timestamp: string;
+        productSource: string;
+        correlationId?: string;
+    };
+}
+interface BulkEventPayload {
+    items: Array<{
+        id: string;
+        data: Record<string, unknown>;
+    }>;
+    metadata: {
+        tenantId?: string;
+        workspaceId?: string;
+        userId: string;
+        timestamp: string;
+        productSource: string;
+    };
+}
+interface ModuleEventsConfig {
+    moduleName: string;
+    subjectPrefix?: string;
+    loggerLabel?: string;
+}
+declare class ModuleEventsService {
+    private readonly productSource;
+    private readonly subjectPrefix;
+    private readonly loggerLabel;
+    private publisher;
+    private connected;
+    private connecting;
+    constructor(config: ModuleEventsConfig);
+    private ensureConnected;
+    private publish;
+    private buildPayload;
+    private buildSubject;
+    publishCreated(entityType: string, id: string, data: Record<string, unknown>, userId: string, tenantId?: string, workspaceId?: string): Promise<void>;
+    publishUpdated(entityType: string, id: string, data: Record<string, unknown>, userId: string, tenantId?: string, workspaceId?: string): Promise<void>;
+    publishDeleted(entityType: string, id: string, userId: string, tenantId?: string, workspaceId?: string): Promise<void>;
+    publishCustom(entityType: string, action: string, id: string, data: Record<string, unknown>, userId: string, tenantId?: string, workspaceId?: string): Promise<void>;
+    publishBulkCreated(_entityType: string, items: Array<{
+        id: string;
+        data: Record<string, unknown>;
+    }>, userId: string, tenantId?: string, workspaceId?: string): Promise<void>;
+    close(): Promise<void>;
+    healthCheck(): Promise<{
+        healthy: boolean;
+        message: string;
+    }>;
+}
+declare function createModuleEventsService(config: ModuleEventsConfig): ModuleEventsService;
+
+declare enum EventPriority {
+    LOW = "low",
+    NORMAL = "normal",
+    HIGH = "high",
+    CRITICAL = "critical"
+}
+interface PublishEventOptions {
+    subject: string;
+    data: Record<string, unknown>;
+    priority?: EventPriority;
+    metadata?: Record<string, unknown>;
+    delay?: number;
+    messageId?: string;
+    workspaceId?: string;
+    organizationId?: string;
+}
+interface SubscribeOptions {
+    subject: string;
+    queueGroup?: string;
+    durableName?: string;
+    startPosition?: 'first' | 'last' | 'new';
+    ackMode?: 'explicit' | 'auto';
+    maxDeliver?: number;
+    ackWait?: number;
+}
+interface EventMessage {
+    id: string;
+    subject: string;
+    data: Record<string, unknown>;
+    priority: EventPriority;
+    metadata?: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+    publishedAt: string;
+    publishedBy?: string;
+}
+interface PublishResult {
+    messageId: string;
+    subject: string;
+    sequence: number;
+    timestamp: string;
+}
+interface StreamInfo {
+    name: string;
+    subjects: string[];
+    messageCount: number;
+    byteCount: number;
+    firstSequence: number;
+    lastSequence: number;
+    consumerCount: number;
+}
+declare class EventsModule {
+    private client;
+    private context;
+    constructor(client: BurdenoffGraphQLClient, context: SDKContext);
+    createStream(name: string, subjects: string[], options?: {
+        maxMessages?: number;
+        maxBytes?: number;
+        maxAge?: number;
+        storageType?: 'file' | 'memory';
+        replicas?: number;
+    }): Promise<StreamInfo>;
+    getStreamInfo(name: string): Promise<StreamInfo>;
+    deleteStream(name: string): Promise<boolean>;
+    purgeStream(name: string, options?: {
+        subject?: string;
+        sequence?: number;
+    }): Promise<number>;
+    createConsumer(streamName: string, consumerName: string, options: SubscribeOptions): Promise<{
+        name: string;
+        pending: number;
+    }>;
+    deleteConsumer(streamName: string, consumerName: string): Promise<boolean>;
+    ackMessage(streamName: string, consumerName: string, sequence: number): Promise<boolean>;
+    nakMessage(streamName: string, consumerName: string, sequence: number): Promise<boolean>;
+    getConsumerInfo(streamName: string, consumerName: string): Promise<{
+        name: string;
+        pending: number;
+        redelivered: number;
+        numAckPending: number;
+    }>;
+}
+
+declare function createPublisher(): IEventPublisher;
+declare function createConsumer(stream: string, consumer: string): IEventConsumer;
+
+type index_AcknowledgeableEvent<T = unknown> = AcknowledgeableEvent<T>;
+type index_BaseQueueConfig = BaseQueueConfig;
+type index_BulkEventPayload = BulkEventPayload;
+type index_ConsumerConfig = ConsumerConfig;
+declare const index_EntityEventRbacMetadata: typeof EntityEventRbacMetadata;
+type index_EventHandler<T = unknown> = EventHandler<T>;
+type index_EventMetadata = EventMetadata;
+type index_EventPriority = EventPriority;
+declare const index_EventPriority: typeof EventPriority;
+type index_EventQueueFactory = EventQueueFactory;
+declare const index_EventQueueFactory: typeof EventQueueFactory;
+type index_EventQueueHealthCheckResult = EventQueueHealthCheckResult;
+type index_EventsModule = EventsModule;
+declare const index_EventsModule: typeof EventsModule;
+type index_IEventConsumer = IEventConsumer;
+type index_IEventPublisher = IEventPublisher;
+type index_IEventQueue = IEventQueue;
+type index_ISubscription = ISubscription;
+type index_MemoryEventBus = MemoryEventBus;
+declare const index_MemoryEventBus: typeof MemoryEventBus;
+type index_MemoryEventConsumer = MemoryEventConsumer;
+declare const index_MemoryEventConsumer: typeof MemoryEventConsumer;
+type index_MemoryEventPublisher = MemoryEventPublisher;
+declare const index_MemoryEventPublisher: typeof MemoryEventPublisher;
+type index_MemoryEventQueue = MemoryEventQueue;
+declare const index_MemoryEventQueue: typeof MemoryEventQueue;
+type index_ModuleEventPayload = ModuleEventPayload;
+type index_ModuleEventsConfig = ModuleEventsConfig;
+type index_ModuleEventsService = ModuleEventsService;
+declare const index_ModuleEventsService: typeof ModuleEventsService;
+type index_NATSConsumerOptions = NATSConsumerOptions;
+type index_NatsEventConsumer = NatsEventConsumer;
+declare const index_NatsEventConsumer: typeof NatsEventConsumer;
+type index_NatsEventPublisher = NatsEventPublisher;
+declare const index_NatsEventPublisher: typeof NatsEventPublisher;
+declare const index_NatsGraphEventEmitter: typeof NatsGraphEventEmitter;
+type index_PublishEventOptions = PublishEventOptions;
+type index_PublishOptions = PublishOptions;
+type index_PublishResult = PublishResult;
+type index_PublisherConfig = PublisherConfig;
+type index_QueueStatistics = QueueStatistics;
+type index_QueueType = QueueType;
+declare const index_QueueType: typeof QueueType;
+type index_StreamConfig = StreamConfig;
+type index_StreamInfo = StreamInfo;
+type index_SubscribeOptions = SubscribeOptions;
+type index_SubscriptionOptions = SubscriptionOptions;
+declare const index_createConsumer: typeof createConsumer;
+declare const index_createMemoryConsumer: typeof createMemoryConsumer;
+declare const index_createMemoryPublisher: typeof createMemoryPublisher;
+declare const index_createModuleEventsService: typeof createModuleEventsService;
+declare const index_createPublisher: typeof createPublisher;
+declare const index_getGraphEventEmitter: typeof getGraphEventEmitter;
+declare const index_resetGraphEventEmitter: typeof resetGraphEventEmitter;
+declare namespace index {
+  export { type index_AcknowledgeableEvent as AcknowledgeableEvent, type index_BaseQueueConfig as BaseQueueConfig, type index_BulkEventPayload as BulkEventPayload, type index_ConsumerConfig as ConsumerConfig, index_EntityEventRbacMetadata as EntityEventRbacMetadata, EntityEventType$1 as EntityEventType, type index_EventHandler as EventHandler, type EventMessage$1 as EventMessage, type index_EventMetadata as EventMetadata, index_EventPriority as EventPriority, index_EventQueueFactory as EventQueueFactory, type index_EventQueueHealthCheckResult as EventQueueHealthCheckResult, index_EventsModule as EventsModule, GraphEventEmitter$1 as GraphEventEmitter, type EventMessage as GraphQLEventMessage, type EventQueueHealthCheckResult as HealthCheckResult, type index_IEventConsumer as IEventConsumer, type index_IEventPublisher as IEventPublisher, type index_IEventQueue as IEventQueue, type index_ISubscription as ISubscription, index_MemoryEventBus as MemoryEventBus, index_MemoryEventConsumer as MemoryEventConsumer, index_MemoryEventPublisher as MemoryEventPublisher, index_MemoryEventQueue as MemoryEventQueue, type index_ModuleEventPayload as ModuleEventPayload, type index_ModuleEventsConfig as ModuleEventsConfig, index_ModuleEventsService as ModuleEventsService, type index_NATSConsumerOptions as NATSConsumerOptions, index_NatsEventConsumer as NatsEventConsumer, index_NatsEventPublisher as NatsEventPublisher, index_NatsGraphEventEmitter as NatsGraphEventEmitter, type index_PublishEventOptions as PublishEventOptions, type index_PublishOptions as PublishOptions, type index_PublishResult as PublishResult, type index_PublisherConfig as PublisherConfig, type index_QueueStatistics as QueueStatistics, index_QueueType as QueueType, type index_StreamConfig as StreamConfig, type index_StreamInfo as StreamInfo, type index_SubscribeOptions as SubscribeOptions, type index_SubscriptionOptions as SubscriptionOptions, index_createConsumer as createConsumer, createGraphEventEmitter$1 as createGraphEventEmitter, index_createMemoryConsumer as createMemoryConsumer, createGraphEventEmitter as createMemoryGraphEventEmitter, index_createMemoryPublisher as createMemoryPublisher, index_createModuleEventsService as createModuleEventsService, index_createPublisher as createPublisher, index_getGraphEventEmitter as getGraphEventEmitter, index_resetGraphEventEmitter as resetGraphEventEmitter };
+}
+
+export { type AcknowledgeableEvent as A, type BaseQueueConfig as B, type ConsumerConfig as C, type SubscriptionOptions as D, EventsModule as E, createConsumer as F, createMemoryConsumer as G, createGraphEventEmitter as H, type IEventPublisher as I, createMemoryPublisher as J, createModuleEventsService as K, createPublisher as L, MemoryEventBus as M, type NATSConsumerOptions as N, type PublishEventOptions as P, type QueueStatistics as Q, type StreamConfig as S, type BulkEventPayload as a, type EventHandler as b, type EventMessage$1 as c, type EventMetadata as d, EventPriority as e, EventQueueFactory as f, type EventQueueHealthCheckResult as g, type EventMessage as h, index as i, type IEventConsumer as j, type IEventQueue as k, type ISubscription as l, MemoryEventConsumer as m, MemoryEventPublisher as n, MemoryEventQueue as o, type ModuleEventPayload as p, type ModuleEventsConfig as q, ModuleEventsService as r, NatsEventConsumer as s, NatsEventPublisher as t, type PublishOptions as u, type PublishResult as v, type PublisherConfig as w, QueueType as x, type StreamInfo as y, type SubscribeOptions as z };

package/dist/index-CrQgidpx.d.ts

@@ -0,0 +1,77 @@
+import { S as SDKContext } from './index-CHbVw5M7.js';
+
+declare function redactSensitiveFields<T>(value: T): T;
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LogMeta {
+    [key: string]: unknown;
+    context?: SDKContext;
+    timestamp?: string;
+    correlationId?: string;
+}
+interface LoggerConfig {
+    level: LogLevel;
+    console: boolean;
+    transport?: LoggerTransport;
+}
+interface LoggerTransport {
+    log(level: string, message: string, meta?: Record<string, unknown>): void;
+}
+declare class Logger {
+    private level;
+    private enableConsole;
+    private context?;
+    private transport?;
+    constructor(config?: LoggerConfig);
+    setContext(context: SDKContext): void;
+    getContext(): SDKContext | undefined;
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    log(message: string, ...args: unknown[]): void;
+    trace(message: string, ...args: unknown[]): void;
+    private parseArgs;
+    private logInternal;
+    private logToConsole;
+    private shouldLog;
+    createChild(childContext: Partial<SDKContext>): Logger;
+    child(context: string): Logger;
+    withMetadata(metadata: Record<string, unknown>): {
+        log: (message: string, ...args: unknown[]) => void;
+        error: (message: string, ...args: unknown[]) => void;
+        warn: (message: string, ...args: unknown[]) => void;
+        info: (message: string, ...args: unknown[]) => void;
+        debug: (message: string, ...args: unknown[]) => void;
+        trace: (message: string, ...args: unknown[]) => void;
+    };
+    close(): Promise<void>;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+    setConsoleEnabled(enabled: boolean): void;
+    isConsoleEnabled(): boolean;
+    addTransport(transport: LoggerTransport): void;
+    removeTransport(): void;
+}
+declare const logger: Logger;
+declare const log: (message: string, ...args: unknown[]) => void;
+declare const warn: (message: string, ...args: unknown[]) => void;
+declare const error: (message: string, ...args: unknown[]) => void;
+declare const debug: (message: string, ...args: unknown[]) => void;
+
+type index_LogLevel = LogLevel;
+type index_LogMeta = LogMeta;
+type index_Logger = Logger;
+declare const index_Logger: typeof Logger;
+type index_LoggerConfig = LoggerConfig;
+type index_LoggerTransport = LoggerTransport;
+declare const index_debug: typeof debug;
+declare const index_error: typeof error;
+declare const index_log: typeof log;
+declare const index_logger: typeof logger;
+declare const index_redactSensitiveFields: typeof redactSensitiveFields;
+declare const index_warn: typeof warn;
+declare namespace index {
+  export { type index_LogLevel as LogLevel, type index_LogMeta as LogMeta, index_Logger as Logger, type index_LoggerConfig as LoggerConfig, type index_LoggerTransport as LoggerTransport, index_debug as debug, index_error as error, index_log as log, index_logger as logger, index_redactSensitiveFields as redactSensitiveFields, index_warn as warn };
+}
+
+export { Logger as L, type LogLevel as a, type LogMeta as b, type LoggerConfig as c, type LoggerTransport as d, debug as e, error as f, log as g, index as i, logger as l, redactSensitiveFields as r, warn as w };