@types/sqlite3

  • Version 3.1.11
  • Published
  • 7.08 kB
  • 1 dependency
  • MIT license

Install

npm i @types/sqlite3
yarn add @types/sqlite3
pnpm add @types/sqlite3

Overview

TypeScript definitions for sqlite3

Index

Variables

variable cached

const cached: {
Database(
filename: string,
callback?: (this: Database, err: Error | null) => void
): Database;
Database(
filename: string,
mode?: number,
callback?: (this: Database, err: Error | null) => void
): Database;
};

    variable OPEN_CREATE

    const OPEN_CREATE: number;

      variable OPEN_PRIVATECACHE

      const OPEN_PRIVATECACHE: number;

        variable OPEN_READONLY

        const OPEN_READONLY: number;

          variable OPEN_READWRITE

          const OPEN_READWRITE: number;

            variable OPEN_SHAREDCACHE

            const OPEN_SHAREDCACHE: number;

              variable OPEN_URI

              const OPEN_URI: number;

                Functions

                function verbose

                verbose: () => sqlite3;

                  Classes

                  class Database

                  class Database extends events.EventEmitter {}

                    constructor

                    constructor(filename: string, callback?: (err: Error | null) => void);

                      constructor

                      constructor(
                      filename: string,
                      mode?: number,
                      callback?: (err: Error | null) => void
                      );

                        method all

                        all: {
                        (
                        sql: string,
                        callback?: (this: Statement, err: Error | null, rows: any[]) => void
                        ): this;
                        (
                        sql: string,
                        params: any,
                        callback?: (this: Statement, err: Error, rows: any[]) => void
                        ): this;
                        (sql: string, ...params: any[]): this;
                        };

                          method close

                          close: (callback?: (err: Error | null) => void) => void;

                            method configure

                            configure: (option: 'busyTimeout', value: number) => void;

                              method each

                              each: {
                              (
                              sql: string,
                              callback?: (this: Statement, err: Error | null, row: any) => void,
                              complete?: (err: Error | null, count: number) => void
                              ): this;
                              (
                              sql: string,
                              params: any,
                              callback?: (this: Statement, err: Error, row: any) => void,
                              complete?: (err: Error, count: number) => void
                              ): this;
                              (sql: string, ...params: any[]): this;
                              };

                                method exec

                                exec: (
                                sql: string,
                                callback?: (this: Statement, err: Error | null) => void
                                ) => this;

                                  method get

                                  get: {
                                  (
                                  sql: string,
                                  callback?: (this: Statement, err: Error | null, row: any) => void
                                  ): this;
                                  (
                                  sql: string,
                                  params: any,
                                  callback?: (this: Statement, err: Error, row: any) => void
                                  ): this;
                                  (sql: string, ...params: any[]): this;
                                  };

                                    method interrupt

                                    interrupt: () => void;

                                      method on

                                      on: {
                                      (event: 'trace', listener: (sql: string) => void): this;
                                      (event: 'profile', listener: (sql: string, time: number) => void): this;
                                      (event: 'error', listener: (err: Error) => void): this;
                                      (event: 'open' | 'close', listener: () => void): this;
                                      (event: string, listener: (...args: any[]) => void): this;
                                      };

                                        method parallelize

                                        parallelize: (callback?: () => void) => void;

                                          method prepare

                                          prepare: {
                                          (
                                          sql: string,
                                          callback?: (this: Statement, err: Error | null) => void
                                          ): Statement;
                                          (
                                          sql: string,
                                          params: any,
                                          callback?: (this: Statement, err: Error) => void
                                          ): Statement;
                                          (sql: string, ...params: any[]): Statement;
                                          };

                                            method run

                                            run: {
                                            (sql: string, callback?: (this: RunResult, err: Error | null) => void): this;
                                            (
                                            sql: string,
                                            params: any,
                                            callback?: (this: RunResult, err: Error) => void
                                            ): this;
                                            (sql: string, ...params: any[]): this;
                                            };

                                              method serialize

                                              serialize: (callback?: () => void) => void;

                                                class Statement

                                                class Statement {}

                                                  method all

                                                  all: {
                                                  (callback?: (err: Error | null, rows: any[]) => void): this;
                                                  (
                                                  params: any,
                                                  callback?: (this: RunResult, err: Error, rows: any[]) => void
                                                  ): this;
                                                  (...params: any[]): this;
                                                  };

                                                    method bind

                                                    bind: {
                                                    (callback?: (err: Error | null) => void): this;
                                                    (...params: any[]): this;
                                                    };

                                                      method each

                                                      each: {
                                                      (
                                                      callback?: (err: Error | null, row: any) => void,
                                                      complete?: (err: Error | null, count: number) => void
                                                      ): this;
                                                      (
                                                      params: any,
                                                      callback?: (this: RunResult, err: Error, row: any) => void,
                                                      complete?: (err: Error, count: number) => void
                                                      ): this;
                                                      (...params: any[]): this;
                                                      };

                                                        method finalize

                                                        finalize: (callback?: (err: Error) => void) => Database;

                                                          method get

                                                          get: {
                                                          (callback?: (err: Error | null, row?: any) => void): this;
                                                          (
                                                          params: any,
                                                          callback?: (this: RunResult, err: Error, row?: any) => void
                                                          ): this;
                                                          (...params: any[]): this;
                                                          };

                                                            method reset

                                                            reset: (callback?: (err: null) => void) => this;

                                                              method run

                                                              run: {
                                                              (callback?: (err: Error | null) => void): this;
                                                              (params: any, callback?: (this: RunResult, err: Error) => void): this;
                                                              (...params: any[]): this;
                                                              };

                                                                Interfaces

                                                                interface RunResult

                                                                interface RunResult extends Statement {}

                                                                  property changes

                                                                  changes: number;

                                                                    property lastID

                                                                    lastID: number;

                                                                      interface sqlite3

                                                                      interface sqlite3 {}

                                                                        property cached

                                                                        cached: typeof cached;

                                                                          property Database

                                                                          Database: typeof Database;

                                                                            property OPEN_CREATE

                                                                            OPEN_CREATE: number;

                                                                              property OPEN_PRIVATECACHE

                                                                              OPEN_PRIVATECACHE: number;

                                                                                property OPEN_READONLY

                                                                                OPEN_READONLY: number;

                                                                                  property OPEN_READWRITE

                                                                                  OPEN_READWRITE: number;

                                                                                    property OPEN_SHAREDCACHE

                                                                                    OPEN_SHAREDCACHE: number;

                                                                                      property OPEN_URI

                                                                                      OPEN_URI: number;

                                                                                        property RunResult

                                                                                        RunResult: RunResult;

                                                                                          property Statement

                                                                                          Statement: typeof Statement;

                                                                                            method verbose

                                                                                            verbose: () => this;

                                                                                              Package Files (1)

                                                                                              Dependencies (1)

                                                                                              Dev Dependencies (0)

                                                                                              No dev dependencies.

                                                                                              Peer Dependencies (0)

                                                                                              No peer dependencies.

                                                                                              Badge

                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/sqlite3.

                                                                                              • Markdown
                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/sqlite3)
                                                                                              • HTML
                                                                                                <a href="https://www.jsdocs.io/package/@types/sqlite3"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>