plugin-data-source-mssql 2.0.0 → 2.0.2

package/dist/node_modules/tedious/lib/always-encrypted/symmetric-key.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SymmetricKey = void 0;
+// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.
+// Copyright (c) 2019 Microsoft Corporation
+
+class SymmetricKey {
+  constructor(rootKey) {
+    if (!rootKey) {
+      throw new Error('Column encryption key cannot be null.');
+    } else if (0 === rootKey.length) {
+      throw new Error('Empty column encryption key specified.');
+    }
+    this.rootKey = rootKey;
+  }
+  zeroOutKey() {
+    this.rootKey = Buffer.alloc(this.rootKey.length);
+  }
+}
+exports.SymmetricKey = SymmetricKey;
+var _default = exports.default = SymmetricKey;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJTeW1tZXRyaWNLZXkiLCJjb25zdHJ1Y3RvciIsInJvb3RLZXkiLCJFcnJvciIsImxlbmd0aCIsInplcm9PdXRLZXkiLCJCdWZmZXIiLCJhbGxvYyIsImV4cG9ydHMiLCJfZGVmYXVsdCIsImRlZmF1bHQiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvYWx3YXlzLWVuY3J5cHRlZC9zeW1tZXRyaWMta2V5LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIFRoaXMgY29kZSBpcyBiYXNlZCBvbiB0aGUgYG1zc3FsLWpkYmNgIGxpYnJhcnkgcHVibGlzaGVkIHVuZGVyIHRoZSBjb25kaXRpb25zIG9mIE1JVCBsaWNlbnNlLlxuLy8gQ29weXJpZ2h0IChjKSAyMDE5IE1pY3Jvc29mdCBDb3Jwb3JhdGlvblxuXG5leHBvcnQgY2xhc3MgU3ltbWV0cmljS2V5IHtcbiAgZGVjbGFyZSByb290S2V5OiBCdWZmZXI7XG5cbiAgY29uc3RydWN0b3Iocm9vdEtleTogQnVmZmVyKSB7XG4gICAgaWYgKCFyb290S2V5KSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ0NvbHVtbiBlbmNyeXB0aW9uIGtleSBjYW5ub3QgYmUgbnVsbC4nKTtcbiAgICB9IGVsc2UgaWYgKDAgPT09IHJvb3RLZXkubGVuZ3RoKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ0VtcHR5IGNvbHVtbiBlbmNyeXB0aW9uIGtleSBzcGVjaWZpZWQuJyk7XG4gICAgfVxuICAgIHRoaXMucm9vdEtleSA9IHJvb3RLZXk7XG4gIH1cblxuICB6ZXJvT3V0S2V5KCkge1xuICAgIHRoaXMucm9vdEtleSA9IEJ1ZmZlci5hbGxvYyh0aGlzLnJvb3RLZXkubGVuZ3RoKTtcbiAgfVxufVxuZXhwb3J0IGRlZmF1bHQgU3ltbWV0cmljS2V5O1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQTtBQUNBOztBQUVPLE1BQU1BLFlBQVksQ0FBQztFQUd4QkMsV0FBV0EsQ0FBQ0MsT0FBZSxFQUFFO0lBQzNCLElBQUksQ0FBQ0EsT0FBTyxFQUFFO01BQ1osTUFBTSxJQUFJQyxLQUFLLENBQUMsdUNBQXVDLENBQUM7SUFDMUQsQ0FBQyxNQUFNLElBQUksQ0FBQyxLQUFLRCxPQUFPLENBQUNFLE1BQU0sRUFBRTtNQUMvQixNQUFNLElBQUlELEtBQUssQ0FBQyx3Q0FBd0MsQ0FBQztJQUMzRDtJQUNBLElBQUksQ0FBQ0QsT0FBTyxHQUFHQSxPQUFPO0VBQ3hCO0VBRUFHLFVBQVVBLENBQUEsRUFBRztJQUNYLElBQUksQ0FBQ0gsT0FBTyxHQUFHSSxNQUFNLENBQUNDLEtBQUssQ0FBQyxJQUFJLENBQUNMLE9BQU8sQ0FBQ0UsTUFBTSxDQUFDO0VBQ2xEO0FBQ0Y7QUFBQ0ksT0FBQSxDQUFBUixZQUFBLEdBQUFBLFlBQUE7QUFBQSxJQUFBUyxRQUFBLEdBQUFELE9BQUEsQ0FBQUUsT0FBQSxHQUNjVixZQUFZIn0=

package/dist/node_modules/tedious/lib/always-encrypted/types.d.ts

@@ -0,0 +1,73 @@
+import { CEKEntry } from './cek-entry';
+import { type BaseMetadata } from '../metadata-parser';
+export interface EncryptionKeyInfo {
+    encryptedKey: Buffer;
+    dbId: number;
+    keyId: number;
+    keyVersion: number;
+    mdVersion: Buffer;
+    keyPath: string;
+    keyStoreName: string;
+    algorithmName: string;
+}
+export declare enum SQLServerEncryptionType {
+    Deterministic = 1,
+    Randomized = 2,
+    PlainText = 0
+}
+export interface EncryptionAlgorithm {
+    encryptData: (plainText: Buffer) => Buffer;
+    decryptData: (cipherText: Buffer) => Buffer;
+}
+export interface CryptoMetadata {
+    cekEntry?: CEKEntry;
+    cipherAlgorithmId: number;
+    cipherAlgorithmName?: string;
+    normalizationRuleVersion: Buffer;
+    encryptionKeyInfo?: EncryptionKeyInfo;
+    ordinal: number;
+    encryptionType: SQLServerEncryptionType;
+    cipherAlgorithm?: EncryptionAlgorithm;
+    baseTypeInfo?: BaseMetadata;
+}
+export interface HashMap<T> {
+    [hash: string]: T;
+}
+export declare enum DescribeParameterEncryptionResultSet1 {
+    KeyOrdinal = 0,
+    DbId = 1,
+    KeyId = 2,
+    KeyVersion = 3,
+    KeyMdVersion = 4,
+    EncryptedKey = 5,
+    ProviderName = 6,
+    KeyPath = 7,
+    KeyEncryptionAlgorithm = 8
+}
+export declare enum DescribeParameterEncryptionResultSet2 {
+    ParameterOrdinal = 0,
+    ParameterName = 1,
+    ColumnEncryptionAlgorithm = 2,
+    ColumnEncrytionType = 3,
+    ColumnEncryptionKeyOrdinal = 4,
+    NormalizationRuleVersion = 5
+}
+export declare enum SQLServerStatementColumnEncryptionSetting {
+    /**
+     * if "Column Encryption Setting=Enabled" in the connection string, use Enabled. Otherwise, maps to Disabled.
+     */
+    UseConnectionSetting = 0,
+    /**
+     * Enables TCE for the command. Overrides the connection level setting for this command.
+     */
+    Enabled = 1,
+    /**
+     * Parameters will not be encrypted, only the ResultSet will be decrypted. This is an optimization for queries that
+     * do not pass any encrypted input parameters. Overrides the connection level setting for this command.
+     */
+    ResultSetOnly = 2,
+    /**
+     * Disables TCE for the command.Overrides the connection level setting for this command.
+     */
+    Disabled = 3
+}

package/dist/node_modules/tedious/lib/always-encrypted/types.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SQLServerStatementColumnEncryptionSetting = exports.SQLServerEncryptionType = exports.DescribeParameterEncryptionResultSet2 = exports.DescribeParameterEncryptionResultSet1 = void 0;
+// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.
+// Copyright (c) 2019 Microsoft Corporation
+let SQLServerEncryptionType = exports.SQLServerEncryptionType = /*#__PURE__*/function (SQLServerEncryptionType) {
+  SQLServerEncryptionType[SQLServerEncryptionType["Deterministic"] = 1] = "Deterministic";
+  SQLServerEncryptionType[SQLServerEncryptionType["Randomized"] = 2] = "Randomized";
+  SQLServerEncryptionType[SQLServerEncryptionType["PlainText"] = 0] = "PlainText";
+  return SQLServerEncryptionType;
+}({});
+// Fields in the first resultset of "sp_describe_parameter_encryption"
+// We expect the server to return the fields in the resultset in the same order as mentioned below.
+// If the server changes the below order, then transparent parameter encryption will break.
+let DescribeParameterEncryptionResultSet1 = exports.DescribeParameterEncryptionResultSet1 = /*#__PURE__*/function (DescribeParameterEncryptionResultSet1) {
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyOrdinal"] = 0] = "KeyOrdinal";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["DbId"] = 1] = "DbId";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyId"] = 2] = "KeyId";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyVersion"] = 3] = "KeyVersion";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyMdVersion"] = 4] = "KeyMdVersion";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["EncryptedKey"] = 5] = "EncryptedKey";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["ProviderName"] = 6] = "ProviderName";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyPath"] = 7] = "KeyPath";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyEncryptionAlgorithm"] = 8] = "KeyEncryptionAlgorithm";
+  return DescribeParameterEncryptionResultSet1;
+}({}); // Fields in the second resultset of "sp_describe_parameter_encryption"
+// We expect the server to return the fields in the resultset in the same order as mentioned below.
+// If the server changes the below order, then transparent parameter encryption will break.
+let DescribeParameterEncryptionResultSet2 = exports.DescribeParameterEncryptionResultSet2 = /*#__PURE__*/function (DescribeParameterEncryptionResultSet2) {
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["ParameterOrdinal"] = 0] = "ParameterOrdinal";
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["ParameterName"] = 1] = "ParameterName";
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["ColumnEncryptionAlgorithm"] = 2] = "ColumnEncryptionAlgorithm";
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["ColumnEncrytionType"] = 3] = "ColumnEncrytionType";
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["ColumnEncryptionKeyOrdinal"] = 4] = "ColumnEncryptionKeyOrdinal";
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["NormalizationRuleVersion"] = 5] = "NormalizationRuleVersion";
+  return DescribeParameterEncryptionResultSet2;
+}({});
+let SQLServerStatementColumnEncryptionSetting = exports.SQLServerStatementColumnEncryptionSetting = /*#__PURE__*/function (SQLServerStatementColumnEncryptionSetting) {
+  SQLServerStatementColumnEncryptionSetting[SQLServerStatementColumnEncryptionSetting["UseConnectionSetting"] = 0] = "UseConnectionSetting";
+  SQLServerStatementColumnEncryptionSetting[SQLServerStatementColumnEncryptionSetting["Enabled"] = 1] = "Enabled";
+  SQLServerStatementColumnEncryptionSetting[SQLServerStatementColumnEncryptionSetting["ResultSetOnly"] = 2] = "ResultSetOnly";
+  SQLServerStatementColumnEncryptionSetting[SQLServerStatementColumnEncryptionSetting["Disabled"] = 3] = "Disabled";
+  return SQLServerStatementColumnEncryptionSetting;
+}({});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/node_modules/tedious/lib/always-encrypted/utils.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shouldHonorAE = void 0;
+var _types = require("./types");
+// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.
+// Copyright (c) 2019 Microsoft Corporation
+
+const shouldHonorAE = (stmtColumnEncryptionSetting, columnEncryptionSetting) => {
+  switch (stmtColumnEncryptionSetting) {
+    case _types.SQLServerStatementColumnEncryptionSetting.Disabled:
+    case _types.SQLServerStatementColumnEncryptionSetting.ResultSetOnly:
+      return false;
+    case _types.SQLServerStatementColumnEncryptionSetting.Enabled:
+      return true;
+    default:
+      return columnEncryptionSetting;
+  }
+};
+exports.shouldHonorAE = shouldHonorAE;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfdHlwZXMiLCJyZXF1aXJlIiwic2hvdWxkSG9ub3JBRSIsInN0bXRDb2x1bW5FbmNyeXB0aW9uU2V0dGluZyIsImNvbHVtbkVuY3J5cHRpb25TZXR0aW5nIiwiU1FMU2VydmVyU3RhdGVtZW50Q29sdW1uRW5jcnlwdGlvblNldHRpbmciLCJEaXNhYmxlZCIsIlJlc3VsdFNldE9ubHkiLCJFbmFibGVkIiwiZXhwb3J0cyJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hbHdheXMtZW5jcnlwdGVkL3V0aWxzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIFRoaXMgY29kZSBpcyBiYXNlZCBvbiB0aGUgYG1zc3FsLWpkYmNgIGxpYnJhcnkgcHVibGlzaGVkIHVuZGVyIHRoZSBjb25kaXRpb25zIG9mIE1JVCBsaWNlbnNlLlxuLy8gQ29weXJpZ2h0IChjKSAyMDE5IE1pY3Jvc29mdCBDb3Jwb3JhdGlvblxuXG5pbXBvcnQgeyBTUUxTZXJ2ZXJTdGF0ZW1lbnRDb2x1bW5FbmNyeXB0aW9uU2V0dGluZyB9IGZyb20gJy4vdHlwZXMnO1xuXG5leHBvcnQgY29uc3Qgc2hvdWxkSG9ub3JBRSA9IChzdG10Q29sdW1uRW5jcnlwdGlvblNldHRpbmc6IFNRTFNlcnZlclN0YXRlbWVudENvbHVtbkVuY3J5cHRpb25TZXR0aW5nLCBjb2x1bW5FbmNyeXB0aW9uU2V0dGluZzogYm9vbGVhbik6IGJvb2xlYW4gPT4ge1xuICBzd2l0Y2ggKHN0bXRDb2x1bW5FbmNyeXB0aW9uU2V0dGluZykge1xuICAgIGNhc2UgU1FMU2VydmVyU3RhdGVtZW50Q29sdW1uRW5jcnlwdGlvblNldHRpbmcuRGlzYWJsZWQ6XG4gICAgY2FzZSBTUUxTZXJ2ZXJTdGF0ZW1lbnRDb2x1bW5FbmNyeXB0aW9uU2V0dGluZy5SZXN1bHRTZXRPbmx5OlxuICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIGNhc2UgU1FMU2VydmVyU3RhdGVtZW50Q29sdW1uRW5jcnlwdGlvblNldHRpbmcuRW5hYmxlZDpcbiAgICAgIHJldHVybiB0cnVlO1xuICAgIGRlZmF1bHQ6XG4gICAgICByZXR1cm4gY29sdW1uRW5jcnlwdGlvblNldHRpbmc7XG4gIH1cbn07XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUdBLElBQUFBLE1BQUEsR0FBQUMsT0FBQTtBQUhBO0FBQ0E7O0FBSU8sTUFBTUMsYUFBYSxHQUFHQSxDQUFDQywyQkFBc0UsRUFBRUMsdUJBQWdDLEtBQWM7RUFDbEosUUFBUUQsMkJBQTJCO0lBQ2pDLEtBQUtFLGdEQUF5QyxDQUFDQyxRQUFRO0lBQ3ZELEtBQUtELGdEQUF5QyxDQUFDRSxhQUFhO01BQzFELE9BQU8sS0FBSztJQUNkLEtBQUtGLGdEQUF5QyxDQUFDRyxPQUFPO01BQ3BELE9BQU8sSUFBSTtJQUNiO01BQ0UsT0FBT0osdUJBQXVCO0VBQ2xDO0FBQ0YsQ0FBQztBQUFDSyxPQUFBLENBQUFQLGFBQUEsR0FBQUEsYUFBQSJ9

package/dist/node_modules/tedious/lib/bulk-load-payload.d.ts

@@ -0,0 +1,8 @@
+import BulkLoad from './bulk-load';
+export declare class BulkLoadPayload implements AsyncIterable<Buffer> {
+    bulkLoad: BulkLoad;
+    iterator: AsyncIterableIterator<Buffer>;
+    constructor(bulkLoad: BulkLoad);
+    [Symbol.asyncIterator](): AsyncIterableIterator<Buffer>;
+    toString(indent?: string): string;
+}

package/dist/node_modules/tedious/lib/bulk-load-payload.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BulkLoadPayload = void 0;
+class BulkLoadPayload {
+  constructor(bulkLoad) {
+    this.bulkLoad = bulkLoad;
+
+    // We need to grab the iterator here so that `error` event handlers are set up
+    // as early as possible (and are not potentially lost).
+    this.iterator = this.bulkLoad.rowToPacketTransform[Symbol.asyncIterator]();
+  }
+  [Symbol.asyncIterator]() {
+    return this.iterator;
+  }
+  toString(indent = '') {
+    return indent + 'BulkLoad';
+  }
+}
+exports.BulkLoadPayload = BulkLoadPayload;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJCdWxrTG9hZFBheWxvYWQiLCJjb25zdHJ1Y3RvciIsImJ1bGtMb2FkIiwiaXRlcmF0b3IiLCJyb3dUb1BhY2tldFRyYW5zZm9ybSIsIlN5bWJvbCIsImFzeW5jSXRlcmF0b3IiLCJ0b1N0cmluZyIsImluZGVudCIsImV4cG9ydHMiXSwic291cmNlcyI6WyIuLi9zcmMvYnVsay1sb2FkLXBheWxvYWQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IEJ1bGtMb2FkIGZyb20gJy4vYnVsay1sb2FkJztcblxuZXhwb3J0IGNsYXNzIEJ1bGtMb2FkUGF5bG9hZCBpbXBsZW1lbnRzIEFzeW5jSXRlcmFibGU8QnVmZmVyPiB7XG4gIGRlY2xhcmUgYnVsa0xvYWQ6IEJ1bGtMb2FkO1xuICBkZWNsYXJlIGl0ZXJhdG9yOiBBc3luY0l0ZXJhYmxlSXRlcmF0b3I8QnVmZmVyPjtcblxuICBjb25zdHJ1Y3RvcihidWxrTG9hZDogQnVsa0xvYWQpIHtcbiAgICB0aGlzLmJ1bGtMb2FkID0gYnVsa0xvYWQ7XG5cbiAgICAvLyBXZSBuZWVkIHRvIGdyYWIgdGhlIGl0ZXJhdG9yIGhlcmUgc28gdGhhdCBgZXJyb3JgIGV2ZW50IGhhbmRsZXJzIGFyZSBzZXQgdXBcbiAgICAvLyBhcyBlYXJseSBhcyBwb3NzaWJsZSAoYW5kIGFyZSBub3QgcG90ZW50aWFsbHkgbG9zdCkuXG4gICAgdGhpcy5pdGVyYXRvciA9IHRoaXMuYnVsa0xvYWQucm93VG9QYWNrZXRUcmFuc2Zvcm1bU3ltYm9sLmFzeW5jSXRlcmF0b3JdKCk7XG4gIH1cblxuICBbU3ltYm9sLmFzeW5jSXRlcmF0b3JdKCkge1xuICAgIHJldHVybiB0aGlzLml0ZXJhdG9yO1xuICB9XG5cbiAgdG9TdHJpbmcoaW5kZW50ID0gJycpIHtcbiAgICByZXR1cm4gaW5kZW50ICsgKCdCdWxrTG9hZCcpO1xuICB9XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUVPLE1BQU1BLGVBQWUsQ0FBa0M7RUFJNURDLFdBQVdBLENBQUNDLFFBQWtCLEVBQUU7SUFDOUIsSUFBSSxDQUFDQSxRQUFRLEdBQUdBLFFBQVE7O0lBRXhCO0lBQ0E7SUFDQSxJQUFJLENBQUNDLFFBQVEsR0FBRyxJQUFJLENBQUNELFFBQVEsQ0FBQ0Usb0JBQW9CLENBQUNDLE1BQU0sQ0FBQ0MsYUFBYSxDQUFDLENBQUMsQ0FBQztFQUM1RTtFQUVBLENBQUNELE1BQU0sQ0FBQ0MsYUFBYSxJQUFJO0lBQ3ZCLE9BQU8sSUFBSSxDQUFDSCxRQUFRO0VBQ3RCO0VBRUFJLFFBQVFBLENBQUNDLE1BQU0sR0FBRyxFQUFFLEVBQUU7SUFDcEIsT0FBT0EsTUFBTSxHQUFJLFVBQVc7RUFDOUI7QUFDRjtBQUFDQyxPQUFBLENBQUFULGVBQUEsR0FBQUEsZUFBQSJ9

package/dist/node_modules/tedious/lib/bulk-load.d.ts

@@ -0,0 +1,275 @@
+import { EventEmitter } from 'events';
+import Connection, { type InternalConnectionOptions } from './connection';
+import { Transform } from 'stream';
+import { type DataType, type Parameter } from './data-type';
+import { Collation } from './collation';
+/**
+ * @private
+ */
+interface InternalOptions {
+    checkConstraints: boolean;
+    fireTriggers: boolean;
+    keepNulls: boolean;
+    lockTable: boolean;
+    order: {
+        [columnName: string]: 'ASC' | 'DESC';
+    };
+}
+export interface Options {
+    /**
+     * Honors constraints during bulk load, using T-SQL
+     * [CHECK_CONSTRAINTS](https://technet.microsoft.com/en-us/library/ms186247(v=sql.105).aspx).
+     * (default: `false`)
+     */
+    checkConstraints?: InternalOptions['checkConstraints'] | undefined;
+    /**
+     * Honors insert triggers during bulk load, using the T-SQL [FIRE_TRIGGERS](https://technet.microsoft.com/en-us/library/ms187640(v=sql.105).aspx). (default: `false`)
+     */
+    fireTriggers?: InternalOptions['fireTriggers'] | undefined;
+    /**
+     * Honors null value passed, ignores the default values set on table, using T-SQL [KEEP_NULLS](https://msdn.microsoft.com/en-us/library/ms187887(v=sql.120).aspx). (default: `false`)
+     */
+    keepNulls?: InternalOptions['keepNulls'] | undefined;
+    /**
+     * Places a bulk update(BU) lock on table while performing bulk load, using T-SQL [TABLOCK](https://technet.microsoft.com/en-us/library/ms180876(v=sql.105).aspx). (default: `false`)
+     */
+    lockTable?: InternalOptions['lockTable'] | undefined;
+    /**
+     * Specifies the ordering of the data to possibly increase bulk insert performance, using T-SQL [ORDER](https://docs.microsoft.com/en-us/previous-versions/sql/sql-server-2008-r2/ms177468(v=sql.105)). (default: `{}`)
+     */
+    order?: InternalOptions['order'] | undefined;
+}
+export type Callback = 
+/**
+ * A function which will be called after the [[BulkLoad]] finishes executing.
+ *
+ * @param rowCount the number of rows inserted
+ */
+(err: Error | undefined | null, rowCount?: number) => void;
+interface Column extends Parameter {
+    objName: string;
+    collation: Collation | undefined;
+}
+interface ColumnOptions {
+    output?: boolean;
+    /**
+     * For VarChar, NVarChar, VarBinary. Use length as `Infinity` for VarChar(max), NVarChar(max) and VarBinary(max).
+     */
+    length?: number;
+    /**
+     * For Numeric, Decimal.
+     */
+    precision?: number;
+    /**
+     * For Numeric, Decimal, Time, DateTime2, DateTimeOffset.
+     */
+    scale?: number;
+    /**
+     * If the name of the column is different from the name of the property found on `rowObj` arguments passed to [[addRow]], then you can use this option to specify the property name.
+     */
+    objName?: string;
+    /**
+     * Indicates whether the column accepts NULL values.
+     */
+    nullable?: boolean;
+}
+declare class RowTransform extends Transform {
+    /**
+     * @private
+     */
+    columnMetadataWritten: boolean;
+    /**
+     * @private
+     */
+    bulkLoad: BulkLoad;
+    /**
+     * @private
+     */
+    mainOptions: BulkLoad['options'];
+    /**
+     * @private
+     */
+    columns: BulkLoad['columns'];
+    /**
+     * @private
+     */
+    constructor(bulkLoad: BulkLoad);
+    /**
+     * @private
+     */
+    _transform(row: Array<unknown> | {
+        [colName: string]: unknown;
+    }, _encoding: string, callback: (error?: Error) => void): void;
+    /**
+     * @private
+     */
+    _flush(callback: () => void): void;
+}
+/**
+ * A BulkLoad instance is used to perform a bulk insert.
+ *
+ * Use [[Connection.newBulkLoad]] to create a new instance, and [[Connection.execBulkLoad]] to execute it.
+ *
+ * Example of BulkLoad Usages:
+ *
+ * ```js
+ * // optional BulkLoad options
+ * const options = { keepNulls: true };
+ *
+ * // instantiate - provide the table where you'll be inserting to, options and a callback
+ * const bulkLoad = connection.newBulkLoad('MyTable', options, (error, rowCount) => {
+ *   console.log('inserted %d rows', rowCount);
+ * });
+ *
+ * // setup your columns - always indicate whether the column is nullable
+ * bulkLoad.addColumn('myInt', TYPES.Int, { nullable: false });
+ * bulkLoad.addColumn('myString', TYPES.NVarChar, { length: 50, nullable: true });
+ *
+ * // execute
+ * connection.execBulkLoad(bulkLoad, [
+ *   { myInt: 7, myString: 'hello' },
+ *   { myInt: 23, myString: 'world' }
+ * ]);
+ * ```
+ */
+declare class BulkLoad extends EventEmitter {
+    /**
+     * @private
+     */
+    error: Error | undefined;
+    /**
+     * @private
+     */
+    canceled: boolean;
+    /**
+     * @private
+     */
+    executionStarted: boolean;
+    /**
+     * @private
+     */
+    streamingMode: boolean;
+    /**
+     * @private
+     */
+    table: string;
+    /**
+     * @private
+     */
+    timeout: number | undefined;
+    /**
+     * @private
+     */
+    options: InternalConnectionOptions;
+    /**
+     * @private
+     */
+    callback: Callback;
+    /**
+     * @private
+     */
+    columns: Array<Column>;
+    /**
+     * @private
+     */
+    columnsByName: {
+        [name: string]: Column;
+    };
+    /**
+     * @private
+     */
+    firstRowWritten: boolean;
+    /**
+     * @private
+     */
+    rowToPacketTransform: RowTransform;
+    /**
+     * @private
+     */
+    bulkOptions: InternalOptions;
+    /**
+     * @private
+     */
+    connection: Connection | undefined;
+    /**
+     * @private
+     */
+    rows: Array<any> | undefined;
+    /**
+     * @private
+     */
+    rst: Array<any> | undefined;
+    /**
+     * @private
+     */
+    rowCount: number | undefined;
+    collation: Collation | undefined;
+    /**
+     * @private
+     */
+    constructor(table: string, collation: Collation | undefined, connectionOptions: InternalConnectionOptions, { checkConstraints, fireTriggers, keepNulls, lockTable, order, }: Options, callback: Callback);
+    /**
+     * Adds a column to the bulk load.
+     *
+     * The column definitions should match the table you are trying to insert into.
+     * Attempting to call addColumn after the first row has been added will throw an exception.
+     *
+     * ```js
+     * bulkLoad.addColumn('MyIntColumn', TYPES.Int, { nullable: false });
+     * ```
+     *
+     * @param name The name of the column.
+     * @param type One of the supported `data types`.
+     * @param __namedParameters Additional column type information. At a minimum, `nullable` must be set to true or false.
+     * @param length For VarChar, NVarChar, VarBinary. Use length as `Infinity` for VarChar(max), NVarChar(max) and VarBinary(max).
+     * @param nullable Indicates whether the column accepts NULL values.
+     * @param objName If the name of the column is different from the name of the property found on `rowObj` arguments passed to [[addRow]] or [[Connection.execBulkLoad]], then you can use this option to specify the property name.
+     * @param precision For Numeric, Decimal.
+     * @param scale For Numeric, Decimal, Time, DateTime2, DateTimeOffset.
+    */
+    addColumn(name: string, type: DataType, { output, length, precision, scale, objName, nullable }: ColumnOptions): void;
+    /**
+     * @private
+     */
+    getOptionsSql(): string;
+    /**
+     * @private
+     */
+    getBulkInsertSql(): string;
+    /**
+     * This is simply a helper utility function which returns a `CREATE TABLE SQL` statement based on the columns added to the bulkLoad object.
+     * This may be particularly handy when you want to insert into a temporary table (a table which starts with `#`).
+     *
+     * ```js
+     * var sql = bulkLoad.getTableCreationSql();
+     * ```
+     *
+     * A side note on bulk inserting into temporary tables: if you want to access a local temporary table after executing the bulk load,
+     * you'll need to use the same connection and execute your requests using [[Connection.execSqlBatch]] instead of [[Connection.execSql]]
+     */
+    getTableCreationSql(): string;
+    /**
+     * @private
+     */
+    getColMetaData(): Buffer;
+    /**
+     * Sets a timeout for this bulk load.
+     *
+     * ```js
+     * bulkLoad.setTimeout(timeout);
+     * ```
+     *
+     * @param timeout The number of milliseconds before the bulk load is considered failed, or 0 for no timeout.
+     *   When no timeout is set for the bulk load, the [[ConnectionOptions.requestTimeout]] of the Connection is used.
+     */
+    setTimeout(timeout?: number): void;
+    /**
+     * @private
+     */
+    createDoneToken(): Buffer;
+    /**
+     * @private
+     */
+    cancel(): void;
+}
+export default BulkLoad;