import { S as Selector, k as StorageDeleteEvent, l as SerializedStorageDeleteEvent, R as ResourceTransactionEvent, h as SerializedResourceTransactionEvent, m as ResourceSetContentsEvent, n as SerializedResourceSetContentsEvent, o as Emitter } from './hive.DlaRxYsk.js';
import { Transaction, TransactionResult } from '../sdk/transaction.js';
import z from 'zod';

//#region src/protocol.d.ts
type Protocol = {
  Handshake: {
    request: {
      token?: string | null | undefined;
    };
  };
  Join: {
    request: {
      token?: string | null | undefined;
      resource: Selector['key'];
    };
  };
  Messages: {
    [StorageDeleteEvent.type]: SerializedStorageDeleteEvent;
    [ResourceTransactionEvent.type]: SerializedResourceTransactionEvent;
    [ResourceSetContentsEvent.type]: SerializedResourceSetContentsEvent;
  };
  Requests: {
    [ResourceTransactionEvent.type]: {
      request: {
        resource: Selector['key'];
        transaction: Transaction;
        trace: string;
      };
      response: {
        resource: Selector['key'];
        results: TransactionResult<[]>;
      };
    };
  };
};

declare const PulseMessageSchema: z.ZodObject<{
  id: z.ZodString;
  ts: z.ZodNumber;
  type: z.ZodLiteral<"pulse">;
}, z.core.$strip>;
type PulseMessage = z.output<typeof PulseMessageSchema>;
declare const EnvelopeMessageSchema: z.ZodObject<{
  id: z.ZodString;
  ts: z.ZodNumber;
  type: z.ZodLiteral<"envelope">;
  channel: z.ZodNullable<z.ZodString>;
  key: z.ZodNullable<z.ZodString>;
  data: z.ZodAny;
}, z.core.$strip>;
type EnvelopeMessage = z.output<typeof EnvelopeMessageSchema>;
declare const RequestMessageSchema: z.ZodObject<{
  id: z.ZodString;
  ts: z.ZodNumber;
  type: z.ZodLiteral<"request">;
  channel: z.ZodNullable<z.ZodString>;
  key: z.ZodNullable<z.ZodString>;
  req: z.ZodUUID;
  data: z.ZodAny;
}, z.core.$strip>;
type RequestMessage = z.output<typeof RequestMessageSchema>;
declare const ResponseMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
  id: z.ZodString;
  ts: z.ZodNumber;
  type: z.ZodLiteral<"response">;
  channel: z.ZodNullable<z.ZodString>;
  req: z.ZodUUID;
  data: z.ZodAny;
  error: z.ZodNull;
}, z.core.$strip>, z.ZodObject<{
  id: z.ZodString;
  ts: z.ZodNumber;
  type: z.ZodLiteral<"response">;
  channel: z.ZodNullable<z.ZodString>;
  req: z.ZodUUID;
  data: z.ZodNull;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>]>;
type ResponseMessage = z.output<typeof ResponseMessageSchema>;
//#endregion
//#region src/utils/listener.d.ts
type ListenerFor<T extends Record<string, unknown>, K extends keyof T = keyof T> = {
  bivarianceHack(payload: T[K]): void;
}["bivarianceHack"];
type Listener<T extends Record<string, unknown>, K extends keyof T = keyof T> = ListenerFor<T, K>;

//#region src/server/messages.d.ts

declare const HandshakeResponseMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
  id: z.ZodString;
  ts: z.ZodNumber;
  type: z.ZodLiteral<"handshake:res">;
  channel: z.ZodNullable<z.ZodString>;
  req: z.ZodUUID;
  pulse: z.ZodObject<{
    interval: z.ZodNumber;
    threshold: z.ZodNumber;
  }, z.core.$strip>;
  data: z.ZodAny;
  error: z.ZodNull;
}, z.core.$strip>, z.ZodObject<{
  id: z.ZodString;
  ts: z.ZodNumber;
  type: z.ZodLiteral<"handshake:res">;
  req: z.ZodUUID;
  data: z.ZodNull;
  error: z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>]>;
type HandshakeResponseMessage = z.output<typeof HandshakeResponseMessageSchema>;
declare const JoinResponseMessageSchema: z.ZodObject<{
  id: z.ZodString;
  ts: z.ZodNumber;
  type: z.ZodLiteral<"join:res">;
  channel: z.ZodString;
  req: z.ZodUUID;
  data: z.ZodAny;
  error: z.ZodUnion<readonly [z.ZodNull, z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
  }, z.core.$strip>]>;
}, z.core.$strip>;
type JoinResponseMessage = z.output<typeof JoinResponseMessageSchema>;
declare const LeaveResponseMessageSchema: z.ZodObject<{
  id: z.ZodString;
  ts: z.ZodNumber;
  type: z.ZodLiteral<"leave:res">;
  channel: z.ZodString;
  data: z.ZodAny;
  error: z.ZodUnion<readonly [z.ZodNull, z.ZodObject<{
    name: z.ZodString;
    message: z.ZodString;
  }, z.core.$strip>]>;
}, z.core.$strip>;
type LeaveResponseMessage = z.output<typeof LeaveResponseMessageSchema>;
type ServerMessage = PulseMessage | HandshakeResponseMessage | JoinResponseMessage | LeaveResponseMessage | EnvelopeMessage | RequestMessage | ResponseMessage;
//#endregion
//#region src/utils/types.d.ts
type Schema = {
  Requests?: Record<string, {
    request?: any;
    response?: any;
  }>;
  Messages?: Record<string, any>;
  Handshake?: {
    request?: any;
    response?: any;
  };
  Join?: {
    request?: any;
    response?: any;
  };
  Leave?: {
    request?: any;
    response?: any;
  };
};
type RequestKeys<S extends Schema> = S["Requests"] extends Record<string, any> ? keyof S["Requests"] : never;
type MessageKeys<S extends Schema> = S["Messages"] extends Record<string, any> ? keyof S["Messages"] : never;
type RequestData<S extends Schema, K extends RequestKeys<S>> = S["Requests"] extends Record<string, any> ? K extends keyof S["Requests"] ? "request" extends keyof S["Requests"][K] ? S["Requests"][K]["request"] : undefined : never : never;
type ResponseData<S extends Schema, K extends RequestKeys<S>> = S["Requests"] extends Record<string, any> ? K extends keyof S["Requests"] ? "response" extends keyof S["Requests"][K] ? S["Requests"][K]["response"] : undefined : never : never;
type MessageData<S extends Schema, K extends MessageKeys<S>> = S["Messages"] extends Record<string, any> ? K extends keyof S["Messages"] ? S["Messages"][K] : never : never;
type HandshakeRequestData<S extends Schema> = S["Handshake"] extends {
  request: any;
} ? S["Handshake"]["request"] : undefined;
type JoinRequestData<S extends Schema> = S["Join"] extends {
  request: any;
} ? S["Join"]["request"] : undefined;
type LeaveRequestData<S extends Schema> = S["Leave"] extends {
  request: any;
} ? S["Leave"]["request"] : undefined;
/**
 * Helper type for request parameters that makes data optional when undefined.
 */
type RequestParams<S extends Schema, K extends RequestKeys<S>> = RequestData<S, K> extends undefined ? {
  key: K;
  data?: undefined;
  timeout?: number;
} : {
  key: K;
  data: RequestData<S, K>;
  timeout?: number;
};
/**
 * Helper type for handshake parameters that makes data optional when undefined.
 */
type HandshakeParams<S extends Schema> = HandshakeRequestData<S> extends undefined ? {
  data?: undefined;
  timeout?: number;
} : {
  data: HandshakeRequestData<S>;
  timeout?: number;
};
/**
 * Helper type for join parameters that makes data optional when undefined.
 */
type JoinParams<S extends Schema> = JoinRequestData<S> extends undefined ? {
  data?: undefined;
  timeout?: number;
} : {
  data: JoinRequestData<S>;
  timeout?: number;
};
/**
 * Helper type for leave parameters that makes data optional when undefined.
 */
type LeaveParams<S extends Schema> = LeaveRequestData<S> extends undefined ? {
  data?: undefined;
  timeout?: number;
} : {
  data: LeaveRequestData<S>;
  timeout?: number;
};
/**
 * Helper type that creates a union of all possible request handler props.
 * This allows TypeScript to narrow the data type based on the request key.
 */
type RequestHandlerProps<S extends Schema> = S["Requests"] extends Record<string, any> ? { [K in keyof S["Requests"]]: {
  key: K;
  data: K extends RequestKeys<S> ? RequestData<S, K> : unknown;
} }[keyof S["Requests"]] | {
  key: null;
  data: unknown;
} : {
  key: null;
  data: unknown;
};
/**
 * Helper type that creates a union of all possible client message event payloads.
 * This allows TypeScript to narrow the data type based on the message key.
 */
type ClientMessageEventPayload<S extends Schema> = S["Messages"] extends Record<string, any> ? { [K in MessageKeys<S>]: {
  channel: string | null;
  key: K;
  data: MessageData<S, K>;
} }[MessageKeys<S>] | {
  channel: string | null;
  key: null;
  data: unknown;
} : {
  channel: string | null;
  key: null;
  data: unknown;
};

//#region src/client/channel.d.ts
interface ChannelOptions<S extends Schema = Record<string, never>> {
  client: WebSocketClient<S>;
  name: string;
}
declare class Channel<S extends Schema = Record<string, never>> {
  /**
   * Unique name of the Channel.
   */
  readonly name: string;
  /**
   * Reference to the `WebSocketClient` instance that the Channel belongs to.
   */
  readonly client: WebSocketClient<S>;
  /**
   * Whether this Channel is currently active (joined) on the Server.
   */
  active: boolean;
  constructor(opts: ChannelOptions<S>);
  /**
   * Send a Message to this Channel.
   */
  readonly send: <K extends MessageKeys<S>>(params: K extends never ? {
    key?: null;
    data: unknown;
  } : {
    key: K;
    data: MessageData<S, K>;
  }) => Promise<void>;
}
//#endregion
//#region src/client/events.d.ts
/**
 * Map of events emitted by the `WebSocketClient`.
 *
 * Public events are emitted after processing to indicate that operations have
 * completed successfully. These events fire after handlers and business logic
 * have been invoked, confirming the success of the operation.
 */
type WebSocketClientEvents<S extends Schema = Record<string, never>> = {
  /**
   * Emitted when the Client has successfully connected to the remote
   * `WebSocketServer` and completed the Handshake.
   */
  connect: unknown;
  /**
   * Emitted when the Client has closed the Connection to the
   * remote `WebSocketServer`.
   */
  disconnect: unknown;
  /**
   * Emitted after the Client has successfully joined a Channel.
   */
  join: Channel<S>;
  /**
   * Emitted after the Client has successfully left a Channel.
   */
  leave: Channel<S>;
  /**
   * Emitted after a Message has been received from the remote `WebSocketServer`.
   */
  message: ClientMessageEventPayload<S>;
};
//#endregion
//#region src/client/internal.d.ts
/**
 * Map of internal events emitted by the `WebSocketClient`.
 *
 * Most internal events are intentionally emitted before processing to provide
 * raw, protocol-level observability and debuggability.
 */
type WebSocketClientInternalEvents = {
  /**
   * Emitted when a Connection to the remote `WebSocketServer` is opened.
   */
  open: unknown;
  /**
   * Emitted when a Connection to the remote `WebSocketServer` is closed.
   */
  close: unknown;
  /**
   * Emitted when the `WebSocketClient` has successfully completed the Handshake
   * with the remote `WebSocketServer`.
   */
  handshake: HandshakeResponseMessage;
  /**
   * Emitted for any WebSocket message received from the remote `WebSocketServer`.
   */
  message: ServerMessage;
  /**
   * Emitted when a Response is received from the remote `WebSocketServer`.
   */
  response: {
    /**
     * Unique ID of the Request the Response is for.
     */
    req: string;
    /**
     * Data of the Response.
     */
    data: unknown;
    /**
     * Error of the Response.
     */
    error: {
      name: string;
      message: string;
    } | null;
  };
  /**
   * Emitted when a Connection attempt to the remote `WebSocketServer` is made.
   */
  attempt: {
    attempt: number;
    delay: number;
  };
  /**
   * Emitted when an error occurs during the Connection with the remote
   * `WebSocketServer`.
   *
   * This event is only emitted for asynchronous/background errors (message
   * parsing, pulse timeouts, unexpected disconnections).
   *
   * Errors from explicit operations like `connect()`, `join()`, or
   * `request()` are communicated through promise rejections only.
   */
  error: Error;
};
/**
 * Internal `EventEmitter` instance used to distribute internal events.
 */
declare class WebSocketClientInternal {
  private readonly emitter;
  readonly on: <K extends keyof WebSocketClientInternalEvents>(event: K, listener: Listener<WebSocketClientInternalEvents, K>) => void;
  readonly off: <K extends keyof WebSocketClientInternalEvents>(event: K, listener: Listener<WebSocketClientInternalEvents, K>) => void;
  readonly emit: <K extends keyof WebSocketClientInternalEvents>(event: K, payload: WebSocketClientInternalEvents[K]) => void;
}
//#endregion
//#region src/client/index.d.ts
interface WebSocketClientConfig<S extends Schema = Record<string, never>> {
  /**
   * URL of the `WebSocketServer` to connect to.
   */
  url: string;
  /**
   * Optional Error handler function. Invoked when asynchronous/background
   * errors occur during the Connection with the `WebSocketServer`.
   *
   * This handler is only invoked for asynchronous/background errors (message
   * parsing, pulse timeouts, unexpected disconnections).
   *
   * Errors from explicit operations like `connect()`, `join()`, or
   * `request()` are communicated through promise rejections only.
   *
   * @default console.error
   */
  onError?: (props: {
    error: Error;
  }) => void;
  /**
   * Optional Request handler function. Invoked when the `WebSocketServer`
   * sends a Request to the Client.
   *
   * If the handler returns or resolves, a `SuccessfulResponseMessage` is
   * returned to the Server with the returned data.
   *
   * If the handler throws or rejects, a `FailedResponseMessage` is returned to
   * the Server.
   *
   * If no handler is provided, a `RequestHandlerNotFoundError` is returned to
   * the Server for any Requests.
   *
   * @default undefined
   */
  handleRequest?: (props: RequestHandlerProps<S>) => unknown | Promise<unknown>;
  /**
   * Connection configuration options.
   */
  connection?: {
    /**
     * Maximum number of connection retry attempts.
     *
     * @default 8
     */
    maxRetries?: number;
  };
}
declare class WebSocketClient<S extends Schema = Record<string, never>> {
  /**
   * URL of the `WebSocketServer` to connect to.
   */
  private readonly url;
  /**
   * Error handler function. Called whenever an error occurs.
   */
  private readonly onError;
  /**
   * Request handler function. Called when the server sends a request.
   */
  private readonly handleRequest?;
  /**
   * Maximum number of connection retry attempts.
   */
  private readonly maxRetries;
  /**
   * Public `EventEmitter` instance used to distribute user-facing events.
   */
  readonly emitter: Emitter<WebSocketClientEvents<S>>;
  /**
   * Internal `EventEmitter` instance used to distribute internal events.
   */
  readonly internal: WebSocketClientInternal;
  /**
   * Reference to the raw `WebSocket` instance.
   */
  ws: WebSocket | null;
  /**
   * Internal timer used to send a `PulseMessage` to the remote
   * `WebSocketServer` if no other message was sent within the Pulse interval
   * shared by the remote `WebSocketServer` during the Handshake.
   */
  private pulseTimer;
  /**
   * Internal timer used to abort the connection if no message was received
   * within the Pulse interval and the timeout threshold shared by the remote
   * `WebSocketServer` during the Handshake.
   */
  private pulseTimeout;
  /**
   * Internal timer used to schedule reconnection attempts after connection loss.
   */
  private reconnectTimer;
  /**
   * Pulse configuration negotiated during handshake.
   */
  private pulseInterval;
  private pulseThreshold;
  /**
   * Reference to the parameters initially passed to the `connect` method.
   *
   * Required when reconnecting the `WebSocketClient` after the connection has
   * been lost.
   */
  private handshakeParams;
  /**
   * Current state of the client. Derived directly from the underlying
   * `WebSocket` instance.
   */
  get state(): "connecting" | "connected" | "disconnecting" | "disconnected";
  private readonly pending;
  readonly channels: Map<string, Channel<S>>;
  constructor(config: WebSocketClientConfig<S>);
  /**
   * WebSocket `message` event handler.
   *
   * If the raw message cannot be parsed or does not satisfy the expected
   * structure, an error is logged and the message is ignored.
   *
   * @param event Message event.
   */
  private readonly handleSocketMessage;
  /**
   * WebSocket `error` event handler.
   *
   * @param event Error event.
   */
  private readonly handleSocketError;
  private readonly schedulePulse;
  private readonly resetPulseTimeout;
  private readonly rejectAllPending;
  private readonly handshake;
  private readonly sendMessage;
  readonly connect: (params?: HandshakeParams<S>) => Promise<WebSocketClient<S>>;
  readonly disconnect: (reconnect?: boolean) => Promise<void>;
  readonly join: (channel: string, params?: JoinParams<S>) => Promise<Channel<S>>;
  readonly leave: (channel: string, params?: LeaveParams<S>) => Promise<void>;
  readonly send: <K extends MessageKeys<S>>(params: K extends never ? {
    key?: null;
    data: unknown;
    channel?: string | null;
  } : {
    key: K;
    data: MessageData<S, K>;
    channel?: string | null;
  }) => Promise<void>;
  readonly request: <K extends RequestKeys<S>>(params: K extends never ? {
    key?: null;
    data?: unknown;
    timeout?: number;
  } : RequestParams<S, K>) => Promise<K extends never ? unknown : ResponseData<S, K>>;
  /**
   * Register a new event listener.
   *
   * @param event Name of the event to listen for.
   * @param listener Function to call when the event is emitted.
   *
   * @returns `this` to allow chaining.
   */
  on<K extends keyof WebSocketClientEvents<S>>(event: K, listener: Listener<WebSocketClientEvents<S>, K>): this;
  /**
   * Remove an event listener.
   *
   * @param event Name of the event to remove the listener from.
   * @param listener Function to remove from the event.
   *
   * @returns `this` to allow chaining.
   */
  off<K extends keyof WebSocketClientEvents<S>>(event: K, listener: Listener<WebSocketClientEvents<S>, K>): this;
  /**
   * Destroy the client and clean up all resources.
   *
   * This method must be manually called to prevent memory leaks.
   *
   * It unsubscribes event handlers, disconnects the socket, rejects all pending
   * operations, and clears all channels.
   *
   * @returns Promise resolving when the client has been destroyed.
   */
  readonly destroy: () => Promise<void>;
}

export { WebSocketClient as W };
export type { Protocol as P };