/// /// /** * The version of the ØMQ library the bindings were built with. Formatted as * `(major).(minor).(patch)`. For example: `"4.3.2"`. */ export declare const version: string; /** * Exposes some of the optionally available ØMQ capabilities, which may depend * on the library version and platform. * * This is an object with keys corresponding to supported ØMQ features and * transport protocols. Available capabilities will be set to `true`. * Unavailable capabilities will be absent or set to `false`. * * Possible keys include: * * `ipc` - Support for the `ipc://` protocol. * * `pgm` - Support for the `pgm://` protocol. * * `tipc` - Support for the `tipc://` protocol. * * `norm` - Support for the `norm://` protocol. * * `curve` - Support for the CURVE security mechanism. * * `gssapi` - Support for the GSSAPI security mechanism. * * `draft` - Wether the library is built with support for DRAFT sockets. */ export declare const capability: Partial<{ ipc: boolean; pgm: boolean; tipc: boolean; norm: boolean; curve: boolean; gssapi: boolean; draft: boolean; }>; /** * Returns a new random key pair to be used with the CURVE security mechanism. * * To correctly connect two sockets with this mechanism: * * * Generate a **client** keypair with {@link curveKeyPair}(). * * Assign the private and public key on the client socket with * {@link Socket.curveSecretKey} and {@link Socket.curvePublicKey}. * * Generate a **server** keypair with {@link curveKeyPair}(). * * Assign the private key on the server socket with {@link Socket.curveSecretKey}. * * Assign the public key **on the client socket** with * {@link Socket.curveServerKey}. The server does *not* need to know its own * public key. Key distribution is *not* handled by the CURVE security * mechanism. * * * @returns An object with a `publicKey` and a `secretKey` property, each being * a 40 character Z85-encoded string. */ export declare function curveKeyPair(): { publicKey: string; secretKey: string; }; /** * A ØMQ context. Contexts manage the background I/O to send and receive * messages of their associated sockets. * * It is usually not necessary to instantiate a new context - the global * {@link context} is used for new sockets by default. The global context is the * only context that is shared between threads (when using * [worker_threads](https://nodejs.org/api/worker_threads.html)). Custom * contexts can only be used in the same thread. * * ```typescript * // Use default context (recommended). * const socket = new Dealer() * ``` * * ```typescript * // Use custom context. * const context = new Context() * const socket = new Dealer({context}) * ``` * * **Note:** By default all contexts (including the global context) will prevent * the process from terminating if there are any messages in an outgoing queue, * even if the associated socket was closed. For some applications this is * unnecessary or unwanted. Consider setting {@link Context.blocky} to `false` * or setting {@link Socket.linger} for each new socket. */ export declare class Context { /** * Creates a new ØMQ context and sets any provided context options. Sockets * need to be explicitly associated with a new context during construction. * * @param options An optional object with options that will be set on the * context during creation. */ constructor(options?: Options); protected getBoolOption(option: number): boolean; protected setBoolOption(option: number, value: boolean): void; protected getInt32Option(option: number): number; protected setInt32Option(option: number, value: number): void; } /** * Any socket that has no explicit context passed in during construction will * be associated with this context. The default context is exposed in order to * be able to change its behaviour with {@link Context} options. */ export declare const context: Context; interface ErrnoError extends Error { code: string; errno: number; } export interface AuthError extends Error { status: 300 | 400 | 500; } export interface ProtoError extends Error { code: "ERR_ZMTP_UNSPECIFIED" | "ERR_ZMTP_UNEXPECTED_COMMAND" | "ERR_ZMTP_INVALID_SEQUENCE" | "ERR_ZMTP_KEY_EXCHANGE" | "ERR_ZMTP_MALFORMED_COMMAND_UNSPECIFIED" | "ERR_ZMTP_MALFORMED_COMMAND_MESSAGE" | "ERR_ZMTP_MALFORMED_COMMAND_HELLO" | "ERR_ZMTP_MALFORMED_COMMAND_INITIATE" | "ERR_ZMTP_MALFORMED_COMMAND_ERROR" | "ERR_ZMTP_MALFORMED_COMMAND_READY" | "ERR_ZMTP_MALFORMED_COMMAND_WELCOME" | "ERR_ZMTP_INVALID_METADATA" | "ERR_ZMTP_CRYPTOGRAPHIC" | "ERR_ZMTP_MECHANISM_MISMATCH" | "ERR_ZAP_UNSPECIFIED" | "ERR_ZAP_MALFORMED_REPLY" | "ERR_ZAP_BAD_REQUEST_ID" | "ERR_ZAP_BAD_VERSION" | "ERR_ZAP_INVALID_STATUS_CODE" | "ERR_ZAP_INVALID_METADATA"; } export interface EventAddress { address: string; } export interface EventInterval { interval: number; } export interface EventError { error: E; } export type EventFor = Expand<{ type: T; } & D>; /** * A union type that represents all possible even types and the associated data. * Events always have a `type` property with an {@link EventType} value. * * The following socket events can be generated. This list may be different * depending on the ZeroMQ version that is used. * * Note that the **error** event is avoided by design, since this has a [special * behaviour](https://nodejs.org/api/events.html#events_error_events) in Node.js * causing an exception to be thrown if it is unhandled. * * Other error names are adjusted to be as close to possible as other * [networking related](https://nodejs.org/api/net.html) event names in Node.js * and/or to the corresponding ZeroMQ.js method call. Events (including any * errors) that correspond to a specific operation are namespaced with a colon * `:`, e.g. `bind:error` or `connect:retry`. * * * **accept** - ZMQ_EVENT_ACCEPTED The socket has accepted a connection from a * remote peer. * * * **accept:error** - ZMQ_EVENT_ACCEPT_FAILED The socket has rejected a * connection from a remote peer. * * The following additional details will be included with this event: * * * `error` - An error object that describes the specific error * that occurred. * * * **bind** - ZMQ_EVENT_LISTENING The socket was successfully bound to a * network interface. * * * **bind:error** - ZMQ_EVENT_BIND_FAILED The socket could not bind to a given * interface. * * The following additional details will be included with this event: * * * `error` - An error object that describes the specific error * that occurred. * * * **connect** - ZMQ_EVENT_CONNECTED The socket has successfully connected to * a remote peer. * * * **connect:delay** - ZMQ_EVENT_CONNECT_DELAYED A connect request on the * socket is pending. * * * **connect:retry** - ZMQ_EVENT_CONNECT_RETRIED A connection attempt is being * handled by reconnect timer. Note that the reconnect interval is * recalculated at each retry. * * The following additional details will be included with this event: * * * `interval` - The current reconnect interval. * * * **close** - ZMQ_EVENT_CLOSED The socket was closed. * * * **close:error** - ZMQ_EVENT_CLOSE_FAILED The socket close failed. Note that * this event occurs **only on IPC** transports.. * * The following additional details will be included with this event: * * * `error` - An error object that describes the specific error * that occurred. * * * **disconnect** - ZMQ_EVENT_DISCONNECTED The socket was disconnected * unexpectedly. * * * **handshake** - ZMQ_EVENT_HANDSHAKE_SUCCEEDED The ZMTP security mechanism * handshake succeeded. NOTE: This event may still be in DRAFT statea and not * yet available in stable releases. * * * **handshake:error:protocol** - ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL The ZMTP * security mechanism handshake failed due to some mechanism protocol error, * either between the ZMTP mechanism peers, or between the mechanism server * and the ZAP handler. This indicates a configuration or implementation error * in either peer resp. the ZAP handler. NOTE: This event may still be in * DRAFT state and not yet available in stable releases. * * * **handshake:error:auth** - ZMQ_EVENT_HANDSHAKE_FAILED_AUTH The ZMTP * security mechanism handshake failed due to an authentication failure. NOTE: * This event may still be in DRAFT state and not yet available in stable * releases. * * * **handshake:error:other** - ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL * Unspecified error during handshake. NOTE: This event may still be in DRAFT * state and not yet available in stable releases. * * * **end** - ZMQ_EVENT_MONITOR_STOPPED Monitoring on this socket ended. * * * **unknown** An event was generated by ZeroMQ that the Node.js library could * not interpret. Please submit a pull request for new event types if they are * not yet included. */ export type Event = EventFor<"accept", EventAddress> | EventFor<"accept:error", EventAddress & EventError> | EventFor<"bind", EventAddress> | EventFor<"bind:error", EventAddress & EventError> | EventFor<"connect", EventAddress> | EventFor<"connect:delay", EventAddress> | EventFor<"connect:retry", EventAddress & EventInterval> | EventFor<"close", EventAddress> | EventFor<"close:error", EventAddress & EventError> | EventFor<"disconnect", EventAddress> | EventFor<"end"> | EventFor<"handshake", EventAddress> | EventFor<"handshake:error:protocol", EventAddress & EventError> | EventFor<"handshake:error:auth", EventAddress & EventError> | EventFor<"handshake:error:other", EventAddress & EventError> | EventFor<"unknown">; /** * A union type of all available event types. See {@link Event} for an overview * of the events that can be observed. */ export type EventType = Event["type"]; /** * Represents the event data object given one particular event type, for example * `EventOfType<"accept">`. * * @typeparam E The specific event type. */ export type EventOfType = Expand>>; /** * An event observer for ØMQ sockets. This starts up a ZMQ monitoring socket * internally that receives all socket events. The event observer can be used in * one of two ways, which are **mutually exclusive**: with {@link receive}() or * with event listeners attached with {@link on}(). */ export declare class Observer { /** * Whether the observer was closed, either manually or because the associated * socket was closed. * * @readonly */ readonly closed: boolean; /** * Creates a new ØMQ observer. It should not be necessary to instantiate a new * observer. Access an existing observer for a socket with * {@link Socket.events}. * * ```typescript * const socket = new Publisher() * const events = socket.events * ``` * * @param socket The socket to observe. */ constructor(socket: Socket); /** * Closes the observer. Afterwards no new events will be received or emitted. * Calling this method is optional. */ close(): void; /** * Waits for the next event to become availeble on the observer. Reads an * event immediately if possible. If no events are queued, it will wait * asynchonously. The promise will be resolved with the next event when * available. * * When reading events with {@link receive}() the observer may **not** be in * event emitter mode. Avoid mixing calls to {@link receive}() with event * handlers via attached with {@link on}(). * * ```typescript * for await (event of socket.events) { * switch (event.type) { * case "bind": * console.log(`Socket bound to ${event.address}`) * break * // ... * } * } * ``` * * @returns Resolved with the next event and its details. See {@link Event}. */ receive(): Promise; } /** * Proxy messages between two ØMQ sockets. The proxy connects a front-end socket * to a back-end socket. Conceptually, data flows from front-end to back-end. * Depending on the socket types, replies may flow in the opposite direction. * The direction is conceptual only; the proxy is fully symmetric and there is * no technical difference between front-end and back-end. * * ```typescript * // Proxy between a router/dealer socket for 5 seconds. * const proxy = new Proxy(new Router, new Dealer) * await proxy.frontEnd.bind("tcp://*:3001") * await proxy.backEnd.bind("tcp://*:3002") * setTimeout(() => proxy.terminate(), 5000) * await proxy.run() * ``` * * [Review the ØMQ documentation](http://api.zeromq.org/4-3:zmq-proxy#toc3) for * an overview of some example applications of a proxy. * * @typeparam F The front-end socket type. * @typeparam B The back-end socket type. */ export declare class Proxy { /** * Returns the original front-end socket. * * @readonly */ readonly frontEnd: F; /** * Returns the original back-end socket. * * @readonly */ readonly backEnd: B; /** * Creates a new ØMQ proxy. Proxying will start between the front-end and * back-end sockets when {@link run}() is called after both sockets have been * bound or connected. * * @param frontEnd The front-end socket. * @param backEnd The back-end socket. */ constructor(frontEnd: F, backEnd: B); /** * Starts the proxy loop in a worker thread and waits for its termination. * Before starting, you must set any socket options, and connect or bind both * front-end and back-end sockets. * * On termination the front-end and back-end sockets will be closed * automatically. * * @returns Resolved when the proxy has terminated. */ run(): Promise; /** * Temporarily suspends any proxy activity. Resume activity with * {@link resume}(). */ pause(): void; /** * Resumes proxy activity after suspending it with {@link pause}(). */ resume(): void; /** * Gracefully shuts down the proxy. The front-end and back-end sockets will be * closed automatically. There might be a slight delay between terminating and * the {@link run}() method resolving. */ terminate(): void; } /** * A ØMQ socket. This class should generally not be used directly. Instead, * create one of its subclasses that corresponds to the socket type you want to * use. * * ```typescript * new zmq.Pair(...) * new zmq.Publisher(...) * new zmq.Subscriber(...) * new zmq.Request(...) * new zmq.Reply(...) * new zmq.Dealer(...) * new zmq.Router(...) * new zmq.Pull(...) * new zmq.Push(...) * new zmq.XPublisher(...) * new zmq.XSubscriber(...) * new zmq.Stream(...) * ``` * * Socket options can be set during construction or via a property after the * socket was created. Most socket options do not take effect until the next * {@link bind}() or {@link connect}() call. Setting such an option after the * socket is already connected or bound will display a warning. */ export declare abstract class Socket { /** * Event {@link Observer} for this socket. This starts up a ØMQ monitoring * socket internally that receives all socket events. * * @readonly */ readonly events: Observer; /** * {@link Context} that this socket belongs to. * * @readonly */ readonly context: Context; /** * Whether this socket was previously closed with {@link close}(). * * @readonly */ readonly closed: boolean; /** * Whether any messages are currently available. If `true`, the next call to * {@link Readable.receive}() will immediately read a message from the socket. * For sockets that cannot receive messsages this is always `false`. * * @readonly */ readonly readable: boolean; /** * Whether any messages can be queued for sending. If `true`, the next call to * {@link Writable.send}() will immediately queue a message on the socket. * For sockets that cannot send messsages this is always `false`. * * @readonly */ readonly writable: boolean; /** * Creates a new socket of the specified type. Subclasses are expected to * provide the correct socket type. * * @param type The socket type. * @param options Any options to set during construction. */ protected constructor(type: SocketType, options?: {}); /** * Closes the socket and disposes of all resources. Any messages that are * queued may be discarded or sent in the background depending on the * {@link linger} setting. * * After this method is called, it is no longer possible to call any other * methods on this socket. * * Sockets that go out of scope and have no {@link Readable.receive}() or * {@link Writable.send}() operations in progress will automatically be * closed. Therefore it is not necessary in most applications to call * {@link close}() manually. * * Calling this method on a socket that is already closed is a no-op. */ close(): void; /** * Binds the socket to the given address. During {@link bind}() the socket * cannot be used. Do not call any other methods until the returned promise * resolves. Make sure to use `await`. * * You can use `*` in place of a hostname to bind on all interfaces/addresses, * and you can use `*` in place of a port to bind to a random port (which can * be retrieved with {@link lastEndpoint} later). * * ```typescript * await socket.bind("tcp://127.0.0.1:3456") * await socket.bind("tcp://*:3456") // binds on all interfaces * await socket.bind("tcp://127.0.0.1:*") // binds on random port * ``` * * @param address Address to bind this socket to. * @returns Resolved when the socket was successfully bound. */ bind(address: string): Promise; /** * Unbinds the socket to the given address. During {@link unbind}() the socket * cannot be used. Do not call any other methods until the returned promise * resolves. Make sure to use `await`. * * @param address Address to unbind this socket from. * @returns Resolved when the socket was successfully unbound. */ unbind(address: string): Promise; /** * Connects to the socket at the given remote address and returns immediately. * The connection will be made asynchronously in the background. * * ```typescript * socket.connect("tcp://127.0.0.1:3456") * ``` * * @param address The address to connect to. */ connect(address: string): void; /** * Disconnects a previously connected socket from the given address and * returns immediately. Disonnection will happen asynchronously in the * background. * * ```typescript * socket.disconnect("tcp://127.0.0.1:3456") * ``` * * @param address The previously connected address to disconnect from. */ disconnect(address: string): void; protected getBoolOption(option: number): boolean; protected setBoolOption(option: number, value: boolean): void; protected getInt32Option(option: number): number; protected setInt32Option(option: number, value: number): void; protected getUint32Option(option: number): number; protected setUint32Option(option: number, value: number): void; protected getInt64Option(option: number): number; protected setInt64Option(option: number, value: number): void; protected getUint64Option(option: number): number; protected setUint64Option(option: number, value: number): void; protected getStringOption(option: number): string | null; protected setStringOption(option: number, value: string | Buffer | null): void; } export declare const enum SocketType { Pair = 0, Publisher = 1, Subscriber = 2, Request = 3, Reply = 4, Dealer = 5, Router = 6, Pull = 7, Push = 8, XPublisher = 9, XSubscriber = 10, Stream = 11, Server = 12, Client = 13, Radio = 14, Dish = 15, Gather = 16, Scatter = 17, Datagram = 18 } type IfEquals = (() => T extends X ? 1 : 2) extends () => T extends Y ? 1 : 2 ? A : B; export type Expand = T extends infer O ? { [K in keyof O]: O[K]; } : never; /** @internal */ export type ReadableKeys = { [P in keyof T]-?: T[P] extends Function ? never : P; }[keyof T]; /** @internal */ export type WritableKeys = { [P in keyof T]-?: T[P] extends Function ? never : IfEquals<{ [Q in P]: T[P]; }, { -readonly [Q in P]: T[P]; }, P>; }[keyof T]; export type Options = Expand>>>; export {};