@depup/sentry__node 10.75.1-depup.0 → 11.0.0-depup.0

package/build/types-ts3.8/integrations/tracing/hapi/types.d.ts

@@ -1,166 +0,0 @@
-import * as stream from 'stream';
-interface Podium {
-    new (events?: Events[]): Podium;
-    new (events?: Events): Podium;
-    registerEvent(events: Events[]): void;
-    registerEvent(events: Events): void;
-    registerPodium?(podiums: Podium[]): void;
-    registerPodium?(podiums: Podium): void;
-    emit(criteria: string | {
-        name: string;
-        channel?: string | undefined;
-        tags?: string | string[] | undefined;
-    }, data: any, callback?: () => void): void;
-    on(criteria: string | Criteria, listener: Listener): void;
-    addListener(criteria: string | Criteria, listener: Listener): void;
-    once(criteria: string | Criteria, listener: Listener): void;
-    removeListener(name: string, listener: Listener): Podium;
-    removeAllListeners(name: string): Podium;
-    hasListeners(name: string): boolean;
-}
-export interface Boom<Data = any> extends Error {
-    isBoom: boolean;
-    isServer: boolean;
-    message: string;
-    output: Output;
-    reformat: () => string;
-    isMissing?: boolean | undefined;
-    data: Data;
-}
-export interface Output {
-    statusCode: number;
-    headers: {
-        [index: string]: string;
-    };
-    payload: Payload;
-}
-export interface Payload {
-    statusCode: number;
-    error: string;
-    message: string;
-    attributes?: any;
-}
-export type Events = string | EventOptionsObject | Podium;
-export interface EventOptionsObject {
-    name: string;
-    channels?: string | string[] | undefined;
-    clone?: boolean | undefined;
-    spread?: boolean | undefined;
-    tags?: boolean | undefined;
-    shared?: boolean | undefined;
-}
-export interface CriteriaObject {
-    name: string;
-    block?: boolean | number | undefined;
-    channels?: string | string[] | undefined;
-    clone?: boolean | undefined;
-    count?: number | undefined;
-    filter?: string | string[] | CriteriaFilterOptionsObject | undefined;
-    spread?: boolean | undefined;
-    tags?: boolean | undefined;
-    listener?: Listener | undefined;
-}
-export interface CriteriaFilterOptionsObject {
-    tags?: string | string[] | undefined;
-    all?: boolean | undefined;
-}
-export type Criteria = string | CriteriaObject;
-export interface Listener {
-    (data: any, tags?: Tags, callback?: () => void): void;
-}
-export type Tags = {
-    [tag: string]: boolean;
-};
-interface UserCredentials {
-}
-interface AppCredentials {
-}
-interface AuthCredentials {
-    scope?: string[] | undefined;
-    user?: UserCredentials | undefined;
-    app?: AppCredentials | undefined;
-}
-interface RequestAuth {
-    artifacts: object;
-    credentials: AuthCredentials;
-    error: Error;
-    isAuthenticated: boolean;
-    isAuthorized: boolean;
-    mode: string;
-    strategy: string;
-}
-interface RequestEvents extends Podium {
-    on(criteria: 'peek', listener: PeekListener): void;
-    on(criteria: 'finish' | 'disconnect', listener: (data: undefined) => void): void;
-    once(criteria: 'peek', listener: PeekListener): void;
-    once(criteria: 'finish' | 'disconnect', listener: (data: undefined) => void): void;
-}
-declare namespace Lifecycle {
-    type Method = (request: Request, h: ResponseToolkit, err?: Error) => ReturnValue;
-    type ReturnValue = ReturnValueTypes | Promise<ReturnValueTypes>;
-    type ReturnValueTypes = (null | string | number | boolean) | Buffer | (Error | Boom) | stream.Stream | (object | object[]) | symbol | ResponseToolkit;
-    type FailAction = 'error' | 'log' | 'ignore' | Method;
-}
-declare namespace Util {
-    interface Dictionary<T> {
-        [key: string]: T;
-    }
-    type HTTP_METHODS_PARTIAL_LOWERCASE = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'options';
-    type HTTP_METHODS_PARTIAL = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | HTTP_METHODS_PARTIAL_LOWERCASE;
-    type HTTP_METHODS = 'HEAD' | 'head' | HTTP_METHODS_PARTIAL;
-}
-interface RequestRoute {
-    method: Util.HTTP_METHODS_PARTIAL;
-    path: string;
-    vhost?: string | string[] | undefined;
-    realm: any;
-    fingerprint: string;
-    auth: {
-        access(request: Request): boolean;
-    };
-}
-export interface Request extends Podium {
-    app: ApplicationState;
-    readonly auth: RequestAuth;
-    events: RequestEvents;
-    readonly headers: Util.Dictionary<string>;
-    readonly path: string;
-    response: ResponseObject | Boom | null;
-    readonly route: RequestRoute;
-    readonly url: URL;
-}
-interface ResponseObjectHeaderOptions {
-    append?: boolean | undefined;
-    separator?: string | undefined;
-    override?: boolean | undefined;
-    duplicate?: boolean | undefined;
-}
-export interface ResponseObject extends Podium {
-    readonly statusCode: number;
-    header(name: string, value: string, options?: ResponseObjectHeaderOptions): ResponseObject;
-}
-interface ResponseToolkit {
-    readonly continue: symbol;
-}
-export interface RequestEvent {
-    timestamp: string;
-    tags: string[];
-    channel: 'internal' | 'app' | 'error';
-    data: object;
-    error: object;
-}
-interface ServerEvents {
-    on(criteria: any, listener: any): void;
-}
-export type Server = Record<string, any> & {
-    events: ServerEvents;
-    register: any;
-    ext(event: any, method: Lifecycle.Method, options?: Record<string, any>): void;
-    initialize(): Promise<void>;
-    start(): Promise<void>;
-};
-interface ApplicationState {
-}
-type PeekListener = (chunk: string, encoding: string) => void;
-export {};
-//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/hapi/vendored/enums/AttributeNames.d.ts

@@ -1,6 +0,0 @@
-export declare enum AttributeNames {
-    HAPI_TYPE = "hapi.type",
-    PLUGIN_NAME = "hapi.plugin.name",
-    EXT_TYPE = "server.ext.type"
-}
-//# sourceMappingURL=AttributeNames.d.ts.map

package/build/types-ts3.8/integrations/tracing/hapi/vendored/hapi-types.d.ts

@@ -1,70 +0,0 @@
-export type ServerOptions = Record<string, any>;
-export declare function server(options?: ServerOptions): Server;
-export declare function Server(options?: ServerOptions): Server;
-export type ServerRequestExtType = 'onPreAuth' | 'onCredentials' | 'onPostAuth' | 'onPreHandler' | 'onPostHandler' | 'onPreResponse' | 'onRequest';
-export declare namespace Lifecycle {
-    type Method = (request: any, h: any, err?: Error) => ReturnValue;
-    type ReturnValue = any;
-    type FailAction = 'error' | 'log' | 'ignore' | Method;
-}
-export interface ServerRoute<T = any> {
-    path: string;
-    method: string;
-    handler?: Lifecycle.Method | T;
-    options?: ((server: Server) => ServerRouteOptions) | ServerRouteOptions;
-    [key: string]: any;
-}
-interface ServerRouteOptions {
-    handler?: Lifecycle.Method | any;
-    [key: string]: any;
-}
-export interface Server {
-    route: (...args: any[]) => any;
-    ext: (...args: any[]) => any;
-    register: (...args: any[]) => any;
-    [key: string]: any;
-}
-export interface Plugin<T, _V = void> {
-    register: (server: Server, options: T) => void | Promise<void>;
-    name?: string;
-    pkg?: {
-        name: string;
-        [key: string]: any;
-    };
-    [key: string]: any;
-}
-export interface PluginNameVersion {
-    name: string;
-    [key: string]: any;
-}
-export interface PluginPackage {
-    pkg: {
-        name: string;
-        [key: string]: any;
-    };
-    [key: string]: any;
-}
-export interface ServerRegisterPluginObject<T> {
-    plugin: Plugin<T, void> | {
-        plugin: Plugin<T, void>;
-        [key: string]: any;
-    };
-    [key: string]: any;
-}
-export interface ServerRegisterOptions {
-    [key: string]: any;
-}
-export interface ServerExtEventsObject {
-    type: string;
-    [key: string]: any;
-}
-export interface ServerExtEventsRequestObject {
-    type: ServerRequestExtType;
-    method: Lifecycle.Method;
-    [key: string]: any;
-}
-export interface ServerExtOptions {
-    [key: string]: any;
-}
-export {};
-//# sourceMappingURL=hapi-types.d.ts.map

package/build/types-ts3.8/integrations/tracing/hapi/vendored/instrumentation.d.ts

@@ -1,72 +0,0 @@
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-/** Hapi instrumentation for OpenTelemetry */
-export declare class HapiInstrumentation extends InstrumentationBase {
-    constructor(config?: InstrumentationConfig);
-    protected init(): InstrumentationNodeModuleDefinition;
-    /**
-     * Patches the Hapi.server and Hapi.Server functions in order to instrument
-     * the server.route, server.ext, and server.register functions via calls to the
-     * @function _getServerRoutePatch, @function _getServerExtPatch, and
-     * @function _getServerRegisterPatch functions
-     * @param original - the original Hapi Server creation function
-     */
-    private _getServerPatch;
-    /**
-     * Patches the plugin register function used by the Hapi Server. This function
-     * goes through each plugin that is being registered and adds instrumentation
-     * via a call to the @function _wrapRegisterHandler function.
-     * @param {RegisterFunction<T>} original - the original register function which
-     * registers each plugin on the server
-     */
-    private _getServerRegisterPatch;
-    /**
-     * Patches the Server.ext function which adds extension methods to the specified
-     * point along the request lifecycle. This function accepts the full range of
-     * accepted input into the standard Hapi `server.ext` function. For each extension,
-     * it adds instrumentation to the handler via a call to the @function _wrapExtMethods
-     * function.
-     * @param original - the original ext function which adds the extension method to the server
-     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
-     * for adding this server extension. Else, signifies that the extension was added directly
-     */
-    private _getServerExtPatch;
-    /**
-     * Patches the Server.route function. This function accepts either one or an array
-     * of Hapi.ServerRoute objects and adds instrumentation on each route via a call to
-     * the @function _wrapRouteHandler function.
-     * @param {HapiServerRouteInputMethod} original - the original route function which adds
-     * the route to the server
-     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
-     * for adding this server route. Else, signifies that the route was added directly
-     */
-    private _getServerRoutePatch;
-    /**
-     * Wraps newly registered plugins to add instrumentation to the plugin's clone of
-     * the original server. Specifically, wraps the server.route and server.ext functions
-     * via calls to @function _getServerRoutePatch and @function _getServerExtPatch
-     * @param {Hapi.Plugin<T>} plugin - the new plugin which is being instrumented
-     */
-    private _wrapRegisterHandler;
-    /**
-     * Wraps request extension methods to add instrumentation to each new extension handler.
-     * Patches each individual extension in order to create the
-     * span and propagate context. It does not create spans when there is no parent span.
-     * @param {PatchableExtMethod | PatchableExtMethod[]} method - the request extension
-     * handler which is being instrumented
-     * @param {Hapi.ServerRequestExtType} extPoint - the point in the Hapi request lifecycle
-     * which this extension targets
-     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
-     * for adding this server route. Else, signifies that the route was added directly
-     */
-    private _wrapExtMethods;
-    /**
-     * Patches each individual route handler method in order to create the
-     * span and propagate context. It does not create spans when there is no parent span.
-     * @param {PatchableServerRoute} route - the route handler which is being instrumented
-     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
-     * for adding this server route. Else, signifies that the route was added directly
-     */
-    private _wrapRouteHandler;
-}
-//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/hapi/vendored/internal-types.d.ts

@@ -1,32 +0,0 @@
-import * as Hapi from './hapi-types';
-export declare const HapiComponentName = "@hapi/hapi";
-/**
- * This symbol is used to mark a Hapi route handler or server extension handler as
- * already patched, since its possible to use these handlers multiple times
- * i.e. when allowing multiple versions of one plugin, or when registering a plugin
- * multiple times on different servers.
- */
-export declare const handlerPatched: unique symbol;
-export type HapiServerRouteInputMethod = (route: HapiServerRouteInput) => void;
-export type HapiServerRouteInput = PatchableServerRoute | PatchableServerRoute[];
-export type PatchableServerRoute = Hapi.ServerRoute<any> & {
-    [handlerPatched]?: boolean;
-};
-export type HapiPluginObject<T> = Hapi.ServerRegisterPluginObject<T>;
-export type HapiPluginInput<T> = HapiPluginObject<T> | Array<HapiPluginObject<T>>;
-export type RegisterFunction<T> = (plugin: HapiPluginInput<T>, options?: Hapi.ServerRegisterOptions) => Promise<void>;
-export type PatchableExtMethod = Hapi.Lifecycle.Method & {
-    [handlerPatched]?: boolean;
-};
-export type ServerExtDirectInput = [
-    Hapi.ServerRequestExtType,
-    Hapi.Lifecycle.Method,
-    (Hapi.ServerExtOptions | undefined)?
-];
-export declare const HapiLayerType: {
-    ROUTER: string;
-    PLUGIN: string;
-    EXT: string;
-};
-export declare const HapiLifecycleMethodNames: Set<string>;
-//# sourceMappingURL=internal-types.d.ts.map

package/build/types-ts3.8/integrations/tracing/hapi/vendored/utils.d.ts

@@ -1,18 +0,0 @@
-import { Attributes } from '@opentelemetry/api';
-import * as Hapi from './hapi-types';
-import { HapiPluginObject, PatchableExtMethod, ServerExtDirectInput } from './internal-types';
-export declare function getPluginName<T>(plugin: Hapi.Plugin<T>): string;
-export declare const isLifecycleExtType: (variableToCheck: unknown) => variableToCheck is Hapi.ServerRequestExtType;
-export declare const isLifecycleExtEventObj: (variableToCheck: unknown) => variableToCheck is Hapi.ServerExtEventsRequestObject;
-export declare const isDirectExtInput: (variableToCheck: unknown) => variableToCheck is ServerExtDirectInput;
-export declare const isPatchableExtMethod: (variableToCheck: PatchableExtMethod | PatchableExtMethod[]) => variableToCheck is PatchableExtMethod;
-export declare const getRouteMetadata: (route: Hapi.ServerRoute, pluginName?: string) => {
-    attributes: Attributes;
-    name: string;
-};
-export declare const getExtMetadata: (extPoint: Hapi.ServerRequestExtType, pluginName?: string, methodName?: string) => {
-    attributes: Attributes;
-    name: string;
-};
-export declare const getPluginFromInput: <T>(pluginObj: HapiPluginObject<T>) => Hapi.Plugin<T, void>;
-//# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/integrations/tracing/hono/constants.d.ts

@@ -1,11 +0,0 @@
-export declare const AttributeNames: {
-    readonly HONO_TYPE: "hono.type";
-    readonly HONO_NAME: "hono.name";
-};
-export type AttributeNames = (typeof AttributeNames)[keyof typeof AttributeNames];
-export declare const HonoTypes: {
-    readonly MIDDLEWARE: "middleware";
-    readonly REQUEST_HANDLER: "request_handler";
-};
-export type HonoTypes = (typeof HonoTypes)[keyof typeof HonoTypes];
-//# sourceMappingURL=constants.d.ts.map

package/build/types-ts3.8/integrations/tracing/hono/index.d.ts

@@ -1,60 +0,0 @@
-import { HonoInstrumentation } from './instrumentation';
-import { Context, MiddlewareHandlerInterface } from './types';
-export declare const instrumentHono: ((options?: unknown) => HonoInstrumentation) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for [Hono](https://hono.dev/).
- *
- * If you also want to capture errors, you need to call `setupHonoErrorHandler(app)` after you set up your Hono server.
- *
- * For more information, see the [hono documentation](https://docs.sentry.io/platforms/javascript/guides/hono/).
- *
- * @deprecated Use the `@sentry/hono` package instead. The `sentry()` middleware from `@sentry/hono/node` handles
- * tracing and error capturing automatically without needing this integration or `setupHonoErrorHandler`.
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *   integrations: [Sentry.honoIntegration()],
- * })
- * ```
- */
-export declare const honoIntegration: () => import("@sentry/core").Integration & {
-    name: "Hono";
-};
-interface HonoHandlerOptions {
-    /**
-     * Callback method deciding whether error should be captured and sent to Sentry
-     * @param error Captured Hono error
-     */
-    shouldHandleError: (context: Context) => boolean;
-}
-/**
- * Add a Hono error handler to capture errors to Sentry.
- *
- * @param app The Hono instances
- * @param options Configuration options for the handler
- *
- * @deprecated Use the `@sentry/hono` package instead. The `sentry()` middleware from `@sentry/hono/node` handles
- * error capturing automatically without needing this function or `honoIntegration`.
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- * const { Hono } = require("hono");
- *
- * const app = new Hono();
- *
- * Sentry.setupHonoErrorHandler(app);
- *
- * // Add your routes, etc.
- * ```
- */
-export declare function setupHonoErrorHandler(app: {
-    use: MiddlewareHandlerInterface;
-}, options?: Partial<HonoHandlerOptions>): void;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/hono/instrumentation.d.ts

@@ -1,55 +0,0 @@
-import { Span } from '@opentelemetry/api';
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-export interface HonoResponseHookFunction {
-    (span: Span): void;
-}
-export interface HonoInstrumentationConfig extends InstrumentationConfig {
-    /** Function for adding custom span attributes from the response */
-    responseHook?: HonoResponseHookFunction;
-}
-/**
- * Hono instrumentation for OpenTelemetry
- */
-export declare class HonoInstrumentation extends InstrumentationBase<HonoInstrumentationConfig> {
-    constructor(config?: HonoInstrumentationConfig);
-    /**
-     * Initialize the instrumentation.
-     */
-    init(): InstrumentationNodeModuleDefinition[];
-    /**
-     * Patches the module exports to instrument Hono.
-     */
-    private _patch;
-    /**
-     * Patches the route handler to instrument it.
-     */
-    private _patchHandler;
-    /**
-     * Patches the 'on' handler to instrument it.
-     */
-    private _patchOnHandler;
-    /**
-     * Patches the middleware handler to instrument it.
-     */
-    private _patchMiddlewareHandler;
-    /**
-     * Wraps a handler or middleware handler to apply instrumentation.
-     */
-    private _wrapHandler;
-    /**
-     * Safely executes a function and handles errors.
-     */
-    private _safeExecute;
-    /**
-     * Determines the handler type based on the result.
-     * @param result
-     * @private
-     */
-    private _determineHandlerType;
-    /**
-     * Handles errors by setting the span status and recording the exception.
-     */
-    private _handleError;
-}
-//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/hono/types.d.ts

@@ -1,36 +0,0 @@
-export type HonoRequest = {
-    path: string;
-    method: string;
-};
-export type Context = {
-    req: HonoRequest;
-    res: Response;
-    error: Error | undefined;
-};
-export type Next = () => Promise<void>;
-export type Handler = (c: Context, next: Next) => Promise<Response> | Response;
-export type MiddlewareHandler = (c: Context, next: Next) => Promise<Response | void>;
-export type HandlerInterface = {
-    (...handlers: (Handler | MiddlewareHandler)[]): HonoInstance;
-    (path: string, ...handlers: (Handler | MiddlewareHandler)[]): HonoInstance;
-};
-export type OnHandlerInterface = {
-    (method: string | string[], path: string | string[], ...handlers: (Handler | MiddlewareHandler)[]): HonoInstance;
-};
-export type MiddlewareHandlerInterface = {
-    (...handlers: MiddlewareHandler[]): HonoInstance;
-    (path: string, ...handlers: MiddlewareHandler[]): HonoInstance;
-};
-export interface HonoInstance {
-    get: HandlerInterface;
-    post: HandlerInterface;
-    put: HandlerInterface;
-    delete: HandlerInterface;
-    options: HandlerInterface;
-    patch: HandlerInterface;
-    all: HandlerInterface;
-    on: OnHandlerInterface;
-    use: MiddlewareHandlerInterface;
-}
-export type Hono = new (...args: unknown[]) => HonoInstance;
-//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/index.d.ts

@@ -1,12 +0,0 @@
-import { Integration } from '@sentry/core';
-/**
- * With OTEL, all performance integrations will be added, as OTEL only initializes them when the patched package is actually required.
- */
-export declare function getAutoPerformanceIntegrations(): Integration[];
-/**
- * Get a list of methods to instrument OTEL, when preload instrumentation.
- */
-export declare function getOpenTelemetryInstrumentationToPreload(): (((options?: any) => void) & {
-    id: string;
-})[];
-//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/kafka/index.d.ts

@@ -1,21 +0,0 @@
-import { KafkaJsInstrumentation } from './vendored/instrumentation';
-export declare const instrumentKafka: ((options?: unknown) => KafkaJsInstrumentation) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for the [kafkajs](https://www.npmjs.com/package/kafkajs) library.
- *
- * For more information, see the [`kafkaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/kafka/).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *  integrations: [Sentry.kafkaIntegration()],
- * });
- */
-export declare const kafkaIntegration: () => import("@sentry/core").Integration & {
-    name: "Kafka";
-};
-//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/kafka/vendored/instrumentation.d.ts

@@ -1,15 +0,0 @@
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-export declare class KafkaJsInstrumentation extends InstrumentationBase<InstrumentationConfig> {
-    constructor(config?: InstrumentationConfig);
-    protected init(): InstrumentationNodeModuleDefinition;
-    private _getConsumerPatch;
-    private _getProducerPatch;
-    private _getConsumerRunPatch;
-    private _getConsumerEachMessagePatch;
-    private _getConsumerEachBatchPatch;
-    private _getProducerTransactionPatch;
-    private _getSendBatchPatch;
-    private _getSendPatch;
-}
-//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/kafka/vendored/kafkajs-types.d.ts

@@ -1,79 +0,0 @@
-type Sender = {
-    send(record: any): Promise<any>;
-    sendBatch(batch: any): Promise<any>;
-};
-export type Producer = Sender & {
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isIdempotent(): boolean;
-    transaction(): Promise<Transaction>;
-    [key: string]: any;
-};
-export type Transaction = Sender & {
-    sendOffsets(offsets: any): Promise<void>;
-    commit(): Promise<void>;
-    abort(): Promise<void>;
-    isActive(): boolean;
-};
-export type Consumer = {
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    subscribe(subscription: any): Promise<void>;
-    run(config?: any): Promise<void>;
-    [key: string]: any;
-};
-export declare class Kafka {
-    consumer(config: any): Consumer;
-    producer(config?: any): Producer;
-    [key: string]: any;
-}
-export interface Message {
-    key?: Buffer | string | null;
-    value: Buffer | string | null;
-    partition?: number;
-    headers?: Record<string, Buffer | string | (Buffer | string)[] | undefined>;
-    timestamp?: string;
-}
-export type KafkaMessage = {
-    [key: string]: any;
-} & Message;
-export type RecordMetadata = {
-    topicName: string;
-    partition: number;
-    errorCode: number;
-    offset?: string;
-    timestamp?: string;
-    baseOffset?: string;
-    logAppendTime?: string;
-    logStartOffset?: string;
-};
-export interface EachMessagePayload {
-    topic: string;
-    partition: number;
-    message: KafkaMessage;
-    heartbeat(): Promise<void>;
-    pause(): () => void;
-}
-export interface EachBatchPayload {
-    batch: any;
-    resolveOffset(offset: string): void;
-    heartbeat(): Promise<void>;
-    pause(): () => void;
-    commitOffsetsIfNecessary(offsets?: any): Promise<void>;
-    uncommittedOffsets(): any;
-    isRunning(): boolean;
-    isStale(): boolean;
-}
-export type EachMessageHandler = (payload: EachMessagePayload) => Promise<void>;
-export type EachBatchHandler = (payload: EachBatchPayload) => Promise<void>;
-export type ConsumerRunConfig = {
-    autoCommit?: boolean;
-    autoCommitInterval?: number | null;
-    autoCommitThreshold?: number | null;
-    eachBatchAutoResolve?: boolean;
-    partitionsConsumedConcurrently?: number;
-    eachBatch?: EachBatchHandler;
-    eachMessage?: EachMessageHandler;
-};
-export {};
-//# sourceMappingURL=kafkajs-types.d.ts.map