@replit/river 0.209.0 → 0.209.2

package/dist/{transport-CxjUaGhi.d.cts → handshake-B3iu79B0.d.cts}

@@ -1,6 +1,6 @@
-import { TSchema, Static } from '@sinclair/typebox';
-import { f as TelemetryInfo, c as TransportClientId, P as ProtocolVersion, b as OpaqueTransportMessage, e as PartialTransportMessage, a as TransportMessage, g as HandshakeErrorCustomHandlerFatalResponseCodes, H as HandshakeErrorResponseCodes } from './message-Dlsh5WDF.cjs';
+import { f as TelemetryInfo, c as TransportClientId, P as ProtocolVersion, b as OpaqueTransportMessage, e as PartialTransportMessage, a as TransportMessage, H as HandshakeErrorResponseCodes, g as HandshakeErrorCustomHandlerFatalResponseCodes } from './message-Dlsh5WDF.cjs';
 import { M as MessageMetadata, L as Logger, T as Tags, a as LogFn, b as LoggingLevel } from './index-D9R6UTMl.cjs';
+import { Static, TSchema } from '@sinclair/typebox';
 import { C as Codec, a as CodecMessageAdapter, S as SendResult, b as SendBufferResult } from './adapter-DjiEwOYi.cjs';
 import { Tracer } from '@opentelemetry/api';
 
@@ -187,100 +187,6 @@ declare abstract class IdentifiedSessionWithGracePeriod extends IdentifiedSessio
     _handleClose(): void;
 }
 
-type ConstructHandshake<T extends TSchema> = () => Static<T> | Promise<Static<T>>;
-type ValidateHandshake<T extends TSchema, ParsedMetadata> = (metadata: Static<T>, previousParsedMetadata?: ParsedMetadata) => Static<typeof HandshakeErrorCustomHandlerFatalResponseCodes> | ParsedMetadata | Promise<Static<typeof HandshakeErrorCustomHandlerFatalResponseCodes> | ParsedMetadata>;
-interface ClientHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
-    /**
-     * Schema for the metadata that the client sends to the server
-     * during the handshake.
-     */
-    schema: MetadataSchema;
-    /**
-     * Gets the {@link HandshakeRequestMetadata} to send to the server.
-     */
-    construct: ConstructHandshake<MetadataSchema>;
-}
-interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema, ParsedMetadata extends object = object> {
-    /**
-     * Schema for the metadata that the server receives from the client
-     * during the handshake.
-     */
-    schema: MetadataSchema;
-    /**
-     * Parses the {@link HandshakeRequestMetadata} sent by the client, transforming
-     * it into {@link ParsedHandshakeMetadata}.
-     *
-     * May return `false` if the client should be rejected.
-     *
-     * @param metadata - The metadata sent by the client.
-     * @param session - The session that the client would be associated with.
-     * @param isReconnect - Whether the client is reconnecting to the session,
-     *                      or if this is a new session.
-     */
-    validate: ValidateHandshake<MetadataSchema, ParsedMetadata>;
-}
-declare function createClientHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, construct: ConstructHandshake<MetadataSchema>): ClientHandshakeOptions;
-declare function createServerHandshakeOptions<MetadataSchema extends TSchema = TSchema, ParsedMetadata extends object = object>(schema: MetadataSchema, validate: ValidateHandshake<MetadataSchema, ParsedMetadata>): ServerHandshakeOptions<MetadataSchema, ParsedMetadata>;
-
-/**
- * Options to control the backoff and retry behavior of the client transport's connection behaviour.
- *
- * River implements exponential backoff with jitter to prevent flooding the server
- * when there's an issue with connection establishment.
- *
- * The backoff is calculated via the following:
- *   backOff = min(jitter + {@link baseIntervalMs} * 2 ^ budget_consumed, {@link maxBackoffMs})
- *
- * We use a leaky bucket rate limit with a budget of {@link attemptBudgetCapacity} reconnection attempts.
- * Budget only starts to restore after a successful handshake at a rate of one budget per {@link budgetRestoreIntervalMs}.
- */
-interface ConnectionRetryOptions {
-    /**
-     * The base interval to wait before retrying a connection.
-     */
-    baseIntervalMs: number;
-    /**
-     * The maximum random jitter to add to the total backoff time.
-     */
-    maxJitterMs: number;
-    /**
-     * The maximum amount of time to wait before retrying a connection.
-     * This does not include the jitter.
-     */
-    maxBackoffMs: number;
-    /**
-     * The max number of times to attempt a connection before a successful handshake.
-     * This persists across connections but starts restoring budget after a successful handshake.
-     * The restoration interval depends on {@link budgetRestoreIntervalMs}
-     */
-    attemptBudgetCapacity: number;
-    /**
-     * After a successful connection attempt, how long to wait before we restore a single budget.
-     */
-    budgetRestoreIntervalMs: number;
-}
-declare class LeakyBucketRateLimit {
-    private budgetConsumed;
-    private intervalHandle?;
-    private readonly options;
-    constructor(options: ConnectionRetryOptions);
-    getBackoffMs(): number;
-    get totalBudgetRestoreTime(): number;
-    consumeBudget(): void;
-    getBudgetConsumed(): number;
-    hasBudget(): boolean;
-    startRestoringBudget(): void;
-    private stopLeak;
-    close(): void;
-}
-
-type TransportOptions = SessionOptions;
-type ProvidedTransportOptions = Partial<TransportOptions>;
-type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
-type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
-type ServerTransportOptions = TransportOptions;
-type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
-
 interface SessionConnectingListeners extends IdentifiedSessionWithGracePeriodListeners {
     onConnectionEstablished: (conn: Connection) => void;
     onConnectionFailed: (err: unknown) => void;
@@ -301,6 +207,12 @@ declare class SessionConnecting<ConnType extends Connection> extends IdentifiedS
     _handleClose(): void;
 }
 
+declare class SessionNoConnection extends IdentifiedSessionWithGracePeriod {
+    readonly state: SessionState.NoConnection;
+    _handleClose(): void;
+    _handleStateExit(): void;
+}
+
 interface SessionHandshakingListeners extends IdentifiedSessionWithGracePeriodListeners {
     onConnectionErrored: (err: unknown) => void;
     onConnectionClosed: () => void;
@@ -391,12 +303,6 @@ declare class SessionConnected<ConnType extends Connection> extends IdentifiedSe
     _handleClose(): void;
 }
 
-declare class SessionNoConnection extends IdentifiedSessionWithGracePeriod {
-    readonly state: SessionState.NoConnection;
-    _handleClose(): void;
-    _handleStateExit(): void;
-}
-
 interface SessionBackingOffListeners extends IdentifiedSessionWithGracePeriodListeners {
     onBackoffFinished: () => void;
 }
@@ -473,6 +379,65 @@ declare class EventDispatcher<T extends EventTypes> {
     dispatchEvent<K extends T>(eventType: K, event: EventMap[K]): void;
 }
 
+/**
+ * Options to control the backoff and retry behavior of the client transport's connection behaviour.
+ *
+ * River implements exponential backoff with jitter to prevent flooding the server
+ * when there's an issue with connection establishment.
+ *
+ * The backoff is calculated via the following:
+ *   backOff = min(jitter + {@link baseIntervalMs} * 2 ^ budget_consumed, {@link maxBackoffMs})
+ *
+ * We use a leaky bucket rate limit with a budget of {@link attemptBudgetCapacity} reconnection attempts.
+ * Budget only starts to restore after a successful handshake at a rate of one budget per {@link budgetRestoreIntervalMs}.
+ */
+interface ConnectionRetryOptions {
+    /**
+     * The base interval to wait before retrying a connection.
+     */
+    baseIntervalMs: number;
+    /**
+     * The maximum random jitter to add to the total backoff time.
+     */
+    maxJitterMs: number;
+    /**
+     * The maximum amount of time to wait before retrying a connection.
+     * This does not include the jitter.
+     */
+    maxBackoffMs: number;
+    /**
+     * The max number of times to attempt a connection before a successful handshake.
+     * This persists across connections but starts restoring budget after a successful handshake.
+     * The restoration interval depends on {@link budgetRestoreIntervalMs}
+     */
+    attemptBudgetCapacity: number;
+    /**
+     * After a successful connection attempt, how long to wait before we restore a single budget.
+     */
+    budgetRestoreIntervalMs: number;
+}
+declare class LeakyBucketRateLimit {
+    private budgetConsumed;
+    private intervalHandle?;
+    private readonly options;
+    constructor(options: ConnectionRetryOptions);
+    getBackoffMs(): number;
+    get totalBudgetRestoreTime(): number;
+    consumeBudget(): void;
+    getBudgetConsumed(): number;
+    hasBudget(): boolean;
+    startRestoringBudget(): void;
+    private stopLeak;
+    close(): void;
+}
+
+type TransportOptions = SessionOptions;
+type ProvidedTransportOptions = Partial<TransportOptions>;
+type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
+type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
+type ServerTransportOptions = TransportOptions;
+type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
+
 /**
  * Represents the possible states of a transport.
  * @property {'open'} open - The transport is open and operational (note that this doesn't mean it is actively connected)
@@ -574,4 +539,39 @@ declare abstract class Transport<ConnType extends Connection> {
     getSessionBoundSendFn(to: TransportClientId, sessionId: SessionId): SessionBoundSendFn;
 }
 
+type ConstructHandshake<T extends TSchema> = () => Static<T> | Promise<Static<T>>;
+type ValidateHandshake<T extends TSchema, ParsedMetadata> = (metadata: Static<T>, previousParsedMetadata?: ParsedMetadata) => Static<typeof HandshakeErrorCustomHandlerFatalResponseCodes> | ParsedMetadata | Promise<Static<typeof HandshakeErrorCustomHandlerFatalResponseCodes> | ParsedMetadata>;
+interface ClientHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
+    /**
+     * Schema for the metadata that the client sends to the server
+     * during the handshake.
+     */
+    schema: MetadataSchema;
+    /**
+     * Gets the {@link HandshakeRequestMetadata} to send to the server.
+     */
+    construct: ConstructHandshake<MetadataSchema>;
+}
+interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema, ParsedMetadata extends object = object> {
+    /**
+     * Schema for the metadata that the server receives from the client
+     * during the handshake.
+     */
+    schema: MetadataSchema;
+    /**
+     * Parses the {@link HandshakeRequestMetadata} sent by the client, transforming
+     * it into {@link ParsedHandshakeMetadata}.
+     *
+     * May return `false` if the client should be rejected.
+     *
+     * @param metadata - The metadata sent by the client.
+     * @param session - The session that the client would be associated with.
+     * @param isReconnect - Whether the client is reconnecting to the session,
+     *                      or if this is a new session.
+     */
+    validate: ValidateHandshake<MetadataSchema, ParsedMetadata>;
+}
+declare function createClientHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, construct: ConstructHandshake<MetadataSchema>): ClientHandshakeOptions;
+declare function createServerHandshakeOptions<MetadataSchema extends TSchema = TSchema, ParsedMetadata extends object = object>(schema: MetadataSchema, validate: ValidateHandshake<MetadataSchema, ParsedMetadata>): ServerHandshakeOptions<MetadataSchema, ParsedMetadata>;
+
 export { Connection as C, type DeleteSessionOptions as D, type EventMap as E, LeakyBucketRateLimit as L, type ProvidedTransportOptions as P, type Session as S, Transport as T, type TransportStatus as a, type ProvidedClientTransportOptions as b, type ProvidedServerTransportOptions as c, SessionState as d, SessionNoConnection as e, SessionConnecting as f, SessionHandshaking as g, SessionConnected as h, type EventTypes as i, type EventHandler as j, ProtocolError as k, type ProtocolErrorType as l, type ClientTransportOptions as m, type ClientHandshakeOptions as n, type ClientSession as o, SessionBackingOff as p, type ServerHandshakeOptions as q, createClientHandshakeOptions as r, createServerHandshakeOptions as s, CommonSession as t, type CommonSessionProps as u, type ServerTransportOptions as v, type ServerSession as w, type SessionOptions as x, type SessionBoundSendFn as y, type SessionId as z };

package/dist/{transport-DwEB67zY.d.ts → handshake-DNinPBA3.d.ts}

@@ -1,6 +1,6 @@
-import { TSchema, Static } from '@sinclair/typebox';
-import { f as TelemetryInfo, c as TransportClientId, P as ProtocolVersion, b as OpaqueTransportMessage, e as PartialTransportMessage, a as TransportMessage, g as HandshakeErrorCustomHandlerFatalResponseCodes, H as HandshakeErrorResponseCodes } from './message-Dlsh5WDF.js';
+import { f as TelemetryInfo, c as TransportClientId, P as ProtocolVersion, b as OpaqueTransportMessage, e as PartialTransportMessage, a as TransportMessage, H as HandshakeErrorResponseCodes, g as HandshakeErrorCustomHandlerFatalResponseCodes } from './message-Dlsh5WDF.js';
 import { M as MessageMetadata, L as Logger, T as Tags, a as LogFn, b as LoggingLevel } from './index-CSM8soK7.js';
+import { Static, TSchema } from '@sinclair/typebox';
 import { C as Codec, a as CodecMessageAdapter, S as SendResult, b as SendBufferResult } from './adapter-Cp7_gIVA.js';
 import { Tracer } from '@opentelemetry/api';
 
@@ -187,100 +187,6 @@ declare abstract class IdentifiedSessionWithGracePeriod extends IdentifiedSessio
     _handleClose(): void;
 }
 
-type ConstructHandshake<T extends TSchema> = () => Static<T> | Promise<Static<T>>;
-type ValidateHandshake<T extends TSchema, ParsedMetadata> = (metadata: Static<T>, previousParsedMetadata?: ParsedMetadata) => Static<typeof HandshakeErrorCustomHandlerFatalResponseCodes> | ParsedMetadata | Promise<Static<typeof HandshakeErrorCustomHandlerFatalResponseCodes> | ParsedMetadata>;
-interface ClientHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
-    /**
-     * Schema for the metadata that the client sends to the server
-     * during the handshake.
-     */
-    schema: MetadataSchema;
-    /**
-     * Gets the {@link HandshakeRequestMetadata} to send to the server.
-     */
-    construct: ConstructHandshake<MetadataSchema>;
-}
-interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema, ParsedMetadata extends object = object> {
-    /**
-     * Schema for the metadata that the server receives from the client
-     * during the handshake.
-     */
-    schema: MetadataSchema;
-    /**
-     * Parses the {@link HandshakeRequestMetadata} sent by the client, transforming
-     * it into {@link ParsedHandshakeMetadata}.
-     *
-     * May return `false` if the client should be rejected.
-     *
-     * @param metadata - The metadata sent by the client.
-     * @param session - The session that the client would be associated with.
-     * @param isReconnect - Whether the client is reconnecting to the session,
-     *                      or if this is a new session.
-     */
-    validate: ValidateHandshake<MetadataSchema, ParsedMetadata>;
-}
-declare function createClientHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, construct: ConstructHandshake<MetadataSchema>): ClientHandshakeOptions;
-declare function createServerHandshakeOptions<MetadataSchema extends TSchema = TSchema, ParsedMetadata extends object = object>(schema: MetadataSchema, validate: ValidateHandshake<MetadataSchema, ParsedMetadata>): ServerHandshakeOptions<MetadataSchema, ParsedMetadata>;
-
-/**
- * Options to control the backoff and retry behavior of the client transport's connection behaviour.
- *
- * River implements exponential backoff with jitter to prevent flooding the server
- * when there's an issue with connection establishment.
- *
- * The backoff is calculated via the following:
- *   backOff = min(jitter + {@link baseIntervalMs} * 2 ^ budget_consumed, {@link maxBackoffMs})
- *
- * We use a leaky bucket rate limit with a budget of {@link attemptBudgetCapacity} reconnection attempts.
- * Budget only starts to restore after a successful handshake at a rate of one budget per {@link budgetRestoreIntervalMs}.
- */
-interface ConnectionRetryOptions {
-    /**
-     * The base interval to wait before retrying a connection.
-     */
-    baseIntervalMs: number;
-    /**
-     * The maximum random jitter to add to the total backoff time.
-     */
-    maxJitterMs: number;
-    /**
-     * The maximum amount of time to wait before retrying a connection.
-     * This does not include the jitter.
-     */
-    maxBackoffMs: number;
-    /**
-     * The max number of times to attempt a connection before a successful handshake.
-     * This persists across connections but starts restoring budget after a successful handshake.
-     * The restoration interval depends on {@link budgetRestoreIntervalMs}
-     */
-    attemptBudgetCapacity: number;
-    /**
-     * After a successful connection attempt, how long to wait before we restore a single budget.
-     */
-    budgetRestoreIntervalMs: number;
-}
-declare class LeakyBucketRateLimit {
-    private budgetConsumed;
-    private intervalHandle?;
-    private readonly options;
-    constructor(options: ConnectionRetryOptions);
-    getBackoffMs(): number;
-    get totalBudgetRestoreTime(): number;
-    consumeBudget(): void;
-    getBudgetConsumed(): number;
-    hasBudget(): boolean;
-    startRestoringBudget(): void;
-    private stopLeak;
-    close(): void;
-}
-
-type TransportOptions = SessionOptions;
-type ProvidedTransportOptions = Partial<TransportOptions>;
-type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
-type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
-type ServerTransportOptions = TransportOptions;
-type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
-
 interface SessionConnectingListeners extends IdentifiedSessionWithGracePeriodListeners {
     onConnectionEstablished: (conn: Connection) => void;
     onConnectionFailed: (err: unknown) => void;
@@ -301,6 +207,12 @@ declare class SessionConnecting<ConnType extends Connection> extends IdentifiedS
     _handleClose(): void;
 }
 
+declare class SessionNoConnection extends IdentifiedSessionWithGracePeriod {
+    readonly state: SessionState.NoConnection;
+    _handleClose(): void;
+    _handleStateExit(): void;
+}
+
 interface SessionHandshakingListeners extends IdentifiedSessionWithGracePeriodListeners {
     onConnectionErrored: (err: unknown) => void;
     onConnectionClosed: () => void;
@@ -391,12 +303,6 @@ declare class SessionConnected<ConnType extends Connection> extends IdentifiedSe
     _handleClose(): void;
 }
 
-declare class SessionNoConnection extends IdentifiedSessionWithGracePeriod {
-    readonly state: SessionState.NoConnection;
-    _handleClose(): void;
-    _handleStateExit(): void;
-}
-
 interface SessionBackingOffListeners extends IdentifiedSessionWithGracePeriodListeners {
     onBackoffFinished: () => void;
 }
@@ -473,6 +379,65 @@ declare class EventDispatcher<T extends EventTypes> {
     dispatchEvent<K extends T>(eventType: K, event: EventMap[K]): void;
 }
 
+/**
+ * Options to control the backoff and retry behavior of the client transport's connection behaviour.
+ *
+ * River implements exponential backoff with jitter to prevent flooding the server
+ * when there's an issue with connection establishment.
+ *
+ * The backoff is calculated via the following:
+ *   backOff = min(jitter + {@link baseIntervalMs} * 2 ^ budget_consumed, {@link maxBackoffMs})
+ *
+ * We use a leaky bucket rate limit with a budget of {@link attemptBudgetCapacity} reconnection attempts.
+ * Budget only starts to restore after a successful handshake at a rate of one budget per {@link budgetRestoreIntervalMs}.
+ */
+interface ConnectionRetryOptions {
+    /**
+     * The base interval to wait before retrying a connection.
+     */
+    baseIntervalMs: number;
+    /**
+     * The maximum random jitter to add to the total backoff time.
+     */
+    maxJitterMs: number;
+    /**
+     * The maximum amount of time to wait before retrying a connection.
+     * This does not include the jitter.
+     */
+    maxBackoffMs: number;
+    /**
+     * The max number of times to attempt a connection before a successful handshake.
+     * This persists across connections but starts restoring budget after a successful handshake.
+     * The restoration interval depends on {@link budgetRestoreIntervalMs}
+     */
+    attemptBudgetCapacity: number;
+    /**
+     * After a successful connection attempt, how long to wait before we restore a single budget.
+     */
+    budgetRestoreIntervalMs: number;
+}
+declare class LeakyBucketRateLimit {
+    private budgetConsumed;
+    private intervalHandle?;
+    private readonly options;
+    constructor(options: ConnectionRetryOptions);
+    getBackoffMs(): number;
+    get totalBudgetRestoreTime(): number;
+    consumeBudget(): void;
+    getBudgetConsumed(): number;
+    hasBudget(): boolean;
+    startRestoringBudget(): void;
+    private stopLeak;
+    close(): void;
+}
+
+type TransportOptions = SessionOptions;
+type ProvidedTransportOptions = Partial<TransportOptions>;
+type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
+type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
+type ServerTransportOptions = TransportOptions;
+type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
+
 /**
  * Represents the possible states of a transport.
  * @property {'open'} open - The transport is open and operational (note that this doesn't mean it is actively connected)
@@ -574,4 +539,39 @@ declare abstract class Transport<ConnType extends Connection> {
     getSessionBoundSendFn(to: TransportClientId, sessionId: SessionId): SessionBoundSendFn;
 }
 
+type ConstructHandshake<T extends TSchema> = () => Static<T> | Promise<Static<T>>;
+type ValidateHandshake<T extends TSchema, ParsedMetadata> = (metadata: Static<T>, previousParsedMetadata?: ParsedMetadata) => Static<typeof HandshakeErrorCustomHandlerFatalResponseCodes> | ParsedMetadata | Promise<Static<typeof HandshakeErrorCustomHandlerFatalResponseCodes> | ParsedMetadata>;
+interface ClientHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
+    /**
+     * Schema for the metadata that the client sends to the server
+     * during the handshake.
+     */
+    schema: MetadataSchema;
+    /**
+     * Gets the {@link HandshakeRequestMetadata} to send to the server.
+     */
+    construct: ConstructHandshake<MetadataSchema>;
+}
+interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema, ParsedMetadata extends object = object> {
+    /**
+     * Schema for the metadata that the server receives from the client
+     * during the handshake.
+     */
+    schema: MetadataSchema;
+    /**
+     * Parses the {@link HandshakeRequestMetadata} sent by the client, transforming
+     * it into {@link ParsedHandshakeMetadata}.
+     *
+     * May return `false` if the client should be rejected.
+     *
+     * @param metadata - The metadata sent by the client.
+     * @param session - The session that the client would be associated with.
+     * @param isReconnect - Whether the client is reconnecting to the session,
+     *                      or if this is a new session.
+     */
+    validate: ValidateHandshake<MetadataSchema, ParsedMetadata>;
+}
+declare function createClientHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, construct: ConstructHandshake<MetadataSchema>): ClientHandshakeOptions;
+declare function createServerHandshakeOptions<MetadataSchema extends TSchema = TSchema, ParsedMetadata extends object = object>(schema: MetadataSchema, validate: ValidateHandshake<MetadataSchema, ParsedMetadata>): ServerHandshakeOptions<MetadataSchema, ParsedMetadata>;
+
 export { Connection as C, type DeleteSessionOptions as D, type EventMap as E, LeakyBucketRateLimit as L, type ProvidedTransportOptions as P, type Session as S, Transport as T, type TransportStatus as a, type ProvidedClientTransportOptions as b, type ProvidedServerTransportOptions as c, SessionState as d, SessionNoConnection as e, SessionConnecting as f, SessionHandshaking as g, SessionConnected as h, type EventTypes as i, type EventHandler as j, ProtocolError as k, type ProtocolErrorType as l, type ClientTransportOptions as m, type ClientHandshakeOptions as n, type ClientSession as o, SessionBackingOff as p, type ServerHandshakeOptions as q, createClientHandshakeOptions as r, createServerHandshakeOptions as s, CommonSession as t, type CommonSessionProps as u, type ServerTransportOptions as v, type ServerSession as w, type SessionOptions as x, type SessionBoundSendFn as y, type SessionId as z };