import { ProviderClient, ProviderTransaction } from './provider';
/** Connection Options for NATS */
export interface NatsConnectionOptions {
    servers?: string | string[];
    timeout?: number;
    name?: string;
    user?: string;
    pass?: string;
    token?: string;
}
/** Additional JetStream Options */
export interface NatsJetStreamOptions {
    domain?: string;
    prefix?: string;
    timeout?: number;
}
/** Combined Stream Options */
export interface NatsStreamOptions extends NatsConnectionOptions {
    jetstream?: NatsJetStreamOptions;
}
/** Type for NATS Client Options */
export type NatsClientOptions = NatsStreamOptions;
/** Interface representing a NATS Connection */
export interface NatsConnection extends ProviderClient {
    jetstream(options?: NatsJetStreamOptions): NatsJetStreamClient;
    jetstreamManager(options?: NatsJetStreamOptions): Promise<NatsJetStreamManager>;
    close(): Promise<void>;
}
export interface NatsSubscriptionType {
    /**
     * Unsubscribes from the subject, stopping message delivery.
     */
    unsubscribe(): void;
    /**
     * Drains the subscription, ensuring all pending messages are delivered
     * before unsubscribing.
     * @returns Promise<void>
     */
    drain(): Promise<void>;
    /**
     * The subject this subscription is listening to.
     */
    subject: string;
    /**
     * The queue group this subscription belongs to, if any.
     */
    queue?: string;
    /**
     * Indicates whether this subscription is currently active.
     */
    isClosed: boolean;
    /**
     * Async iterator for processing incoming messages.
     */
    [Symbol.asyncIterator](): AsyncIterableIterator<NatsMessageType>;
}
/** Type representing the NATS Connection */
export type NatsClientType = NatsConnection;
/** Type representing the NATS Connection Function */
export type NatsClassType = (options: NatsClientOptions) => Promise<NatsConnection>;
/** Interface for JetStream Client */
export interface NatsJetStreamClient {
    publish(subject: string, data: Uint8Array, options?: NatsPublishOptions): Promise<NatsPubAck>;
    consumers: any;
    jetstreamManager(): Promise<NatsJetStreamManager>;
}
/** **NatsJetStreamType** */
export type NatsJetStreamType = NatsJetStreamClient;
/** Interface for JetStream Manager */
export interface NatsJetStreamManager {
    streams: NatsStreamManager;
    consumers: NatsConsumerManager;
}
/** Interface for Stream Manager */
export interface NatsStreamManager {
    add(config: Partial<NatsStreamConfig>): Promise<void>;
    delete(stream: string): Promise<boolean>;
    info(stream: string): Promise<NatsStreamInfo>;
    list(): AsyncIterable<NatsStreamInfo>;
    deleteMessage(stream: string, seq: number): Promise<boolean>;
    update(stream: string, config: NatsStreamConfig): Promise<void>;
}
/** Interface for Consumer Manager */
export interface NatsConsumerManager {
    add(stream: string, config: NatsConsumerConfig): Promise<void>;
    delete(stream: string, consumer: string): Promise<boolean>;
    info(stream: string, consumer: string): Promise<NatsConsumerInfo>;
    list(stream: string): AsyncIterable<NatsConsumerInfo>;
}
/** Stream Configuration */
export interface NatsStreamConfig {
    name: string;
    subjects?: string[];
    retention?: NatsRetentionPolicy;
    storage?: NatsStorageType;
    num_replicas?: number;
    max_msgs?: number;
    max_age?: number;
}
/** Consumer Configuration */
export interface NatsConsumerConfig {
    durable_name?: string;
    deliver_subject?: string;
    deliver_group?: string;
    ack_policy?: NatsAckPolicy;
    ack_wait?: number;
    max_deliver?: number;
}
/** Interface for JetStream Message */
export interface NatsJsMsg {
    seq: number;
    ack(): void;
    nak(): void;
    term(): void;
    inProgress(): void;
    working(): void;
    data: Uint8Array;
    subject: string;
    headers?: {
        [key: string]: string;
    };
    info: NatsDeliveryInfo;
}
/** Delivery Info for a Message */
export interface NatsDeliveryInfo {
    stream: string;
    consumer: string;
    redeliveryCount: number;
    timestampNanos: number;
    pending: number;
}
/** Interface for Publish Acknowledgment */
export interface NatsPubAck extends ProviderTransaction {
    stream: string;
    seq: number;
    duplicate: boolean;
}
/** Interface for Stream Information */
export interface NatsStreamInfo {
    config: NatsStreamConfig;
    state: NatsStreamState;
}
/** Stream State Information */
export interface NatsStreamState {
    messages: number;
    bytes: number;
    first_seq: number;
    last_seq: number;
}
/** Interface for Consumer Information */
export interface NatsConsumerInfo {
    name: string;
    stream_name: string;
    config: NatsConsumerConfig;
    delivered: NatsSequenceInfo;
    ack_floor: NatsSequenceInfo;
    num_ack_pending: number;
    num_redelivered: number;
    num_waiting: number;
    num_pending: number;
}
/** Sequence Information */
export interface NatsSequenceInfo {
    consumer_seq: number;
    stream_seq: number;
}
/** Publish Options */
export interface NatsPublishOptions {
    msgID?: string;
    expect?: NatsMsgExpect;
    headers?: {
        [key: string]: string;
    };
}
/** Message Expectation */
export interface NatsMsgExpect {
    lastMsgID?: string;
    streamName?: string;
    lastSequence?: number;
}
/** NATS Error */
export interface NatsError extends Error {
    code?: string;
}
/** Retention Policies */
export type NatsRetentionPolicy = 'limits' | 'interest' | 'workqueue';
/** Storage Types */
export type NatsStorageType = 'file' | 'memory';
/** Acknowledgment Policies */
export type NatsAckPolicy = 'none' | 'all' | 'explicit';
/** Types for Specific Policies */
export type NatsRetentionPolicyWorkqueueType = 'workqueue';
export type NatsStorageMemoryType = 'memory';
export type NatsAckPolicyExplicitType = 'explicit';
/** NATS Message Type */
export type NatsMessageType = NatsJsMsg;
/** NATS Transaction Interface */
export interface NatsTransaction {
    msgs: NatsMessageType[];
    pubAcks: NatsPubAck[];
    execute(): Promise<void>;
    rollback(): Promise<void>;
}
/** NATS Client Error Type */
export type NatsErrorType = NatsError;
/** NATS Stream Info Type */
export type NatsStreamInfoType = NatsStreamInfo;
/** NATS Stream Config Type */
export type NatsStreamConfigType = Partial<NatsStreamConfig>;
/** NATS Consumer Config Type */
export type NatsConsumerConfigType = Partial<NatsConsumerConfig>;
/** NATS Publish Ack Type */
export type NatsPubAckType = NatsPubAck;