node-firebird 2.3.4 → 2.4.0

package/lib/srp.js

@@ -1,12 +1,19 @@
-var crypto = require('crypto');
-
-const SRP_KEY_SIZE = 128,
-  SRP_KEY_MAX = BigInt('340282366920938463463374607431768211456'), // 1 << SRP_KEY_SIZE
-  SRP_SALT_SIZE = 32;
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIME_N = void 0;
+exports.clientSeed = clientSeed;
+exports.serverSeed = serverSeed;
+exports.serverSession = serverSession;
+exports.clientProof = clientProof;
+exports.hexPad = hexPad;
+const crypto_1 = __importDefault(require("crypto"));
+const SRP_KEY_SIZE = 128, SRP_KEY_MAX = BigInt('340282366920938463463374607431768211456'), // 1 << SRP_KEY_SIZE
+SRP_SALT_SIZE = 32;
 const DEBUG = false;
 const DEBUG_PRIVATE_KEY = BigInt('0x84316857F47914F838918D5C12CE3A3E7A9B2D7C9486346809E9EEFCE8DE7CD4259D8BE4FD0BCC2D259553769E078FA61EE2977025E4DA42F7FD97914D8A33723DFAFBC00770B7DA0C2E3778A05790F0C0F33C32A19ED88A12928567749021B3FD45DCD1CE259C45325067E3DDC972F87867349BA82C303CCCAA9B207218007B');
-
 /**
  * Prime values.
  *
@@ -17,29 +24,32 @@ const PRIME = {
     g: BigInt(2),
     k: BigInt('1277432915985975349439481660349303019122249719989')
 };
-
+const kCache = {};
+function getK(hashAlgo) {
+    if (!kCache[hashAlgo]) {
+        kCache[hashAlgo] = BigInt('0x' + getHash(hashAlgo, pad(PRIME.N), pad(PRIME.g)));
+    }
+    return kCache[hashAlgo];
+}
 /**
  * Generate a client key pair.
  *
  * @param a BigInt Client private key.
  * @returns {{private: BigInt, public: BigInt}}
  */
-exports.clientSeed = function(a = toBigInt(crypto.randomBytes(SRP_KEY_SIZE)) % PRIME.N) {
+function clientSeed(a = toBigInt(crypto_1.default.randomBytes(SRP_KEY_SIZE)) % PRIME.N) {
     // a must be in [0, N): clientSession() reduces the exponent (a + ux) mod N
     // to match the Firebird engine, but A = g^a is computed from the raw a.
     // When random a >= N (~10% of 1024-bit values), the proof diverges from
     // the server's session key, causing sporadic auth failures.
     var A = modPow(PRIME.g, a, PRIME.N);
-
     dump('a', a);
     dump('A', A);
-
     return {
         public: A,
         private: a
     };
 }
-
 /**
  * Generate a server key pair.
  *
@@ -49,24 +59,29 @@ exports.clientSeed = function(a = toBigInt(crypto.randomBytes(SRP_KEY_SIZE)) % P
  * @param b BigInt Server private key.
  * @returns {{private: BigInt, public: BigInt}}
  */
-exports.serverSeed = function(user, password, salt, b = toBigInt(crypto.randomBytes(SRP_KEY_SIZE))) {
-    var v = getVerifier(user, password, salt);
-    var gb = modPow(PRIME.g, b, PRIME.N);
-    var kv = (PRIME.k * v) % PRIME.N;
+function serverSeed(user, password, salt, b, hashAlgo = 'sha1') {
+    if (typeof b === 'string') {
+        hashAlgo = b;
+        b = undefined;
+    }
+    const bKey = (b === undefined || b === null)
+        ? toBigInt(crypto_1.default.randomBytes(SRP_KEY_SIZE))
+        : b;
+    var v = getVerifier(user, password, salt, 'sha1');
+    var gb = modPow(PRIME.g, bKey, PRIME.N);
+    var k = getK('sha1');
+    var kv = (k * v) % PRIME.N;
     var B = (kv + gb) % PRIME.N;
-
     dump('v', v);
-    dump('b', b);
-    dump('gb', b);
+    dump('b', bKey);
+    dump('gb', bKey);
     dump('kv', v);
     dump('B', B);
-
     return {
         public: B,
-        private: b
+        private: bKey
     };
 }
-
 /**
  * Server session secret.
  *
@@ -78,47 +93,39 @@ exports.serverSeed = function(user, password, salt, b = toBigInt(crypto.randomBy
  * @param b BigInt Server private key.
  * @returns {BigInt}
  */
-exports.serverSession = function(user, password, salt, A, B, b) {
-    var u = getScramble(A, B);
-    var v = getVerifier(user, password, salt);
+function serverSession(user, password, salt, A, B, b, hashAlgo = 'sha1') {
+    var u = getScramble(A, B, 'sha1');
+    var v = getVerifier(user, password, salt, 'sha1');
     var vu = modPow(v, u, PRIME.N);
     var Avu = (A * vu) % PRIME.N;
     var sessionSecret = modPow(Avu, b, PRIME.N);
     var K = getHash('sha1', toBuffer(sessionSecret));
-
     dump('server sessionSecret', sessionSecret);
     dump('server K', K);
-
     return BigInt('0x' + K);
-};
-
+}
+;
 /**
  * M = H(H(N) xor H(g), H(I), s, A, B, K)
  */
-exports.clientProof = function(user, password, salt, A, B, a, hashAlgo) {
-    var K = clientSession(user, password, salt, A, B, a);
+function clientProof(user, password, salt, A, B, a, hashAlgo = 'sha1') {
+    var K = clientSession(user, password, salt, A, B, a, 'sha1');
     var n1, n2;
-
     n1 = toBigInt(getHash('sha1', toBuffer(PRIME.N)));
     n2 = toBigInt(getHash('sha1', toBuffer(PRIME.g)));
-
     dump('n1', n1);
     dump('n2', n2);
-
     n1 = modPow(n1, n2, PRIME.N);
     n2 = toBigInt(getHash('sha1', user));
     var M = toBigInt(getHash(hashAlgo, toBuffer(n1), toBuffer(n2), salt, toBuffer(A), toBuffer(B), toBuffer(K)));
-
     dump('n1-2', n1);
     dump('n2-2', n2);
     dump('proof:M', M);
-
     return {
         clientSessionKey: K,
         authData: M,
     };
 }
-
 /**
  *  Pad hex string.
  */
@@ -126,18 +133,14 @@ function hexPad(hex) {
     if (hex.length % 2 !== 0) {
         hex = '0' + hex;
     }
-
     return hex;
 }
-exports.hexPad = hexPad;
-
 /**
  * The SRP prime modulus N (1024-bit, same value used by Firebird).
  * Exported so tests and tooling can assert key-size invariants without
  * duplicating the constant.
  */
 exports.PRIME_N = PRIME.N;
-
 /**
  * Pad key with SRP_KEY_SIZE.
  *
@@ -146,14 +149,16 @@ exports.PRIME_N = PRIME.N;
  */
 function pad(n) {
     var buff = Buffer.from(hexPad(n.toString(16)), 'hex');
-
     if (buff.length > SRP_KEY_SIZE) {
         buff = buff.slice(buff.length - SRP_KEY_SIZE, buff.length);
     }
-
+    else if (buff.length < SRP_KEY_SIZE) {
+        var padded = Buffer.alloc(SRP_KEY_SIZE);
+        buff.copy(padded, SRP_KEY_SIZE - buff.length);
+        buff = padded;
+    }
     return buff;
 }
-
 /**
  * Scramble keys.
  *
@@ -161,10 +166,9 @@ function pad(n) {
  * @param B BigInt Server public key.
  * @returns {BigInt}
  */
-function getScramble(A, B) {
-    return BigInt('0x' + getHash('sha1', pad(A), pad(B)));
+function getScramble(A, B, hashAlgo = 'sha1') {
+    return BigInt('0x' + getHash(hashAlgo, pad(A), pad(B)));
 }
-
 /**
  * Client session secret.
  *
@@ -180,17 +184,16 @@ function getScramble(A, B) {
  * @param B BigInt Server public key.
  * @param a BigInt Client private key.
  */
-function clientSession(user, password, salt, A, B, a) {
-    var u = getScramble(A, B);
-    var x = getUserHash(user, salt, password);
+function clientSession(user, password, salt, A, B, a, hashAlgo = 'sha1') {
+    var u = getScramble(A, B, 'sha1');
+    var x = getUserHash(user, salt, password, 'sha1');
     var gx = modPow(PRIME.g, x, PRIME.N);
-    var kgx = (PRIME.k * gx) % PRIME.N;
+    var k = getK('sha1');
+    var kgx = (k * gx) % PRIME.N;
     var diff = (B - kgx) % PRIME.N;
-
     if (diff < 0n) {
         diff = diff + PRIME.N;
     }
-
     // Note: While the SRP specification says exponents should not be reduced mod N,
     // the Firebird engine implementation does reduce these exponents mod N.
     // We must match the server's behavior for authentication to succeed.
@@ -198,7 +201,6 @@ function clientSession(user, password, salt, A, B, a) {
     var aux = (a + ux) % PRIME.N;
     var sessionSecret = modPow(diff, aux, PRIME.N);
     var K = toBigInt(getHash('sha1', toBuffer(sessionSecret)));
-
     dump('B', B);
     dump('u', u);
     dump('x', x);
@@ -209,10 +211,8 @@ function clientSession(user, password, salt, A, B, a) {
     dump('aux', aux);
     dump('sessionSecret', sessionSecret);
     dump('sessionKey(K)', K);
-
     return K;
 }
-
 /**
  * Compute user hash.
  *
@@ -221,13 +221,11 @@ function clientSession(user, password, salt, A, B, a) {
  * @param password string Connection password.
  * @returns {BigInt}
  */
-function getUserHash(user, salt, password) {
-    var hash1 = getHash('sha1', user.toUpperCase(), ':', password);
-    var hash2 = getHash('sha1', salt, toBuffer(hash1));
-
+function getUserHash(user, salt, password, hashAlgo = 'sha1') {
+    var hash1 = getHash(hashAlgo, user.toUpperCase(), ':', password);
+    var hash2 = getHash(hashAlgo, salt, toBuffer(hash1));
     return toBigInt(hash2);
 }
-
 /**
  * Verifier of user hash.
  *
@@ -236,10 +234,9 @@ function getUserHash(user, salt, password) {
  * @param salt  BigInt Connection salt.
  * @returns {BigInt}
  */
-function getVerifier(user, password, salt) {
-    return modPow(PRIME.g, getUserHash(user, salt, password), PRIME.N);
+function getVerifier(user, password, salt, hashAlgo = 'sha1') {
+    return modPow(PRIME.g, getUserHash(user, salt, password, hashAlgo), PRIME.N);
 }
-
 /**
  * Hash data and return hex string.
  *
@@ -248,15 +245,12 @@ function getVerifier(user, password, salt) {
  * @returns {string}
  */
 function getHash(algo, ...data) {
-    var hash = crypto.createHash(algo);
-
+    var hash = crypto_1.default.createHash(algo);
     for (var d of data) {
         hash.update(d);
     }
-
     return hash.digest('hex');
 }
-
 /**
  * Convert BigInt to buffer.
  *
@@ -266,7 +260,6 @@ function getHash(algo, ...data) {
 function toBuffer(bigInt) {
     return Buffer.from(typeof bigInt === 'bigint' ? hexPad(bigInt.toString(16)) : bigInt, 'hex');
 }
-
 /**
  * Convert hex buffer or string to BigInt.
  *
@@ -276,7 +269,6 @@ function toBuffer(bigInt) {
 function toBigInt(hex) {
     return BigInt('0x' + (Buffer.isBuffer(hex) ? hex.toString('hex') : hex));
 }
-
 /**
  * Dump value in debug mode.
  *
@@ -288,11 +280,9 @@ function dump(key, value) {
         if (typeof value === 'bigint') {
             value = value.toString(16);
         }
-
         console.log(key + '=' + value);
     }
 }
-
 /**
  * Calculates (base ^ exp) % mod using native BigInt.
  */

package/lib/types.d.ts

@@ -0,0 +1,375 @@
+export type DatabaseCallback = (err: any, db: Database) => void;
+export type TransactionCallback = (err: any, transaction: Transaction) => void;
+export type QueryCallback = (err: any, result: any[]) => void;
+export type SimpleCallback = (err: any) => void;
+export type SequentialCallback = (row: any, index: number, next?: (err?: any) => void) => void | Promise<void>;
+/**
+ * Describes a single column in a prepared statement's result set or
+ * parameter list.  The properties here are populated by the
+ * `isc_info_sql_*` response items returned by the Firebird server during
+ * op_prepare_statement.
+ *
+ * On Firebird 6.0+ (Protocol 20) `relationSchema` is additionally
+ * populated when the column comes from a table that lives in a
+ * named schema.
+ */
+export interface ColumnMetadata {
+    /** Internal Firebird SQL type code (before nullability bit is masked). */
+    type: number;
+    /** SQL sub-type (e.g. BLOB sub-type 1 = TEXT). */
+    subType: number;
+    /** Numeric scale for fixed-point types (negative, e.g. NUMERIC(9,2) → -2). */
+    scale: number;
+    /** Maximum byte length for character / binary columns. */
+    length: number;
+    /** Whether the column accepts NULL values. */
+    nullable: boolean;
+    /** Column / parameter name as declared in the DDL. */
+    field?: string;
+    /** Source relation (table / view) name. */
+    relation?: string;
+    /**
+     * **Firebird 6.0+ (Protocol 20+)**
+     * Schema that owns the source relation.  `undefined` or empty string
+     * for legacy (pre-6.0) servers or columns not drawn from a named
+     * schema (e.g. computed expressions).
+     */
+    relationSchema?: string;
+    /** Column alias as it appears in the SELECT list. */
+    alias?: string;
+    /** Alias of the source relation / sub-query. */
+    relationAlias?: string;
+    /** Owner (user) of the source relation. */
+    owner?: string;
+    /**
+     * **Firebird 6.0+ (Protocol 20+)**
+     *
+     * Character Set ID extracted from packed subType for string/character types.
+     */
+    charSetId?: number;
+    /**
+     * **Firebird 6.0+ (Protocol 20+)**
+     *
+     * Collation ID extracted from packed subType for string/character types.
+     */
+    collationId?: number;
+}
+export type Isolation = number[];
+export type TransactionOptions = {
+    autoCommit?: boolean;
+    autoUndo?: boolean;
+    isolation?: Isolation;
+    ignoreLimbo?: boolean;
+    readOnly?: boolean;
+    wait?: boolean;
+    waitTimeout?: number;
+};
+export type QueryOptions = {
+    timeout?: number;
+    scrollable?: boolean;
+};
+export interface Database {
+    detach(callback?: SimpleCallback): Database;
+    transaction(options: TransactionOptions | Isolation | TransactionCallback, callback?: TransactionCallback): Database;
+    newStatement(query: string, callback: (err: Error | null, statement: Statement) => void): Database;
+    query(query: string, params: any[], callback: QueryCallback, options?: QueryOptions): Database;
+    execute(query: string, params: any[], callback: QueryCallback, options?: QueryOptions): Database;
+    sequentially(query: string, params: any[], rowCallback: SequentialCallback, callback: SimpleCallback, options?: QueryOptions | boolean): Database;
+    drop(callback: SimpleCallback): void;
+    escape(value: any): string;
+    attachEvent(callback: any): this;
+    createTablespace(name: string, filePath: string, callback?: QueryCallback): Database;
+    alterTablespace(name: string, filePath: string, callback?: QueryCallback): Database;
+    dropTablespace(name: string, callback?: QueryCallback): Database;
+    createSchema(schemaName: string, tablespaceName?: string | QueryCallback, callback?: QueryCallback): Database;
+}
+export interface Transaction {
+    newStatement(query: string, callback: (err: Error | null, statement: Statement) => void): void;
+    query(query: string, params: any[], callback: QueryCallback, options?: QueryOptions): void;
+    execute(query: string, params: any[], callback: QueryCallback, options?: QueryOptions): void;
+    sequentially(query: string, params: any[], rowCallback: SequentialCallback, callback: SimpleCallback, options?: QueryOptions | boolean): Database;
+    commit(callback?: SimpleCallback): void;
+    commitRetaining(callback?: SimpleCallback): void;
+    rollback(callback?: SimpleCallback): void;
+    rollbackRetaining(callback?: SimpleCallback): void;
+}
+export interface Statement {
+    close(callback?: SimpleCallback): void;
+    drop(callback?: SimpleCallback): void;
+    release(callback?: SimpleCallback): void;
+    execute(transaction: Transaction, params: any[], callback: QueryCallback, options?: QueryOptions): void;
+    fetch(transaction: Transaction, count: number, callback: QueryCallback): void;
+    fetchScroll(transaction: Transaction, direction: 'NEXT' | 'PRIOR' | 'FIRST' | 'LAST' | 'ABSOLUTE' | 'RELATIVE' | number, offset: number, count: number, callback: QueryCallback): void;
+    fetchAll(transaction: Transaction, callback: QueryCallback): void;
+}
+export type SupportedCharacterSet = 'NONE' | 'CP943C' | 'DOS737' | 'DOS775' | 'DOS858' | 'DOS862' | 'DOS864' | 'DOS866' | 'DOS869' | 'GB18030' | 'GBK' | 'ISO8859_1' | 'ISO8859_2' | 'ISO8859_3' | 'ISO8859_4' | 'ISO8859_5' | 'ISO8859_6' | 'ISO8859_7' | 'ISO8859_8' | 'ISO8859_9' | 'ISO8859_13' | 'KOI8R' | 'KOI8U' | 'TIS620' | 'UTF8' | 'WIN1251' | 'WIN1252' | 'WIN1253' | 'WIN1254' | 'WIN1255' | 'WIN1256' | 'WIN1257' | 'WIN1258' | 'WIN_1258';
+export interface Options {
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    lowercase_keys?: boolean;
+    role?: string;
+    pageSize?: number;
+    retryConnectionInterval?: number;
+    encoding?: SupportedCharacterSet;
+    blobAsText?: boolean;
+    /**
+     * Segment size in bytes used when WRITING blobs (op_batch_segments).
+     * Default 1024, max 65535. Use 65535 to minimize round-trips on
+     * remote/high-latency connections.
+     */
+    blobChunkSize?: number;
+    /**
+     * Buffer size in bytes requested per op_get_segment when READING
+     * blobs. Default 1024, max 65535. Use 65535 to minimize round-trips
+     * on remote/high-latency connections (~64x fewer round-trips).
+     */
+    blobReadChunkSize?: number;
+    wireCrypt?: number;
+    wireCompression?: boolean;
+    pluginName?: string;
+    parallelWorkers?: number;
+    maxInlineBlobSize?: number;
+    maxNegotiatedProtocols?: number;
+    dbCryptConfig?: string;
+    /**
+     * Timeout in milliseconds for a single pool.get() attach operation.
+     * If attach() does not complete within this time the slot is freed,
+     * the caller receives an error, and any late-arriving connection is
+     * safely discarded. Set to 0 or omit to disable (default: no timeout).
+     *
+     * Recommended value: 5000–10000 ms depending on network latency and
+     * expected Firebird server response time under load.
+     */
+    connectTimeout?: number;
+    /**
+     * **Firebird 6.0+ only (Protocol 20+)**
+     *
+     * Sets the session's current schema at connection time.  Equivalent to
+     * executing `SET SCHEMA <name>` immediately after connecting.
+     *
+     * Unqualified object references (tables, procedures, etc.) that do not
+     * match any schema in the `searchPath` fall back to `PUBLIC`.
+     *
+     * Example: `defaultSchema: 'myapp'`
+     */
+    defaultSchema?: string;
+    /**
+     * **Firebird 6.0+ only (Protocol 20+)**
+     *
+     * Comma-separated (or array of) schema names used to resolve
+     * unqualified object references, tried in order from left to right.
+     * Equivalent to PostgreSQL's `search_path`.
+     *
+     * Examples:
+     * ```ts
+     * searchPath: 'myapp,PUBLIC'
+     * searchPath: ['myapp', 'PUBLIC']
+     * ```
+     *
+     * When omitted the server uses its own configured default
+     * (typically `PUBLIC` then `SYSTEM`).
+     */
+    searchPath?: string | string[];
+    /**
+     * **Firebird 6.0+ only (Protocol 20+)**
+     *
+     * Automatically stringifies JavaScript objects/arrays passed as query
+     * parameters to JSON strings, and automatically parses returned JSON
+     * text/BLOB columns back into JavaScript objects/arrays.
+     */
+    jsonAsObject?: boolean;
+}
+export interface SvcMgrOptions extends Options {
+    manager: true;
+}
+export interface ConnectionPool {
+    get(callback: DatabaseCallback): void;
+    destroy(callback?: SimpleCallback): void;
+}
+export interface ReadableOptions {
+    optread?: 'byline' | 'buffer';
+    buffersize?: number;
+    timeout?: number;
+}
+export interface BackupOptions extends ReadableOptions {
+    database?: string;
+    files: string | {
+        filename: string;
+        sizefile: string;
+    }[];
+    factor?: number;
+    verbose?: boolean;
+    ignorechecksums?: boolean;
+    ignorelimbo?: boolean;
+    metadataonly?: boolean;
+    nogarbasecollect?: boolean;
+    olddescriptions?: boolean;
+    nontransportable?: boolean;
+    convert?: boolean;
+    expand?: boolean;
+    notriggers?: boolean;
+}
+export interface NBackupOptions extends ReadableOptions {
+    database?: string;
+    file: string;
+    level?: number;
+    notriggers?: boolean;
+    direct?: 'on' | 'off';
+}
+export interface RestoreOptions extends ReadableOptions {
+    database?: string;
+    files: string | string[];
+    verbose?: boolean;
+    cachebuffers?: number;
+    pagesize?: boolean;
+    readonly?: boolean;
+    deactivateindexes?: boolean;
+    noshadow?: boolean;
+    novalidity?: boolean;
+    individualcommit?: boolean;
+    replace?: boolean;
+    create?: boolean;
+    useallspace?: boolean;
+    metadataonly?: boolean;
+    fixfssdata?: string;
+    fixfssmetadata?: string;
+}
+export interface NRestoreOptions extends ReadableOptions {
+    database?: string;
+    files: string | string[];
+}
+export interface ValidateOptions extends ReadableOptions {
+    database?: string;
+    checkdb?: boolean;
+    ignorechecksums?: boolean;
+    killshadows?: boolean;
+    mend?: boolean;
+    validate?: boolean;
+    full?: boolean;
+    sweep?: boolean;
+    listlimbo?: boolean;
+    icu?: boolean;
+}
+export interface StatsOptions extends ReadableOptions {
+    database?: string;
+    record?: boolean;
+    nocreation?: boolean;
+    tables?: boolean;
+    pages?: boolean;
+    header?: boolean;
+    indexes?: boolean;
+    tablesystem?: boolean;
+    encryption?: boolean;
+    objects?: string;
+}
+export interface UserInfo {
+    userid: number;
+    groupid: number;
+    username: string;
+    firstname: string;
+    middlename: string;
+    lastname: string;
+    admin: number;
+    rolename?: string;
+    groupname?: string;
+}
+export interface ServerInfo {
+    result: number;
+    dbinfo?: {
+        database: any[];
+        nbattachment: number;
+        nbdatabase: number;
+    };
+    fbconfig?: any;
+    svcversion?: number;
+    fbversion?: string;
+    fbimplementation?: string;
+    fbcapatibilities: string[];
+    pathsecuritydb?: string;
+    fbenv?: string;
+    fbenvlock?: string;
+    fbenvmsg?: string;
+    limbotrans?: number[];
+    fbusers?: UserInfo[];
+}
+export interface ServerInfoReq {
+    dbinfo?: boolean;
+    fbconfig?: boolean;
+    svcversion?: boolean;
+    fbversion?: boolean;
+    fbimplementation?: boolean;
+    fbcapatibilities?: boolean;
+    pathsecuritydb?: boolean;
+    fbenv?: boolean;
+    fbenvlock?: boolean;
+    fbenvmsg?: boolean;
+    limbotrans?: boolean;
+}
+export interface TraceOptions extends ReadableOptions {
+    configfile?: string;
+    tracename?: string;
+    traceid?: number;
+}
+export type ServiceManagerCallback = (err: any, svc: ServiceManager) => void;
+export type ReadableCallback = (err: any, reader: NodeJS.ReadableStream) => void;
+export type InfoCallback = (err: any, info: ServerInfo) => void;
+export type LineCallback = (err: any, data: {
+    result: number;
+    line: string;
+}) => void;
+export declare enum ShutdownMode {
+    NORMAL = 0,
+    MULTI = 1,
+    SINGLE = 2,
+    FULL = 3
+}
+export declare enum ShutdownKind {
+    FORCED = 0,
+    DENY_TRANSACTION = 1,
+    DENY_ATTACHMENT = 2
+}
+export interface ServiceManager {
+    detach(callback?: SimpleCallback, force?: boolean): void;
+    backup(options: BackupOptions, callback: ReadableCallback): void;
+    nbackup(options: BackupOptions, callback: ReadableCallback): void;
+    restore(options: RestoreOptions, callback: ReadableCallback): void;
+    nrestore(options: NRestoreOptions, callback: ReadableCallback): void;
+    setDialect(db: string, dialect: 1 | 3, callback: ReadableCallback): void;
+    setSweepinterval(db: string, interval: number, callback: Function): void;
+    setCachebuffer(db: string, nbpages: any, callback: ReadableCallback): void;
+    BringOnline(db: string, callback: ReadableCallback): void;
+    Shutdown(db: string, kind: ShutdownKind, delay: number, mode: ShutdownMode, callback: ReadableCallback): void;
+    Shutdown(db: string, kind: ShutdownKind, delay: number, callback: ReadableCallback): void;
+    setShadow(db: string, val: boolean, callback: ReadableCallback): void;
+    setForcewrite(db: string, val: boolean, callback: ReadableCallback): void;
+    setReservespace(db: string, val: boolean, callback: ReadableCallback): void;
+    setReadonlyMode(db: string, callback: ReadableCallback): void;
+    setReadwriteMode(db: string, callback: ReadableCallback): void;
+    validate(options: ValidateOptions, callback: ReadableCallback): void;
+    commit(db: string, transactid: number, callback: ReadableCallback): void;
+    rollback(db: string, transactid: number, callback: ReadableCallback): void;
+    recover(db: string, transactid: number, callback: ReadableCallback): void;
+    getStats(options: StatsOptions, callback: ReadableCallback): void;
+    getLog(options: ReadableOptions, callback: ReadableCallback): void;
+    getUsers(username: string | null, callback: InfoCallback): void;
+    addUser(username: string, password: string, info: UserInfo, callback: ReadableCallback): void;
+    editUser(username: string, info: UserInfo, callback: ReadableCallback): void;
+    removeUser(username: string, rolename: string | null, callback: ReadableCallback): void;
+    getFbserverInfos(infos: ServerInfoReq, options: {
+        buffersize?: number;
+        timeout?: number;
+    }, callback: InfoCallback): void;
+    startTrace(options: TraceOptions, callback: ReadableCallback): void;
+    suspendTrace(options: TraceOptions, callback: ReadableCallback): void;
+    resumeTrace(options: TraceOptions, callback: ReadableCallback): void;
+    stopTrace(options: TraceOptions, callback: ReadableCallback): void;
+    getTraceList(options: ReadableOptions, callback: ReadableCallback): void;
+    readline(options: ReadableOptions, callback: LineCallback): void;
+    readeof(options: ReadableOptions, callback: LineCallback): void;
+    hasRunningAction(options: ReadableOptions, callback: ReadableCallback): void;
+    readusers(options: ReadableOptions, callback: ReadableCallback): void;
+    readlimbo(options: ReadableOptions, callback: ReadableCallback): void;
+}