plugin-data-source-mssql 1.9.48 → 2.0.1

package/dist/node_modules/tedious/lib/prelogin-payload.js

@@ -0,0 +1,209 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _sprintfJs = require("sprintf-js");
+var _writableTrackingBuffer = _interopRequireDefault(require("./tracking-buffer/writable-tracking-buffer"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const optionBufferSize = 20;
+const TOKEN = {
+  VERSION: 0x00,
+  ENCRYPTION: 0x01,
+  INSTOPT: 0x02,
+  THREADID: 0x03,
+  MARS: 0x04,
+  FEDAUTHREQUIRED: 0x06,
+  TERMINATOR: 0xFF
+};
+const ENCRYPT = {
+  OFF: 0x00,
+  ON: 0x01,
+  NOT_SUP: 0x02,
+  REQ: 0x03
+};
+const encryptByValue = {};
+for (const name in ENCRYPT) {
+  const value = ENCRYPT[name];
+  encryptByValue[value] = name;
+}
+const MARS = {
+  OFF: 0x00,
+  ON: 0x01
+};
+const marsByValue = {};
+for (const name in MARS) {
+  const value = MARS[name];
+  marsByValue[value] = name;
+}
+/*
+  s2.2.6.4
+ */
+class PreloginPayload {
+  constructor(bufferOrOptions = {
+    encrypt: false,
+    version: {
+      major: 0,
+      minor: 0,
+      build: 0,
+      subbuild: 0
+    }
+  }) {
+    if (bufferOrOptions instanceof Buffer) {
+      this.data = bufferOrOptions;
+      this.options = {
+        encrypt: false,
+        version: {
+          major: 0,
+          minor: 0,
+          build: 0,
+          subbuild: 0
+        }
+      };
+    } else {
+      this.options = bufferOrOptions;
+      this.createOptions();
+    }
+    this.extractOptions();
+  }
+  createOptions() {
+    const options = [this.createVersionOption(), this.createEncryptionOption(), this.createInstanceOption(), this.createThreadIdOption(), this.createMarsOption(), this.createFedAuthOption()];
+    let length = 0;
+    for (let i = 0, len = options.length; i < len; i++) {
+      const option = options[i];
+      length += 5 + option.data.length;
+    }
+    length++; // terminator
+    this.data = Buffer.alloc(length, 0);
+    let optionOffset = 0;
+    let optionDataOffset = 5 * options.length + 1;
+    for (let j = 0, len = options.length; j < len; j++) {
+      const option = options[j];
+      this.data.writeUInt8(option.token, optionOffset + 0);
+      this.data.writeUInt16BE(optionDataOffset, optionOffset + 1);
+      this.data.writeUInt16BE(option.data.length, optionOffset + 3);
+      optionOffset += 5;
+      option.data.copy(this.data, optionDataOffset);
+      optionDataOffset += option.data.length;
+    }
+    this.data.writeUInt8(TOKEN.TERMINATOR, optionOffset);
+  }
+  createVersionOption() {
+    const buffer = new _writableTrackingBuffer.default(optionBufferSize);
+    buffer.writeUInt8(this.options.version.major);
+    buffer.writeUInt8(this.options.version.minor);
+    buffer.writeUInt16BE(this.options.version.build);
+    buffer.writeUInt16BE(this.options.version.subbuild);
+    return {
+      token: TOKEN.VERSION,
+      data: buffer.data
+    };
+  }
+  createEncryptionOption() {
+    const buffer = new _writableTrackingBuffer.default(optionBufferSize);
+    if (this.options.encrypt) {
+      buffer.writeUInt8(ENCRYPT.ON);
+    } else {
+      buffer.writeUInt8(ENCRYPT.NOT_SUP);
+    }
+    return {
+      token: TOKEN.ENCRYPTION,
+      data: buffer.data
+    };
+  }
+  createInstanceOption() {
+    const buffer = new _writableTrackingBuffer.default(optionBufferSize);
+    buffer.writeUInt8(0x00);
+    return {
+      token: TOKEN.INSTOPT,
+      data: buffer.data
+    };
+  }
+  createThreadIdOption() {
+    const buffer = new _writableTrackingBuffer.default(optionBufferSize);
+    buffer.writeUInt32BE(0x00);
+    return {
+      token: TOKEN.THREADID,
+      data: buffer.data
+    };
+  }
+  createMarsOption() {
+    const buffer = new _writableTrackingBuffer.default(optionBufferSize);
+    buffer.writeUInt8(MARS.OFF);
+    return {
+      token: TOKEN.MARS,
+      data: buffer.data
+    };
+  }
+  createFedAuthOption() {
+    const buffer = new _writableTrackingBuffer.default(optionBufferSize);
+    buffer.writeUInt8(0x01);
+    return {
+      token: TOKEN.FEDAUTHREQUIRED,
+      data: buffer.data
+    };
+  }
+  extractOptions() {
+    let offset = 0;
+    while (this.data[offset] !== TOKEN.TERMINATOR) {
+      let dataOffset = this.data.readUInt16BE(offset + 1);
+      const dataLength = this.data.readUInt16BE(offset + 3);
+      switch (this.data[offset]) {
+        case TOKEN.VERSION:
+          this.extractVersion(dataOffset);
+          break;
+        case TOKEN.ENCRYPTION:
+          this.extractEncryption(dataOffset);
+          break;
+        case TOKEN.INSTOPT:
+          this.extractInstance(dataOffset);
+          break;
+        case TOKEN.THREADID:
+          if (dataLength > 0) {
+            this.extractThreadId(dataOffset);
+          }
+          break;
+        case TOKEN.MARS:
+          this.extractMars(dataOffset);
+          break;
+        case TOKEN.FEDAUTHREQUIRED:
+          this.extractFedAuth(dataOffset);
+          break;
+      }
+      offset += 5;
+      dataOffset += dataLength;
+    }
+  }
+  extractVersion(offset) {
+    this.version = {
+      major: this.data.readUInt8(offset + 0),
+      minor: this.data.readUInt8(offset + 1),
+      build: this.data.readUInt16BE(offset + 2),
+      subbuild: this.data.readUInt16BE(offset + 4)
+    };
+  }
+  extractEncryption(offset) {
+    this.encryption = this.data.readUInt8(offset);
+    this.encryptionString = encryptByValue[this.encryption];
+  }
+  extractInstance(offset) {
+    this.instance = this.data.readUInt8(offset);
+  }
+  extractThreadId(offset) {
+    this.threadId = this.data.readUInt32BE(offset);
+  }
+  extractMars(offset) {
+    this.mars = this.data.readUInt8(offset);
+    this.marsString = marsByValue[this.mars];
+  }
+  extractFedAuth(offset) {
+    this.fedAuthRequired = this.data.readUInt8(offset);
+  }
+  toString(indent = '') {
+    return indent + 'PreLogin - ' + (0, _sprintfJs.sprintf)('version:%d.%d.%d.%d, encryption:0x%02X(%s), instopt:0x%02X, threadId:0x%08X, mars:0x%02X(%s)', this.version.major, this.version.minor, this.version.build, this.version.subbuild, this.encryption ? this.encryption : 0, this.encryptionString ? this.encryptionString : '', this.instance ? this.instance : 0, this.threadId ? this.threadId : 0, this.mars ? this.mars : 0, this.marsString ? this.marsString : '');
+  }
+}
+var _default = exports.default = PreloginPayload;
+module.exports = PreloginPayload;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_sprintfJs","require","_writableTrackingBuffer","_interopRequireDefault","obj","__esModule","default","optionBufferSize","TOKEN","VERSION","ENCRYPTION","INSTOPT","THREADID","MARS","FEDAUTHREQUIRED","TERMINATOR","ENCRYPT","OFF","ON","NOT_SUP","REQ","encryptByValue","name","value","marsByValue","PreloginPayload","constructor","bufferOrOptions","encrypt","version","major","minor","build","subbuild","Buffer","data","options","createOptions","extractOptions","createVersionOption","createEncryptionOption","createInstanceOption","createThreadIdOption","createMarsOption","createFedAuthOption","length","i","len","option","alloc","optionOffset","optionDataOffset","j","writeUInt8","token","writeUInt16BE","copy","buffer","WritableTrackingBuffer","writeUInt32BE","offset","dataOffset","readUInt16BE","dataLength","extractVersion","extractEncryption","extractInstance","extractThreadId","extractMars","extractFedAuth","readUInt8","encryption","encryptionString","instance","threadId","readUInt32BE","mars","marsString","fedAuthRequired","toString","indent","sprintf","_default","exports","module"],"sources":["../src/prelogin-payload.ts"],"sourcesContent":["import { sprintf } from 'sprintf-js';\n\nimport WritableTrackingBuffer from './tracking-buffer/writable-tracking-buffer';\n\nconst optionBufferSize = 20;\n\nconst TOKEN = {\n  VERSION: 0x00,\n  ENCRYPTION: 0x01,\n  INSTOPT: 0x02,\n  THREADID: 0x03,\n  MARS: 0x04,\n  FEDAUTHREQUIRED: 0x06,\n  TERMINATOR: 0xFF\n};\n\nconst ENCRYPT: { [key: string]: number } = {\n  OFF: 0x00,\n  ON: 0x01,\n  NOT_SUP: 0x02,\n  REQ: 0x03\n};\n\nconst encryptByValue: { [key: number]: string } = {};\n\nfor (const name in ENCRYPT) {\n  const value = ENCRYPT[name];\n  encryptByValue[value] = name;\n}\n\nconst MARS: { [key: string]: number } = {\n  OFF: 0x00,\n  ON: 0x01\n};\n\nconst marsByValue: { [key: number]: string } = {};\n\nfor (const name in MARS) {\n  const value = MARS[name];\n  marsByValue[value] = name;\n}\n\ninterface Options {\n  encrypt: boolean;\n  version: {\n    major: number;\n    minor: number;\n    build: number;\n    subbuild: number;\n  };\n}\n\n/*\n  s2.2.6.4\n */\nclass PreloginPayload {\n  declare data: Buffer;\n  declare options: Options;\n\n  declare version: {\n    major: number;\n    minor: number;\n    build: number;\n    subbuild: number;\n  };\n\n  declare encryption: number;\n  declare encryptionString: string;\n\n  declare instance: number;\n\n  declare threadId: number;\n\n  declare mars: number;\n  declare marsString: string;\n  declare fedAuthRequired: number;\n\n  constructor(bufferOrOptions: Buffer | Options = { encrypt: false, version: { major: 0, minor: 0, build: 0, subbuild: 0 } }) {\n    if (bufferOrOptions instanceof Buffer) {\n      this.data = bufferOrOptions;\n      this.options = { encrypt: false, version: { major: 0, minor: 0, build: 0, subbuild: 0 } };\n    } else {\n      this.options = bufferOrOptions;\n      this.createOptions();\n    }\n    this.extractOptions();\n  }\n\n  createOptions() {\n    const options = [\n      this.createVersionOption(),\n      this.createEncryptionOption(),\n      this.createInstanceOption(),\n      this.createThreadIdOption(),\n      this.createMarsOption(),\n      this.createFedAuthOption()\n    ];\n\n    let length = 0;\n    for (let i = 0, len = options.length; i < len; i++) {\n      const option = options[i];\n      length += 5 + option.data.length;\n    }\n    length++; // terminator\n    this.data = Buffer.alloc(length, 0);\n    let optionOffset = 0;\n    let optionDataOffset = 5 * options.length + 1;\n\n    for (let j = 0, len = options.length; j < len; j++) {\n      const option = options[j];\n      this.data.writeUInt8(option.token, optionOffset + 0);\n      this.data.writeUInt16BE(optionDataOffset, optionOffset + 1);\n      this.data.writeUInt16BE(option.data.length, optionOffset + 3);\n      optionOffset += 5;\n      option.data.copy(this.data, optionDataOffset);\n      optionDataOffset += option.data.length;\n    }\n\n    this.data.writeUInt8(TOKEN.TERMINATOR, optionOffset);\n  }\n\n  createVersionOption() {\n    const buffer = new WritableTrackingBuffer(optionBufferSize);\n    buffer.writeUInt8(this.options.version.major);\n    buffer.writeUInt8(this.options.version.minor);\n    buffer.writeUInt16BE(this.options.version.build);\n    buffer.writeUInt16BE(this.options.version.subbuild);\n    return {\n      token: TOKEN.VERSION,\n      data: buffer.data\n    };\n  }\n\n  createEncryptionOption() {\n    const buffer = new WritableTrackingBuffer(optionBufferSize);\n    if (this.options.encrypt) {\n      buffer.writeUInt8(ENCRYPT.ON);\n    } else {\n      buffer.writeUInt8(ENCRYPT.NOT_SUP);\n    }\n    return {\n      token: TOKEN.ENCRYPTION,\n      data: buffer.data\n    };\n  }\n\n  createInstanceOption() {\n    const buffer = new WritableTrackingBuffer(optionBufferSize);\n    buffer.writeUInt8(0x00);\n    return {\n      token: TOKEN.INSTOPT,\n      data: buffer.data\n    };\n  }\n\n  createThreadIdOption() {\n    const buffer = new WritableTrackingBuffer(optionBufferSize);\n    buffer.writeUInt32BE(0x00);\n    return {\n      token: TOKEN.THREADID,\n      data: buffer.data\n    };\n  }\n\n  createMarsOption() {\n    const buffer = new WritableTrackingBuffer(optionBufferSize);\n    buffer.writeUInt8(MARS.OFF);\n    return {\n      token: TOKEN.MARS,\n      data: buffer.data\n    };\n  }\n\n  createFedAuthOption() {\n    const buffer = new WritableTrackingBuffer(optionBufferSize);\n    buffer.writeUInt8(0x01);\n    return {\n      token: TOKEN.FEDAUTHREQUIRED,\n      data: buffer.data\n    };\n  }\n\n  extractOptions() {\n    let offset = 0;\n    while (this.data[offset] !== TOKEN.TERMINATOR) {\n      let dataOffset = this.data.readUInt16BE(offset + 1);\n      const dataLength = this.data.readUInt16BE(offset + 3);\n      switch (this.data[offset]) {\n        case TOKEN.VERSION:\n          this.extractVersion(dataOffset);\n          break;\n        case TOKEN.ENCRYPTION:\n          this.extractEncryption(dataOffset);\n          break;\n        case TOKEN.INSTOPT:\n          this.extractInstance(dataOffset);\n          break;\n        case TOKEN.THREADID:\n          if (dataLength > 0) {\n            this.extractThreadId(dataOffset);\n          }\n          break;\n        case TOKEN.MARS:\n          this.extractMars(dataOffset);\n          break;\n        case TOKEN.FEDAUTHREQUIRED:\n          this.extractFedAuth(dataOffset);\n          break;\n      }\n      offset += 5;\n      dataOffset += dataLength;\n    }\n  }\n\n  extractVersion(offset: number) {\n    this.version = {\n      major: this.data.readUInt8(offset + 0),\n      minor: this.data.readUInt8(offset + 1),\n      build: this.data.readUInt16BE(offset + 2),\n      subbuild: this.data.readUInt16BE(offset + 4)\n    };\n  }\n\n  extractEncryption(offset: number) {\n    this.encryption = this.data.readUInt8(offset);\n    this.encryptionString = encryptByValue[this.encryption];\n  }\n\n  extractInstance(offset: number) {\n    this.instance = this.data.readUInt8(offset);\n  }\n\n  extractThreadId(offset: number) {\n    this.threadId = this.data.readUInt32BE(offset);\n  }\n\n  extractMars(offset: number) {\n    this.mars = this.data.readUInt8(offset);\n    this.marsString = marsByValue[this.mars];\n  }\n\n  extractFedAuth(offset: number) {\n    this.fedAuthRequired = this.data.readUInt8(offset);\n  }\n\n  toString(indent = '') {\n    return indent + 'PreLogin - ' + sprintf(\n      'version:%d.%d.%d.%d, encryption:0x%02X(%s), instopt:0x%02X, threadId:0x%08X, mars:0x%02X(%s)',\n      this.version.major, this.version.minor, this.version.build, this.version.subbuild,\n      this.encryption ? this.encryption : 0,\n      this.encryptionString ? this.encryptionString : '',\n      this.instance ? this.instance : 0,\n      this.threadId ? this.threadId : 0,\n      this.mars ? this.mars : 0,\n      this.marsString ? this.marsString : ''\n    );\n  }\n}\n\nexport default PreloginPayload;\nmodule.exports = PreloginPayload;\n"],"mappings":"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"}

package/dist/node_modules/tedious/lib/request.d.ts

@@ -0,0 +1,370 @@
+import { EventEmitter } from 'events';
+import { type Parameter, type DataType } from './data-type';
+import Connection from './connection';
+import { type Metadata } from './metadata-parser';
+import { SQLServerStatementColumnEncryptionSetting } from './always-encrypted/types';
+import { type ColumnMetadata } from './token/colmetadata-token-parser';
+import { Collation } from './collation';
+/**
+ * The callback is called when the request has completed, either successfully or with an error.
+ * If an error occurs during execution of the statement(s), then `err` will describe the error.
+ *
+ * As only one request at a time may be executed on a connection, another request should not
+ * be initiated until this callback is called.
+ *
+ * This callback is called before `requestCompleted` is emitted.
+ */
+type CompletionCallback = 
+/**
+ * @param error
+ *   If an error occurred, an error object.
+ *
+ * @param rowCount
+ *   The number of rows emitted as result of executing the SQL statement.
+ *
+ * @param rows
+ *   Rows as a result of executing the SQL statement.
+ *   Will only be available if [[ConnectionOptions.rowCollectionOnRequestCompletion]] is `true`.
+ */
+(error: Error | null | undefined, rowCount?: number, rows?: any) => void;
+export interface ParameterOptions {
+    output?: boolean;
+    length?: number;
+    precision?: number;
+    scale?: number;
+}
+interface RequestOptions {
+    statementColumnEncryptionSetting?: SQLServerStatementColumnEncryptionSetting;
+}
+/**
+ * ```js
+ * const { Request } = require('tedious');
+ * const request = new Request("select 42, 'hello world'", (err, rowCount) {
+ *   // Request completion callback...
+ * });
+ * connection.execSql(request);
+ * ```
+ */
+declare class Request extends EventEmitter {
+    /**
+     * @private
+     */
+    sqlTextOrProcedure: string | undefined;
+    /**
+     * @private
+     */
+    parameters: Parameter[];
+    /**
+     * @private
+     */
+    parametersByName: {
+        [key: string]: Parameter;
+    };
+    /**
+     * @private
+     */
+    preparing: boolean;
+    /**
+     * @private
+     */
+    canceled: boolean;
+    /**
+     * @private
+     */
+    paused: boolean;
+    /**
+     * @private
+     */
+    userCallback: CompletionCallback;
+    /**
+     * @private
+     */
+    handle: number | undefined;
+    /**
+     * @private
+     */
+    error: Error | undefined;
+    /**
+     * @private
+     */
+    connection: Connection | undefined;
+    /**
+     * @private
+     */
+    timeout: number | undefined;
+    /**
+     * @private
+     */
+    rows?: Array<any>;
+    /**
+     * @private
+     */
+    rst?: Array<any>;
+    /**
+     * @private
+     */
+    rowCount?: number;
+    /**
+     * @private
+     */
+    callback: CompletionCallback;
+    shouldHonorAE?: boolean;
+    statementColumnEncryptionSetting: SQLServerStatementColumnEncryptionSetting;
+    cryptoMetadataLoaded: boolean;
+    /**
+     * This event, describing result set columns, will be emitted before row
+     * events are emitted. This event may be emitted multiple times when more
+     * than one recordset is produced by the statement.
+     *
+     * An array like object, where the columns can be accessed either by index
+     * or name. Columns with a name that is an integer are not accessible by name,
+     * as it would be interpreted as an array index.
+     */
+    on(event: 'columnMetadata', listener: (columns: ColumnMetadata[] | {
+        [key: string]: ColumnMetadata;
+    }) => void): this;
+    /**
+     * The request has been prepared and can be used in subsequent calls to execute and unprepare.
+     */
+    on(event: 'prepared', listener: () => void): this;
+    /**
+     * The request encountered an error and has not been prepared.
+     */
+    on(event: 'error', listener: (err: Error) => void): this;
+    /**
+     * A row resulting from execution of the SQL statement.
+     */
+    on(event: 'row', listener: 
+    /**
+     * An array or object (depends on [[ConnectionOptions.useColumnNames]]), where the columns can be accessed by index/name.
+     * Each column has two properties, `metadata` and `value`：
+     *
+     * * `metadata`
+     *
+     *    The same data that is exposed in the `columnMetadata` event.
+     *
+     * * `value`
+     *
+     *    The column's value. It will be `null` for a `NULL`.
+     *    If there are multiple columns with the same name, then this will be an array of the values.
+     */
+    (columns: any) => void): this;
+    /**
+     * All rows from a result set have been provided (through `row` events).
+     *
+     * This token is used to indicate the completion of a SQL statement.
+     * As multiple SQL statements can be sent to the server in a single SQL batch, multiple `done` can be generated.
+     * An `done` event is emitted for each SQL statement in the SQL batch except variable declarations.
+     * For execution of SQL statements within stored procedures, `doneProc` and `doneInProc` events are used in place of `done`.
+     *
+     * If you are using [[Connection.execSql]] then SQL server may treat the multiple calls with the same query as a stored procedure.
+     * When this occurs, the `doneProc` and `doneInProc` events may be emitted instead. You must handle both events to ensure complete coverage.
+     */
+    on(event: 'done', listener: 
+    /**
+     * @param rowCount
+     *   The number of result rows. May be `undefined` if not available.
+     *
+     * @param more
+     *   If there are more results to come (probably because multiple statements are being executed), then `true`.
+     *
+     * @param rst
+     *   Rows as a result of executing the SQL statement.
+     *   Will only be available if Connection's [[ConnectionOptions.rowCollectionOnDone]] is `true`.
+     */
+    (rowCount: number | undefined, more: boolean, rst?: any[]) => void): this;
+    /**
+     * `request.on('doneInProc', function (rowCount, more, rows) { });`
+     *
+     * Indicates the completion status of a SQL statement within a stored procedure. All rows from a statement
+     * in a stored procedure have been provided (through `row` events).
+     *
+     * This event may also occur when executing multiple calls with the same query using [[execSql]].
+     */
+    on(event: 'doneInProc', listener: 
+    /**
+     * @param rowCount
+     *   The number of result rows. May be `undefined` if not available.
+     *
+     * @param more
+     *   If there are more results to come (probably because multiple statements are being executed), then `true`.
+     *
+     * @param rst
+     *   Rows as a result of executing the SQL statement.
+     *   Will only be available if Connection's [[ConnectionOptions.rowCollectionOnDone]] is `true`.
+     */
+    (rowCount: number | undefined, more: boolean, rst?: any[]) => void): this;
+    /**
+     * Indicates the completion status of a stored procedure. This is also generated for stored procedures
+     * executed through SQL statements.\
+     * This event may also occur when executing multiple calls with the same query using [[execSql]].
+     */
+    on(event: 'doneProc', listener: 
+    /**
+     * @param rowCount
+     *   The number of result rows. May be `undefined` if not available.
+     *
+     * @param more
+     *   If there are more results to come (probably because multiple statements are being executed), then `true`.
+     *
+     * @param rst
+     *   Rows as a result of executing the SQL statement.
+     *   Will only be available if Connection's [[ConnectionOptions.rowCollectionOnDone]] is `true`.
+     */
+    (rowCount: number | undefined, more: boolean, procReturnStatusValue: number, rst?: any[]) => void): this;
+    /**
+     * A value for an output parameter (that was added to the request with [[addOutputParameter]]).
+     * See also `Using Parameters`.
+     */
+    on(event: 'returnValue', listener: 
+    /**
+     * @param parameterName
+     *   The parameter name. (Does not start with '@'.)
+     *
+     * @param value
+     *   The parameter's output value.
+     *
+     * @param metadata
+     *   The same data that is exposed in the `columnMetaData` event.
+     */
+    (parameterName: string, value: unknown, metadata: Metadata) => void): this;
+    /**
+     * This event gives the columns by which data is ordered, if `ORDER BY` clause is executed in SQL Server.
+     */
+    on(event: 'order', listener: 
+    /**
+     * @param orderColumns
+     *   An array of column numbers in the result set by which data is ordered.
+     */
+    (orderColumns: number[]) => void): this;
+    on(event: 'requestCompleted', listener: () => void): this;
+    on(event: 'cancel', listener: () => void): this;
+    on(event: 'pause', listener: () => void): this;
+    on(event: 'resume', listener: () => void): this;
+    /**
+     * @private
+     */
+    emit(event: 'columnMetadata', columns: ColumnMetadata[] | {
+        [key: string]: ColumnMetadata;
+    }): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'prepared'): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'error', err: Error): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'row', columns: any): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'done', rowCount: number | undefined, more: boolean, rst?: any[]): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'doneInProc', rowCount: number | undefined, more: boolean, rst?: any[]): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'doneProc', rowCount: number | undefined, more: boolean, procReturnStatusValue: number, rst?: any[]): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'returnValue', parameterName: string, value: unknown, metadata: Metadata): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'requestCompleted'): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'cancel'): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'pause'): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'resume'): boolean;
+    /**
+     * @private
+     */
+    emit(event: 'order', orderColumns: number[]): boolean;
+    /**
+     * @param sqlTextOrProcedure
+     *   The SQL statement to be executed
+     *
+     * @param callback
+     *   The callback to execute once the request has been fully completed.
+     */
+    constructor(sqlTextOrProcedure: string | undefined, callback: CompletionCallback, options?: RequestOptions);
+    /**
+     * @param name
+     *   The parameter name. This should correspond to a parameter in the SQL,
+     *   or a parameter that a called procedure expects. The name should not start with `@`.
+     *
+     * @param type
+     *   One of the supported data types.
+     *
+     * @param value
+     *   The value that the parameter is to be given. The Javascript type of the
+     *   argument should match that documented for data types.
+     *
+     * @param options
+     *   Additional type options. Optional.
+     */
+    addParameter(name: string, type: DataType, value?: unknown, options?: Readonly<ParameterOptions> | null): void;
+    /**
+     * @param name
+     *   The parameter name. This should correspond to a parameter in the SQL,
+     *   or a parameter that a called procedure expects.
+     *
+     * @param type
+     *   One of the supported data types.
+     *
+     * @param value
+     *   The value that the parameter is to be given. The Javascript type of the
+     *   argument should match that documented for data types
+     *
+     * @param options
+     *   Additional type options. Optional.
+     */
+    addOutputParameter(name: string, type: DataType, value?: unknown, options?: Readonly<ParameterOptions> | null): void;
+    /**
+     * @private
+     */
+    makeParamsParameter(parameters: Parameter[]): string;
+    /**
+     * @private
+     */
+    validateParameters(collation: Collation | undefined): void;
+    /**
+     * Temporarily suspends the flow of data from the database. No more `row` events will be emitted until [[resume] is called.
+     * If this request is already in a paused state, calling [[pause]] has no effect.
+     */
+    pause(): void;
+    /**
+     * Resumes the flow of data from the database.
+     * If this request is not in a paused state, calling [[resume]] has no effect.
+     */
+    resume(): void;
+    /**
+     * Cancels a request while waiting for a server response.
+     */
+    cancel(): void;
+    /**
+     * Sets a timeout for this request.
+     *
+     * @param timeout
+     *   The number of milliseconds before the request is considered failed,
+     *   or `0` for no timeout. When no timeout is set for the request,
+     *   the [[ConnectionOptions.requestTimeout]] of the [[Connection]] is used.
+     */
+    setTimeout(timeout?: number): void;
+}
+export default Request;