@platformatic/kafka/dist/network/connection.d.ts

Modern and performant client for Apache Kafka

import EventEmitter from 'node:events';
import { type Socket } from 'node:net';
import { type ConnectionOptions as TLSConnectionOptions } from 'node:tls';
import { type CallbackWithPromise } from '../apis/callbacks.ts';
import { type Callback, type ResponseParser } from '../apis/definitions.ts';
import { type SASLMechanismValue } from '../apis/enumerations.ts';
import { Writer } from '../protocol/writer.ts';
export type SASLCredentialProvider = () => string | Promise<string>;
export interface Broker {
    host: string;
    port: number;
}
export interface SASLOptions {
    mechanism: SASLMechanismValue;
    username?: string | SASLCredentialProvider;
    password?: string | SASLCredentialProvider;
    token?: string | SASLCredentialProvider;
    authBytesValidator?: (authBytes: Buffer, callback: CallbackWithPromise<Buffer>) => void;
}
export interface ConnectionOptions {
    connectTimeout?: number;
    maxInflights?: number;
    tls?: TLSConnectionOptions;
    tlsServerName?: string | boolean;
    sasl?: SASLOptions;
    ownerId?: number;
    handleBackPressure?: boolean;
}
export interface Request {
    correlationId: number;
    apiKey: number;
    apiVersion: number;
    hasResponseHeaderTaggedFields: boolean;
    noResponse: boolean;
    payload: Buffer;
    parser: ResponseParser<unknown>;
    callback: Callback<any>;
    diagnostic: Record<string, unknown>;
}
export declare const ConnectionStatuses: {
    readonly NONE: "none";
    readonly CONNECTING: "connecting";
    readonly AUTHENTICATING: "authenticating";
    readonly CONNECTED: "connected";
    readonly CLOSED: "closed";
    readonly CLOSING: "closing";
    readonly ERROR: "error";
};
export type ConnectionStatus = keyof typeof ConnectionStatuses;
export type ConnectionStatusValue = (typeof ConnectionStatuses)[keyof typeof ConnectionStatuses];
export declare const defaultOptions: ConnectionOptions;
export declare class Connection extends EventEmitter {
    #private;
    constructor(clientId?: string, options?: ConnectionOptions);
    get host(): string | undefined;
    get port(): number | undefined;
    get instanceId(): number;
    get status(): ConnectionStatusValue;
    get socket(): Socket;
    isConnected(): boolean;
    connect(host: string, port: number, callback?: CallbackWithPromise<void>): void | Promise<void>;
    ready(callback: CallbackWithPromise<void>): void;
    ready(): Promise<void>;
    close(callback: CallbackWithPromise<void>): void;
    close(): Promise<void>;
    send<ReturnType>(apiKey: number, apiVersion: number, createPayload: () => Writer, responseParser: ResponseParser<ReturnType>, hasRequestHeaderTaggedFields: boolean, hasResponseHeaderTaggedFields: boolean, callback: Callback<ReturnType>): void;
}