@versori/run 0.1.0-alpha.8 → 0.2.0-alpha.1

package/esm/deps/jsr.io/@nats-io/nats-core/3.0.2/src/core.d.ts

@@ -0,0 +1,866 @@
+export type DisconnectStatus = {
+    type: "disconnect";
+    server: string;
+};
+export type ReconnectStatus = {
+    type: "reconnect";
+    server: string;
+};
+export type ReconnectingStatus = {
+    type: "reconnecting";
+};
+export type ClusterUpdateStatus = {
+    type: "update";
+    added?: string[];
+    deleted?: string[];
+};
+export type LDMStatus = {
+    type: "ldm";
+    server: string;
+};
+export type ServerErrorStatus = {
+    type: "error";
+    error: Error;
+};
+export type ClientPingStatus = {
+    type: "ping";
+    pendingPings: number;
+};
+export type StaleConnectionStatus = {
+    type: "staleConnection";
+};
+export type ForceReconnectStatus = {
+    type: "forceReconnect";
+};
+export type SlowConsumerStatus = {
+    type: "slowConsumer";
+    sub: Subscription;
+    pending: number;
+};
+export type CloseStatus = {
+    type: "close";
+};
+export type Status = DisconnectStatus | ReconnectStatus | ReconnectingStatus | ClusterUpdateStatus | LDMStatus | ServerErrorStatus | ClientPingStatus | StaleConnectionStatus | SlowConsumerStatus | ForceReconnectStatus | CloseStatus;
+export type MsgCallback<T> = (err: Error | null, msg: T) => void | Promise<never>;
+/**
+ * Subscription Options
+ */
+export interface SubOpts<T> {
+    /**
+     * Optional queue name (subscriptions on the same subject that use queues
+     * are horizontally load balanced when part of the same queue).
+     */
+    queue?: string;
+    /**
+     * Optional maximum number of messages to deliver to the subscription
+     * before it is auto-unsubscribed.
+     */
+    max?: number;
+    /**
+     * Optional maximum number of milliseconds before a timer raises an error. This
+     * useful to monitor a subscription that is expected to yield messages.
+     * The timer is cancelled when the first message is received by the subscription.
+     */
+    timeout?: number;
+    /**
+     * An optional function that will handle messages. Typically, messages
+     * are processed via an async iterator on the subscription. If this
+     * option is provided, messages are processed by the specified function.
+     * @param err
+     * @param msg
+     */
+    callback?: MsgCallback<T>;
+    /**
+     * Number of pending messages in a subscription to exceed prior to considering
+     * a subscription a Slow Consumer. By default, slow consumer is on a subscription
+     * is not accounted for.
+     *
+     * This is an experimental option.
+     */
+    slow?: number;
+}
+export interface DnsResolveFn {
+    (h: string): Promise<string[]>;
+}
+/**
+ * Subscription Options
+ */
+export type SubscriptionOptions = SubOpts<Msg>;
+/**
+ * ServerInfo represents information from the connected server
+ */
+export interface ServerInfo {
+    /**
+     * True if the server requires authentication
+     */
+    "auth_required"?: boolean;
+    /**
+     * Server-assigned client_id
+     */
+    "client_id": number;
+    /**
+     * The client's IP as seen by the server
+     */
+    "client_ip"?: string;
+    /**
+     * The name or ID of the cluster
+     */
+    cluster?: string;
+    /**
+     * Other servers available on the connected cluster
+     */
+    "connect_urls"?: string[];
+    /**
+     * Git commit information on the built server binary
+     */
+    "git_commit"?: string;
+    /**
+     * Version information on the Go stack used to build the server binary
+     */
+    go: string;
+    /**
+     * True if the server supports headers
+     */
+    headers?: boolean;
+    /**
+     * Hostname of the connected server
+     */
+    host: string;
+    /**
+     * True if the server supports JetStream
+     */
+    jetstream?: boolean;
+    /**
+     * True if the server is in Lame Duck Mode
+     */
+    ldm?: boolean;
+    /**
+     * Max number of bytes in message that can be sent to the server
+     */
+    "max_payload": number;
+    /**
+     * If the server required nkey or JWT authentication the nonce used during authentication.
+     */
+    nonce?: string;
+    /**
+     * The port where the server is listening
+     */
+    port: number;
+    /**
+     * Version number of the NATS protocol
+     */
+    proto: number;
+    /**
+     * The ID of the server
+     */
+    "server_id": string;
+    /**
+     * The name of the server
+     */
+    "server_name": string;
+    /**
+     * True if TLS is available
+     */
+    "tls_available"?: boolean;
+    /**
+     * True if TLS connections are required
+     */
+    "tls_required"?: boolean;
+    /**
+     * True if TLS client certificate verification is required
+     */
+    "tls_verify"?: boolean;
+    /**
+     * The nats-server version
+     */
+    version: string;
+}
+export interface Server {
+    hostname: string;
+    port: number;
+    listen: string;
+    src: string;
+    tlsName: string;
+    resolve(opts: Partial<{
+        fn: DnsResolveFn;
+        randomize: boolean;
+        debug?: boolean;
+        resolve?: boolean;
+    }>): Promise<Server[]>;
+}
+/**
+ * ServerChanged records servers in the cluster that were added or deleted.
+ */
+export interface ServersChanged {
+    /** list of added servers */
+    readonly added: string[];
+    /** list of deleted servers */
+    readonly deleted: string[];
+}
+export declare const Match: {
+    readonly Exact: "exact";
+    readonly CanonicalMIME: "canonical";
+    readonly IgnoreCase: "insensitive";
+};
+export type Match = typeof Match[keyof typeof Match];
+export interface MsgHdrs extends Iterable<[string, string[]]> {
+    hasError: boolean;
+    status: string;
+    code: number;
+    description: string;
+    get(k: string, match?: Match): string;
+    set(k: string, v: string, match?: Match): void;
+    append(k: string, v: string, match?: Match): void;
+    has(k: string, match?: Match): boolean;
+    keys(): string[];
+    values(k: string, match?: Match): string[];
+    delete(k: string, match?: Match): void;
+    last(k: string, match?: Match): string;
+}
+export interface RequestOptions {
+    /**
+     * number of milliseconds before the request will timeout.
+     */
+    timeout: number;
+    /**
+     * MsgHdrs to include with the request.
+     */
+    headers?: MsgHdrs;
+    /**
+     * If true, the request API will create a regular NATS subscription
+     * to process the response. Otherwise a shared muxed subscriptions is
+     * used. Requires {@link reply}
+     */
+    noMux?: boolean;
+    /**
+     * The subject where the response should be sent to. Requires {@link noMux}
+     */
+    reply?: string;
+}
+export type RequestStrategy = "timer" | "count" | "stall" | "sentinel";
+export interface RequestManyOptions {
+    strategy: RequestStrategy;
+    maxWait: number;
+    headers?: MsgHdrs;
+    maxMessages?: number;
+    noMux?: boolean;
+    stall?: number;
+}
+export interface Stats {
+    /**
+     * Number of bytes received by the client.
+     */
+    inBytes: number;
+    /**
+     * Number of bytes sent by the client.
+     */
+    outBytes: number;
+    /**
+     * Number of messages received by the client.
+     */
+    inMsgs: number;
+    /**
+     * Number of messages sent by the client.
+     */
+    outMsgs: number;
+}
+export type Payload = Uint8Array | string;
+export interface NatsConnection {
+    /**
+     * ServerInfo to the currently connected server or undefined
+     */
+    info?: ServerInfo;
+    /**
+     * Returns a promise that can be used to monitor if the client closes.
+     * The promise can resolve an Error if the reason for the close was
+     * an error. Note that the promise doesn't reject, but rather resolves
+     * to the error if there was one.
+     */
+    closed(): Promise<void | Error>;
+    /**
+     * Close will close the connection to the server. This call will terminate
+     * all pending requests and subscriptions. The returned promise resolves when
+     * the connection closes.
+     */
+    close(): Promise<void>;
+    /**
+     * Publishes the specified data to the specified subject.
+     * @param subject
+     * @param payload
+     * @param options
+     */
+    publish(subject: string, payload?: Payload, options?: PublishOptions): void;
+    /**
+     * Publishes using the subject of the specified message, specifying the
+     * data, headers and reply found in the message if any.
+     * @param msg
+     */
+    publishMessage(msg: Msg): void;
+    /**
+     * Replies using the reply subject of the specified message, specifying the
+     * data, headers in the message if any.
+     * @param msg
+     */
+    respondMessage(msg: Msg): boolean;
+    /**
+     * Subscribe expresses interest in the specified subject. The subject may
+     * have wildcards. Messages are delivered to the {@link SubOpts#callback |SubscriptionOptions callback}
+     * if specified. Otherwise, the subscription is an async iterator for {@link Msg}.
+     *
+     * @param subject
+     * @param opts
+     */
+    subscribe(subject: string, opts?: SubscriptionOptions): Subscription;
+    /**
+     * Publishes a request with specified data in the specified subject expecting a
+     * response before {@link RequestOptions#timeout} milliseconds. The api returns a
+     * Promise that resolves when the first response to the request is received. If
+     * there are no responders (a subscription) listening on the request subject,
+     * the request will fail as soon as the server processes it.
+     *
+     * @param subject
+     * @param payload
+     * @param opts
+     */
+    request(subject: string, payload?: Payload, opts?: RequestOptions): Promise<Msg>;
+    /**
+     * Publishes a request expecting multiple responses back. Several strategies
+     * to determine when the request should stop gathering responses.
+     * @param subject
+     * @param payload
+     * @param opts
+     */
+    requestMany(subject: string, payload?: Payload, opts?: Partial<RequestManyOptions>): Promise<AsyncIterable<Msg>>;
+    /**
+     * Returns a Promise that resolves when the client receives a reply from
+     * the server. Use of this API is not necessary by clients.
+     */
+    flush(): Promise<void>;
+    /**
+     * Initiates a drain on the connection and returns a promise that resolves when the
+     * drain completes and the connection closes.
+     *
+     * Drain is an ordered shutdown of the client. Instead of abruptly closing the client,
+     * subscriptions are drained, that is messages not yet processed by a subscription are
+     * handled before the subscription is closed. After subscriptions are drained it is not
+     * possible to create a new subscription. Then all pending outbound messages are
+     * sent to the server. Finally, the connection is closed.
+     */
+    drain(): Promise<void>;
+    /**
+     * Returns true if the client is closed.
+     */
+    isClosed(): boolean;
+    /**
+     * Returns true if the client is draining.
+     */
+    isDraining(): boolean;
+    /**
+     * Returns the hostport of the server the client is connected to.
+     */
+    getServer(): string;
+    /**
+     * Returns an async iterator of {@link Status} that may be
+     * useful in understanding when the client looses a connection, or
+     * reconnects, or receives an update from the cluster among other things.
+     *
+     * @return an AsyncIterable<Status>
+     */
+    status(): AsyncIterable<Status>;
+    /**
+     * Returns some metrics such as the number of messages and bytes
+     * sent and recieved by the client.
+     */
+    stats(): Stats;
+    /**
+     * @return the number of milliseconds it took for a {@link flush}.
+     */
+    rtt(): Promise<number>;
+    /**
+     * Use of this API is experimental, and it is subject to be removed.
+     *
+     * reconnect() enables a client to force a reconnect. A reconnect will disconnect
+     * the client, and possibly initiate a reconnect to the cluster.  Note that all
+     * reconnect caveats apply:
+     *
+     * - If the reconnection policy given to the client doesn't allow reconnects, the
+     * connection will close.
+     *
+     * - Messages that are inbound or outbound could  be lost.
+     *
+     * - All requests that are in flight will be rejected.
+     *
+     * Note that the returned promise will reject if the client is already closed, or if
+     * it is in the process of draining. If the client is currently disconnected,
+     * this API has no effect, as the client is already attempting to reconnect.
+     */
+    reconnect(): Promise<void>;
+}
+/**
+ * A reviver function
+ */
+export type ReviverFn = (key: string, value: any) => any;
+/**
+ * Represents a message delivered by NATS. This interface is used by
+ * Subscribers.
+ */
+export interface Msg {
+    /**
+     * The subject the message was sent to
+     */
+    subject: string;
+    /**
+     * The subscription ID where the message was dispatched.
+     */
+    sid: number;
+    /**
+     * A possible subject where the recipient may publish a reply (in the cases
+     * where the message represents a request).
+     */
+    reply?: string;
+    /**
+     * The message's data (or payload)
+     */
+    data: Uint8Array;
+    /**
+     * Possible headers that may have been set by the server or the publisher.
+     */
+    headers?: MsgHdrs;
+    /**
+     * Convenience to publish a response to the {@link reply} subject in the
+     * message - this is the same as doing `nc.publish(msg.reply, ...)`.
+     * @param payload
+     * @param opts
+     */
+    respond(payload?: Payload, opts?: PublishOptions): boolean;
+    /**
+     * Convenience method to parse the message payload as JSON. This method
+     * will throw an exception if there's a parsing error;
+     * @param reviver a reviver function
+     */
+    json<T>(reviver?: ReviverFn): T;
+    /**
+     * Convenience method to parse the message payload as string. This method
+     * may throw an exception if there's a conversion error
+     */
+    string(): string;
+}
+export type SyncIterator<T> = {
+    next(): Promise<T | null>;
+};
+/**
+ * syncIterator is a utility function that allows an AsyncIterator to be triggered
+ * by calling next() - the utility will yield null if the underlying iterator is closed.
+ * Note it is possibly an error to call use this function on an AsyncIterable that has
+ * already been started (Symbol.asyncIterator() has been called) from a looping construct.
+ */
+export declare function syncIterator<T>(src: AsyncIterable<T>): SyncIterator<T>;
+/**
+ * Basic interface to a Subscription type
+ */
+export interface Subscription extends AsyncIterable<Msg> {
+    /**
+     * A promise that resolves when the subscription closes. If the promise
+     * resolves to an error, the subscription was closed because of an error
+     * typically a permissions error. Note that this promise doesn't reject, but
+     * rather resolves to void (no error) or an Error
+     */
+    closed: Promise<void | Error>;
+    /**
+     * Stop the subscription from receiving messages. You can optionally
+     * specify that the subscription should stop after the specified number
+     * of messages have been received. Note this count is since the lifetime
+     * of the subscription.
+     * @param max
+     */
+    unsubscribe(max?: number): void;
+    /**
+     * Drain the subscription, closing it after processing all messages
+     * currently in flight for the client. Returns a promise that resolves
+     * when the subscription finished draining.
+     */
+    drain(): Promise<void>;
+    /**
+     * Returns true if the subscription is draining.
+     */
+    isDraining(): boolean;
+    /**
+     * Returns true if the subscription is closed.
+     */
+    isClosed(): boolean;
+    /**
+     * @ignore
+     */
+    callback: MsgCallback<Msg>;
+    /**
+     * Returns the subject that was used to create the subscription.
+     */
+    getSubject(): string;
+    /**
+     * Returns the number of messages received by the subscription.
+     */
+    getReceived(): number;
+    /**
+     * Returns the number of messages that have been processed by the subscription.
+     */
+    getProcessed(): number;
+    /**
+     * Returns the number of messages that are pending processing. Note that this
+     * is method is only valid for iterators.
+     */
+    getPending(): number;
+    /** @ignore */
+    getID(): number;
+    /**
+     * Return the max number of messages before the subscription will unsubscribe.
+     */
+    getMax(): number | undefined;
+}
+export interface PublishOptions {
+    /**
+     * An optional subject where a response should be sent.
+     * Note you must have a subscription listening on this subject
+     * to receive the response.
+     */
+    reply?: string;
+    /**
+     * Optional headers to include with the message.
+     */
+    headers?: MsgHdrs;
+}
+/**
+ * Value expressed as Nanoseconds - use the `nanos(millis)` function
+ * to convert millis to nanoseconds. Note that in some environments this
+ * could overflow.
+ */
+export type Nanos = number;
+export type CallbackFn = () => void;
+export interface Dispatcher<T> {
+    push(v: T | CallbackFn): void;
+}
+export interface QueuedIterator<T> {
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    stop(err?: Error): void;
+    getProcessed(): number;
+    getPending(): number;
+    getReceived(): number;
+}
+export interface Publisher {
+    publish(subject: string, data: Payload, options?: {
+        reply?: string;
+        headers?: MsgHdrs;
+    }): void;
+}
+export declare function createInbox(prefix?: string): string;
+export interface Request {
+    token: string;
+    requestSubject: string;
+    received: number;
+    resolver(err: Error | null, msg: Msg): void;
+    cancel(err?: Error): void;
+}
+/**
+ * @type {}
+ */
+export type NoAuth = void;
+/**
+ * @type {auth_token: string} the user token
+ */
+export interface TokenAuth {
+    "auth_token": string;
+}
+/**
+ * @type {user: string, pass?: string} the username and
+ * optional password if the server requires.
+ */
+export interface UserPass {
+    user: string;
+    pass?: string;
+}
+/**
+ * @type {nkey: string, sig: string} the public nkey for the user,
+ * and a base64 encoded string for the calculated signature of the
+ * challenge nonce.
+ */
+export interface NKeyAuth {
+    nkey: string;
+    sig: string;
+}
+/**
+ * @type {jwt: string, nkey?: string, sig?: string} the user JWT,
+ * and if not a bearer token also the public nkey for the user,
+ * and a base64 encoded string for the calculated signature of the
+ * challenge nonce.
+ */
+export interface JwtAuth {
+    jwt: string;
+    nkey?: string;
+    sig?: string;
+}
+/**
+ * @type NoAuth|TokenAuth|UserPass|NKeyAuth|JwtAuth
+ */
+export type Auth = NoAuth | TokenAuth | UserPass | NKeyAuth | JwtAuth;
+/**
+ * Authenticator is an interface that returns credentials.
+ * @type function(nonce?: string) => Auth
+ */
+export interface Authenticator {
+    (nonce?: string): Auth;
+}
+export interface ConnectionOptions {
+    /**
+     * When the server requires authentication, set an {@link Authenticator}.
+     * An authenticator is created automatically for username/password and token
+     * authentication configurations
+     * if {@link user} and {@link pass} or the {@link token} options are set.
+     */
+    authenticator?: Authenticator | Authenticator[];
+    /**
+     * When set to `true` the client will print protocol messages that it receives
+     * or sends to the server.
+     */
+    debug?: boolean;
+    /**
+     * Sets the maximum count of ping commands that can be awaiting a response
+     * before raising a stale connection status {@link StaleConnectionStatus }
+     * notification {@link NatsConnection#status} and initiating a reconnect.
+     *
+     * @see pingInterval
+     */
+    maxPingOut?: number;
+    /**
+     * Sets the maximum count of per-server reconnect attempts before giving up.
+     * Set to `-1` to never give up.
+     *
+     * @default 10
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Sets the client name. When set, the server monitoring pages will display
+     * this name when referring to this client.
+     */
+    name?: string;
+    /**
+     * When set to true, messages published by this client will not match
+     * this client's subscriptions, so the client is guaranteed to never
+     * receive self-published messages on a subject that it is listening on.
+     */
+    noEcho?: boolean;
+    /**
+     * If set to true, the client will not randomize its server connection list.
+     */
+    noRandomize?: boolean;
+    /**
+     * Sets the password for a client connection. Requires that the {@link user}
+     * option be set. See {@link authenticator}.
+     */
+    pass?: string;
+    /**
+     * When set to true, the server may perform additional checks on protocol
+     * message requests. This option is only useful for NATS client development
+     * and shouldn't be used, as it affects server performance.
+     */
+    pedantic?: boolean;
+    /**
+     * Sets the number of milliseconds between client initiated ping commands.
+     * See {@link maxPingOut}.
+     * @default 2 minutes.
+     */
+    pingInterval?: number;
+    /**
+     * Sets the port number on the localhost (127.0.0.1) where the nats-server is running.
+     * This option is mutually exclusive with {@link servers}.
+     */
+    port?: number;
+    /**
+     * When set to true, the server will attempt to reconnect so long as
+     * {@link maxReconnectAttempts} doesn't prevent it.
+     * @default true
+     */
+    reconnect?: boolean;
+    /**
+     * Set a function that dynamically determines the number of milliseconds
+     * that the client should wait for the next reconnect attempt.
+     */
+    reconnectDelayHandler?: () => number;
+    /**
+     * Set the upper bound for a random delay in milliseconds added to
+     * {@link reconnectTimeWait}.
+     *
+     * @default 100 millis
+     */
+    reconnectJitter?: number;
+    /**
+     * Set the upper bound for a random delay in milliseconds added to
+     * {@link reconnectTimeWait}. This only affects TLS connections
+     *
+     * @default 1000 millis
+     */
+    reconnectJitterTLS?: number;
+    /**
+     * Set the number of millisecods between reconnect attempts.
+     *
+     * @default 2000 millis
+     */
+    reconnectTimeWait?: number;
+    /**
+     * Set the hostport(s) where the client should attempt to connect.
+     * This option is mutually exclusive with {@link port}.
+     *
+     * @default 127.0.0.1:4222
+     */
+    servers?: Array<string> | string;
+    /**
+     * Sets the number of milliseconds the client should wait for a server
+     * handshake to be established.
+     *
+     * @default 20000 millis
+     */
+    timeout?: number;
+    /**
+     * When set (can be an empty object), the client requires a secure connection.
+     * TlsOptions honored depend on the runtime. Consult the specific NATS javascript
+     * client GitHub repo/documentation. When set to null, the client should fail
+     * should not connect using TLS. In the case where TLS is available on the server
+     * a standard connection will be used. If TLS is required, the connection will fail.
+     */
+    tls?: TlsOptions | null;
+    /**
+     * Set to a client authentication token. Note that these tokens are
+     * a specific authentication strategy on the nats-server. This option
+     * is mutually exclusive of {@link user} and {@link pass}. See {@link authenticator}.
+     */
+    token?: string;
+    /**
+     * Sets the username for a client connection. Requires that the {@link pass}
+     * option be set. See {@link authenticator}.
+     */
+    user?: string;
+    /**
+     * When set to true, the server will send response to all server commands.
+     * This option is only useful for NATS client development and shouldn't
+     * be used, as it affects server performance.
+     */
+    verbose?: boolean;
+    /**
+     * When set to true {@link maxReconnectAttempts} will not trigger until the client
+     * has established one connection.
+     */
+    waitOnFirstConnect?: boolean;
+    /**
+     * When set to true, cluster information gossiped by the nats-server will
+     * not augment the lists of server(s) known by the client.
+     */
+    ignoreClusterUpdates?: boolean;
+    /**
+     * A string prefix (must be a valid subject prefix) prepended to inboxes
+     * generated by client. This allows a client with limited subject permissions
+     * to specify a subject where requests can deliver responses.
+     */
+    inboxPrefix?: string;
+    /**
+     * By default, NATS clients will abort reconnect if they fail authentication
+     * twice in a row with the same error, regardless of the reconnect policy.
+     * This option should be used with care as it will disable this behaviour when true
+     */
+    ignoreAuthErrorAbort?: boolean;
+    /**
+     * When true, the client will not augment timeout and other error traces with
+     * additional context as to where the operation was started.
+     */
+    noAsyncTraces?: boolean;
+    /**
+     * When false, the connect function will not perform any hostname resolution. Note that
+     * by default this option will be true if the client supports hostname resolution.
+     * Note that on clients that don't supported (mainly the websocket client, setting this
+     * option to true, will throw an exception as this option is not available.
+     */
+    resolve?: boolean;
+}
+/**
+ * TlsOptions that can be specified to a client. Note that
+ * the options are typically runtime specific, so some clients won't support
+ * them at all. In other cases they will match to the runtime's TLS options.
+ *
+ * If no options are specified, but the argument for TlsOptions is an object,
+ * the client is requesting to only use connections that are secured by TLS.
+ */
+export interface TlsOptions {
+    /**
+     * handshakeFirst option requires the server to be configured with `handshakeFirst: true`.
+     */
+    handshakeFirst?: boolean;
+    certFile?: string;
+    cert?: string;
+    caFile?: string;
+    ca?: string;
+    keyFile?: string;
+    key?: string;
+}
+export declare const DEFAULT_PORT = 4222;
+export declare const DEFAULT_HOST = "127.0.0.1";
+export type ConnectFn = (opts: ConnectionOptions) => Promise<NatsConnection>;
+export interface URLParseFn {
+    (u: string, encrypted?: boolean): string;
+}
+export type Context = {
+    server: ContextServer;
+    data: ContextUser;
+};
+export type ContextServer = {
+    name: string;
+    host: string;
+    id: string;
+    version: string;
+    tags: string[];
+    jetstream: boolean;
+    flags: number;
+    seq: number;
+    time: Date;
+};
+export type ContextUser = {
+    user: string;
+    account: string;
+    permissions?: {
+        publish?: ContextPermission;
+        subscribe?: ContextPermission;
+        responses?: ContextResponsePermission;
+    };
+};
+export type ContextPermission = {
+    deny?: string[];
+    allow?: string[];
+};
+export type ContextResponsePermission = {
+    max: number;
+    ttl: number;
+};
+export type RequestInfo = {
+    acc: string;
+    rtt: number;
+    start?: Date;
+    host?: string;
+    id?: string;
+    svc?: string;
+    user?: string;
+    name?: string;
+    lang?: string;
+    ver?: string;
+    server?: string;
+    cluster?: string;
+    alts?: string[];
+    stop?: Date;
+    jwt?: string;
+    issuer_key?: string;
+    name_tag?: string;
+    tags?: string[];
+    client_type?: string;
+    client_id?: string;
+    nonce?: string;
+};
+export type CallbackOptionalErrorFn = (err: Error | void) => void;
+export type ConnectionClosedListener = {
+    connectionClosedCallback: CallbackOptionalErrorFn;
+};
+//# sourceMappingURL=core.d.ts.map