@sentry/node 10.53.0 → 10.54.0

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

@@ -0,0 +1,121 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { Span } from '@opentelemetry/api';
+export interface MongoDBInstrumentationExecutionResponseHook {
+    (span: Span, responseInfo: MongoResponseHookInformation): void;
+}
+/**
+ * Function that can be used to serialize db.statement tag
+ * @param cmd - MongoDB command object
+ *
+ * @returns serialized string that will be used as the db.statement attribute.
+ */
+export type DbStatementSerializer = (cmd: Record<string, unknown>) => string;
+export interface MongoDBInstrumentationConfig extends InstrumentationConfig {
+    /**
+     * If true, additional information about query parameters and
+     * results will be attached (as `attributes`) to spans representing
+     * database operations.
+     */
+    enhancedDatabaseReporting?: boolean;
+    /**
+     * Hook that allows adding custom span attributes based on the data
+     * returned from MongoDB actions.
+     *
+     * @default undefined
+     */
+    responseHook?: MongoDBInstrumentationExecutionResponseHook;
+    /**
+     * Custom serializer function for the db.statement tag
+     */
+    dbStatementSerializer?: DbStatementSerializer;
+}
+export type Func<T> = (...args: unknown[]) => T;
+export type MongoInternalCommand = {
+    findandmodify: boolean;
+    createIndexes: boolean;
+    count: boolean;
+    aggregate: boolean;
+    ismaster: boolean;
+    indexes?: unknown[];
+    query?: Record<string, unknown>;
+    limit?: number;
+    q?: Record<string, unknown>;
+    u?: Record<string, unknown>;
+};
+export type ServerSession = {
+    id: any;
+    lastUse: number;
+    txnNumber: number;
+    isDirty: boolean;
+};
+export type CursorState = {
+    cmd: MongoInternalCommand;
+} & Record<string, unknown>;
+export interface MongoResponseHookInformation {
+    data: CommandResult;
+}
+export type CommandResult = {
+    result?: unknown;
+    connection?: unknown;
+    message?: unknown;
+};
+export type WireProtocolInternal = {
+    insert: (server: MongoInternalTopology, ns: string, ops: unknown[], options: unknown | Function, callback?: Function) => unknown;
+    update: (server: MongoInternalTopology, ns: string, ops: unknown[], options: unknown | Function, callback?: Function) => unknown;
+    remove: (server: MongoInternalTopology, ns: string, ops: unknown[], options: unknown | Function, callback?: Function) => unknown;
+    killCursors: (server: MongoInternalTopology, ns: string, cursorState: CursorState, callback: Function) => unknown;
+    getMore: (server: MongoInternalTopology, ns: string, cursorState: CursorState, batchSize: number, options: unknown | Function, callback?: Function) => unknown;
+    query: (server: MongoInternalTopology, ns: string, cmd: MongoInternalCommand, cursorState: CursorState, options: unknown | Function, callback?: Function) => unknown;
+    command: (server: MongoInternalTopology, ns: string, cmd: MongoInternalCommand, options: unknown | Function, callback?: Function) => unknown;
+};
+export type MongoInternalTopology = {
+    s?: {
+        options?: {
+            host?: string;
+            port?: number;
+            servername?: string;
+        };
+        host?: string;
+        port?: number;
+    };
+    description?: {
+        address?: string;
+    };
+};
+export declare enum MongodbCommandType {
+    CREATE_INDEXES = "createIndexes",
+    FIND_AND_MODIFY = "findAndModify",
+    IS_MASTER = "isMaster",
+    COUNT = "count",
+    AGGREGATE = "aggregate",
+    UNKNOWN = "unknown"
+}
+export type Document = {
+    [key: string]: any;
+};
+export interface MongodbNamespace {
+    db: string;
+    collection?: string;
+}
+export type V4Connection = {
+    command: Function;
+    commandPromise(ns: MongodbNamespace, cmd: Document, options: undefined | unknown, responseType: undefined | unknown): Promise<any>;
+    commandCallback(ns: MongodbNamespace, cmd: Document, options: undefined | unknown, callback: any): void;
+};
+export type V4ConnectionPool = {
+    checkOut: (callback: (error: any, connection: any) => void) => void;
+};
+export type V4Connect = {
+    connect: Function;
+    connectPromise: (options: any) => Promise<any>;
+    connectCallback: (options: any, callback: any) => void;
+};
+export type V4Session = {
+    acquire: () => ServerSession;
+    release: (session: ServerSession) => void;
+};
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#replacer
+ */
+export type Replacer = (key: string, value: unknown) => unknown;
+//# sourceMappingURL=internal-types.d.ts.map

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

@@ -0,0 +1,107 @@
+/**
+ * Deprecated, use `server.address`, `server.port` attributes instead.
+ *
+ * @example "Server=(localdb)\\v11.0;Integrated Security=true;"
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.address` and `server.port`.
+ */
+export declare const ATTR_DB_CONNECTION_STRING: "db.connection_string";
+/**
+ * Deprecated, use `db.collection.name` instead.
+ *
+ * @example "mytable"
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.collection.name`.
+ */
+export declare const ATTR_DB_MONGODB_COLLECTION: "db.mongodb.collection";
+/**
+ * Deprecated, use `db.namespace` instead.
+ *
+ * @example customers
+ * @example main
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.namespace`.
+ */
+export declare const ATTR_DB_NAME: "db.name";
+/**
+ * Deprecated, use `db.operation.name` instead.
+ *
+ * @example findAndModify
+ * @example HMSET
+ * @example SELECT
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.operation.name`.
+ */
+export declare const ATTR_DB_OPERATION: "db.operation";
+/**
+ * The database statement being executed.
+ *
+ * @example SELECT * FROM wuser_table
+ * @example SET mykey "WuValue"
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.query.text`.
+ */
+export declare const ATTR_DB_STATEMENT: "db.statement";
+/**
+ * Deprecated, use `db.system.name` instead.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.system.name`.
+ */
+export declare const ATTR_DB_SYSTEM: "db.system";
+/**
+ * Deprecated, use `server.address` on client spans and `client.address` on server spans.
+ *
+ * @example example.com
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.address` on client spans and `client.address` on server spans.
+ */
+export declare const ATTR_NET_PEER_NAME: "net.peer.name";
+/**
+ * Deprecated, use `server.port` on client spans and `client.port` on server spans.
+ *
+ * @example 8080
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.port` on client spans and `client.port` on server spans.
+ */
+export declare const ATTR_NET_PEER_PORT: "net.peer.port";
+/**
+ * Enum value "mongodb" for attribute {@link ATTR_DB_SYSTEM_NAME}.
+ *
+ * [MongoDB](https://www.mongodb.com/)
+ *
+ * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const DB_SYSTEM_NAME_VALUE_MONGODB: "mongodb";
+/**
+ * Enum value "mongodb" for attribute {@link ATTR_DB_SYSTEM}.
+ *
+ * MongoDB
+ *
+ * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const DB_SYSTEM_VALUE_MONGODB: "mongodb";
+/**
+ * Deprecated, use `db.client.connection.count` instead.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.client.connection.count`.
+ */
+export declare const METRIC_DB_CLIENT_CONNECTIONS_USAGE: "db.client.connections.usage";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,51 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { Span } from '@opentelemetry/api';
+export interface MongoDBInstrumentationExecutionResponseHook {
+    (span: Span, responseInfo: MongoResponseHookInformation): void;
+}
+/**
+ * Function that can be used to serialize db.statement tag
+ * @param cmd - MongoDB command object
+ *
+ * @returns serialized string that will be used as the db.statement attribute.
+ */
+export type DbStatementSerializer = (cmd: Record<string, unknown>) => string;
+export interface MongoDBInstrumentationConfig extends InstrumentationConfig {
+    /**
+     * If true, additional information about query parameters and
+     * results will be attached (as `attributes`) to spans representing
+     * database operations.
+     */
+    enhancedDatabaseReporting?: boolean;
+    /**
+     * Hook that allows adding custom span attributes based on the data
+     * returned from MongoDB actions.
+     *
+     * @default undefined
+     */
+    responseHook?: MongoDBInstrumentationExecutionResponseHook;
+    /**
+     * Custom serializer function for the db.statement tag
+     */
+    dbStatementSerializer?: DbStatementSerializer;
+    /**
+     * Require parent to create mongodb span, default when unset is true
+     */
+    requireParentSpan?: boolean;
+}
+export interface MongoResponseHookInformation {
+    data: CommandResult;
+}
+export type CommandResult = {
+    result?: unknown;
+    connection?: unknown;
+    message?: unknown;
+};
+export declare enum MongodbCommandType {
+    CREATE_INDEXES = "createIndexes",
+    FIND_AND_MODIFY = "findAndModify",
+    IS_MASTER = "isMaster",
+    COUNT = "count",
+    UNKNOWN = "unknown"
+}
+//# sourceMappingURL=types.d.ts.map

package/build/{types/integrations/tracing/mongoose.d.ts → types-ts3.8/integrations/tracing/mongoose/index.d.ts}

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

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

@@ -0,0 +1,30 @@
+export interface Collection {
+    name: string;
+    conn: Connection;
+    [key: string]: any;
+}
+export interface Connection {
+    name: string;
+    host: string;
+    port: number;
+    user?: string;
+    [key: string]: any;
+}
+export declare const Model: {
+    prototype: any;
+    collection: Collection;
+    modelName: string;
+    aggregate: Function;
+    insertMany: Function;
+    bulkWrite: Function;
+    [key: string]: any;
+};
+export declare const Query: {
+    prototype: any;
+    [key: string]: any;
+};
+export declare const Aggregate: {
+    prototype: any;
+    [key: string]: any;
+};
+//# sourceMappingURL=mongoose-types.d.ts.map

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

@@ -0,0 +1,24 @@
+import { MongooseInstrumentationConfig } from './types';
+import { InstrumentationBase, InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
+export declare const _STORED_PARENT_SPAN: unique symbol;
+export declare const _ALREADY_INSTRUMENTED: unique symbol;
+export declare class MongooseInstrumentation extends InstrumentationBase<MongooseInstrumentationConfig> {
+    private _netSemconvStability;
+    private _dbSemconvStability;
+    constructor(config?: MongooseInstrumentationConfig);
+    private _setSemconvStabilityFromEnv;
+    protected init(): InstrumentationModuleDefinition;
+    private patch;
+    private unpatch;
+    private patchAggregateExec;
+    private patchQueryExec;
+    private patchOnModelMethods;
+    private _patchDocumentUpdateMethods;
+    private patchModelStatic;
+    private patchModelAggregate;
+    private patchAndCaptureSpanContext;
+    private _startSpan;
+    private _handleResponse;
+    private _callOriginalFunction;
+}
+//# sourceMappingURL=mongoose.d.ts.map

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

@@ -0,0 +1,71 @@
+/**
+ * Deprecated, use `db.collection.name` instead.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.collection.name`.
+ */
+export declare const ATTR_DB_MONGODB_COLLECTION: "db.mongodb.collection";
+/**
+ * Deprecated, use `db.namespace` instead.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.namespace`.
+ */
+export declare const ATTR_DB_NAME: "db.name";
+/**
+ * Deprecated, use `db.operation.name` instead.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.operation.name`.
+ */
+export declare const ATTR_DB_OPERATION: "db.operation";
+/**
+ * The database statement being executed.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.query.text`.
+ */
+export declare const ATTR_DB_STATEMENT: "db.statement";
+/**
+ * Deprecated, use `db.system.name` instead.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.system.name`.
+ */
+export declare const ATTR_DB_SYSTEM: "db.system";
+/**
+ * Deprecated, no replacement at this time.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Removed, no replacement at this time.
+ */
+export declare const ATTR_DB_USER: "db.user";
+/**
+ * Deprecated, use `server.address` on client spans and `client.address` on server spans.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.address` on client spans and `client.address` on server spans.
+ */
+export declare const ATTR_NET_PEER_NAME: "net.peer.name";
+/**
+ * Deprecated, use `server.port` on client spans and `client.port` on server spans.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.port` on client spans and `client.port` on server spans.
+ */
+export declare const ATTR_NET_PEER_PORT: "net.peer.port";
+/**
+ * Enum value "mongodb" for attribute {@link ATTR_DB_SYSTEM_NAME}.
+ *
+ * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const DB_SYSTEM_NAME_VALUE_MONGODB: "mongodb";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,36 @@
+import { Span } from '@opentelemetry/api';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export interface SerializerPayload {
+    condition?: any;
+    options?: any;
+    updates?: any;
+    document?: any;
+    aggregatePipeline?: any;
+    fields?: any;
+    documents?: any;
+    operations?: any;
+}
+export type DbStatementSerializer = (operation: string, payload: SerializerPayload) => string;
+export interface ResponseInfo {
+    moduleVersion: string | undefined;
+    response: any;
+}
+export type MongooseResponseCustomAttributesFunction = (span: Span, responseInfo: ResponseInfo) => void;
+export interface MongooseInstrumentationConfig extends InstrumentationConfig {
+    /**
+     * Mongoose operation use mongodb under the hood.
+     * If mongodb instrumentation is enabled, a mongoose operation will also create
+     * a mongodb operation describing the communication with mongoDB servers.
+     * Setting the `suppressInternalInstrumentation` config value to `true` will
+     * cause the instrumentation to suppress instrumentation of underlying operations,
+     * effectively causing mongodb spans to be non-recordable.
+     */
+    suppressInternalInstrumentation?: boolean;
+    /** Custom serializer function for the db.statement tag */
+    dbStatementSerializer?: DbStatementSerializer;
+    /** hook for adding custom attributes using the response payload */
+    responseHook?: MongooseResponseCustomAttributesFunction;
+    /** Set to true if you do not want to collect traces that start with mongoose */
+    requireParentSpan?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,8 @@
+import { Attributes, Span } from '@opentelemetry/api';
+import { Collection } from './mongoose-types';
+import { MongooseResponseCustomAttributesFunction } from './types';
+import { SemconvStability } from '@opentelemetry/instrumentation';
+export declare function getAttributesFromCollection(collection: Collection, dbSemconvStability: SemconvStability, netSemconvStability: SemconvStability): Attributes;
+export declare function handlePromiseResponse(execResponse: any, span: Span, responseHook?: MongooseResponseCustomAttributesFunction, moduleVersion?: string | undefined): any;
+export declare function handleCallbackResponse(callback: Function, exec: Function, originalThis: any, span: Span, args: IArguments, responseHook?: MongooseResponseCustomAttributesFunction, moduleVersion?: string | undefined): any;
+//# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/integrations/tracing/{mysql.d.ts → mysql/index.d.ts}

@@ -1,4 +1,4 @@
-import { MySQLInstrumentation } from '@opentelemetry/instrumentation-mysql';
+import { MySQLInstrumentation } from './vendored/instrumentation';
 export declare const instrumentMysql: ((options?: unknown) => MySQLInstrumentation) & {
     id: string;
 };
@@ -17,4 +17,4 @@ export declare const instrumentMysql: ((options?: unknown) => MySQLInstrumentati
  * ```
  */
 export declare const mysqlIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=mysql.d.ts.map
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,4 @@
+export declare enum AttributeNames {
+    MYSQL_VALUES = "db.mysql.values"
+}
+//# sourceMappingURL=AttributeNames.d.ts.map

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

@@ -0,0 +1,28 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { MySQLInstrumentationConfig } from './types';
+export declare class MySQLInstrumentation extends InstrumentationBase<MySQLInstrumentationConfig> {
+    private _netSemconvStability;
+    private _dbSemconvStability;
+    private _connectionsUsageOld;
+    constructor(config?: MySQLInstrumentationConfig);
+    private _setSemconvStabilityFromEnv;
+    protected _updateMetricInstruments(): void;
+    /**
+     * Convenience function for updating the `db.client.connections.usage` metric.
+     * The name "count" comes from the eventually replacement for this metric per
+     * https://opentelemetry.io/docs/specs/semconv/non-normative/db-migration/#database-client-connection-count
+     */
+    private _connCountAdd;
+    protected init(): InstrumentationNodeModuleDefinition[];
+    private _patchCreateConnection;
+    private _patchCreatePool;
+    private _patchPoolEnd;
+    private _patchCreatePoolCluster;
+    private _patchAdd;
+    private _patchGetConnection;
+    private _getConnectionCallbackPatchFn;
+    private _patchQuery;
+    private _patchCallbackQuery;
+    private _setPoolCallbacks;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,78 @@
+export interface MysqlError extends Error {
+    code: string;
+    errno: number;
+    fatal: boolean;
+    sql?: string;
+    sqlState?: string;
+    sqlMessage?: string;
+    [key: string]: any;
+}
+export interface ConnectionConfig {
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    [key: string]: any;
+}
+export interface PoolConfig extends ConnectionConfig {
+    connectionConfig?: ConnectionConfig;
+    [key: string]: any;
+}
+export interface QueryOptions {
+    sql: string;
+    values?: any;
+    [key: string]: any;
+}
+export interface FieldInfo {
+    catalog: string;
+    db: string;
+    table: string;
+    orgTable: string;
+    name: string;
+    orgName: string;
+    charsetNr: number;
+    length: number;
+    type: number;
+    [key: string]: any;
+}
+export type queryCallback = (err: MysqlError | null, results?: any, fields?: FieldInfo[]) => void;
+export interface Query {
+    sql: string;
+    values?: any;
+    on(event: string, listener: (...args: any[]) => void): this;
+    [key: string]: any;
+}
+export type QueryFunction = {
+    (query: string | QueryOptions, callback?: queryCallback): Query;
+    (query: string | QueryOptions, values?: any, callback?: queryCallback): Query;
+};
+export interface Connection {
+    config: ConnectionConfig;
+    query: QueryFunction;
+    [key: string]: any;
+}
+export interface PoolConnection extends Connection {
+    release(): void;
+    [key: string]: any;
+}
+export interface Pool {
+    config: PoolConfig;
+    query: QueryFunction;
+    getConnection(callback: (err: MysqlError, connection: PoolConnection) => void): void;
+    end(callback?: (err?: MysqlError) => void): void;
+    on(event: string, listener: (...args: any[]) => void): this;
+    [key: string]: any;
+}
+export interface PoolCluster {
+    getConnection(callback: (err: MysqlError, connection: PoolConnection) => void): void;
+    getConnection(pattern: string, callback: (err: MysqlError, connection: PoolConnection) => void): void;
+    getConnection(pattern: string, selector: string, callback: (err: MysqlError, connection: PoolConnection) => void): void;
+    add(config: PoolConfig): void;
+    add(id: string, config: PoolConfig): void;
+    [key: string]: any;
+}
+export declare function createConnection(connectionUri: string | ConnectionConfig): Connection;
+export declare function createPool(config: string | PoolConfig): Pool;
+export declare function createPoolCluster(config?: PoolConfig): PoolCluster;
+//# sourceMappingURL=mysql-types.d.ts.map