taon-typeorm 19.0.49 → 21.0.4

package/websql/lib/typeorm/decorator/relations/JoinTable.d.ts

@@ -1,18 +0,0 @@
-// @ts-nocheck
-import { JoinTableMultipleColumnsOptions } from "../options/JoinTableMultipleColumnsOptions";
-import { JoinTableOptions } from "../options/JoinTableOptions";
-/**
- * JoinTable decorator is used in many-to-many relationship to specify owner side of relationship.
- * Its also used to set a custom junction table's name, column names and referenced columns.
- */
-export declare function JoinTable(): PropertyDecorator;
-/**
- * JoinTable decorator is used in many-to-many relationship to specify owner side of relationship.
- * Its also used to set a custom junction table's name, column names and referenced columns.
- */
-export declare function JoinTable(options: JoinTableOptions): PropertyDecorator;
-/**
- * JoinTable decorator is used in many-to-many relationship to specify owner side of relationship.
- * Its also used to set a custom junction table's name, column names and referenced columns.
- */
-export declare function JoinTable(options: JoinTableMultipleColumnsOptions): PropertyDecorator;

package/websql/lib/typeorm/decorator/relations/ManyToMany.d.ts

@@ -1,15 +0,0 @@
-// @ts-nocheck
-import { ObjectType } from "../../common/ObjectType";
-import { RelationOptions } from "../options/RelationOptions";
-/**
- * Many-to-many is a type of relationship when Entity1 can have multiple instances of Entity2, and Entity2 can have
- * multiple instances of Entity1. To achieve it, this type of relation creates a junction table, where it storage
- * entity1 and entity2 ids. This is owner side of the relationship.
- */
-export declare function ManyToMany<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), options?: RelationOptions): PropertyDecorator;
-/**
- * Many-to-many is a type of relationship when Entity1 can have multiple instances of Entity2, and Entity2 can have
- * multiple instances of Entity1. To achieve it, this type of relation creates a junction table, where it storage
- * entity1 and entity2 ids. This is owner side of the relationship.
- */
-export declare function ManyToMany<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), inverseSide?: string | ((object: T) => any), options?: RelationOptions): PropertyDecorator;

package/websql/lib/typeorm/decorator/relations/ManyToOne.d.ts

@@ -1,15 +0,0 @@
-// @ts-nocheck
-import { ObjectType } from "../../common/ObjectType";
-import { RelationOptions } from "../options/RelationOptions";
-/**
- * A many-to-one relation allows creating the type of relation where Entity1 can have a single instance of Entity2, but
- * Entity2 can have multiple instances of Entity1. Entity1 is the owner of the relationship, and stores the id of
- * Entity2 on its side of the relation.
- */
-export declare function ManyToOne<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), options?: RelationOptions): PropertyDecorator;
-/**
- * A many-to-one relation allows creating the type of relation where Entity1 can have a single instance of Entity2, but
- * Entity2 can have multiple instances of Entity1. Entity1 is the owner of the relationship, and stores the id of
- * Entity2 on its side of the relation.
- */
-export declare function ManyToOne<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), inverseSide?: string | ((object: T) => any), options?: RelationOptions): PropertyDecorator;

package/websql/lib/typeorm/decorator/relations/OneToMany.d.ts

@@ -1,9 +0,0 @@
-// @ts-nocheck
-import { ObjectType } from "../../common/ObjectType";
-import { RelationOptions } from "../options/RelationOptions";
-/**
- * A one-to-many relation allows creating the type of relation where Entity1 can have multiple instances of Entity2,
- * but Entity2 has only one Entity1. Entity2 is the owner of the relationship, and stores the id of Entity1 on its
- * side of the relation.
- */
-export declare function OneToMany<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), inverseSide: string | ((object: T) => any), options?: RelationOptions): PropertyDecorator;

package/websql/lib/typeorm/decorator/relations/OneToOne.d.ts

@@ -1,13 +0,0 @@
-// @ts-nocheck
-import { ObjectType } from "../../common/ObjectType";
-import { RelationOptions } from "../options/RelationOptions";
-/**
- * One-to-one relation allows to create direct relation between two entities. Entity1 have only one Entity2.
- * Entity1 is an owner of the relationship, and storages Entity1 id on its own side.
- */
-export declare function OneToOne<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), options?: RelationOptions): PropertyDecorator;
-/**
- * One-to-one relation allows to create direct relation between two entities. Entity1 have only one Entity2.
- * Entity1 is an owner of the relationship, and storages Entity1 id on its own side.
- */
-export declare function OneToOne<T>(typeFunctionOrTarget: string | ((type?: any) => ObjectType<T>), inverseSide?: string | ((object: T) => any), options?: RelationOptions): PropertyDecorator;

package/websql/lib/typeorm/decorator/relations/RelationCount.d.ts

@@ -1,8 +0,0 @@
-// @ts-nocheck
-import { SelectQueryBuilder } from "../../query-builder/SelectQueryBuilder";
-/**
- * Holds a number of children in the closure table of the column.
- *
- * @deprecated Do not use this decorator, it may be removed in the future versions
- */
-export declare function RelationCount<T>(relation: string | ((object: T) => any), alias?: string, queryBuilderFactory?: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>): PropertyDecorator;

package/websql/lib/typeorm/decorator/relations/RelationId.d.ts

@@ -1,8 +0,0 @@
-// @ts-nocheck
-import { SelectQueryBuilder } from "../../query-builder/SelectQueryBuilder";
-/**
- * Special decorator used to extract relation id into separate entity property.
- *
- * @experimental
- */
-export declare function RelationId<T>(relation: string | ((object: T) => any), alias?: string, queryBuilderFactory?: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>): PropertyDecorator;

package/websql/lib/typeorm/decorator/tree/Tree.d.ts

@@ -1,10 +0,0 @@
-// @ts-nocheck
-import { TreeType } from "../../metadata/types/TreeTypes";
-import { ClosureTreeOptions } from "../../metadata/types/ClosureTreeOptions";
-/**
- * Marks entity to work like a tree.
- * Tree pattern that will be used for the tree entity should be specified.
- * @TreeParent decorator must be used in tree entities.
- * TreeRepository can be used to manipulate with tree entities.
- */
-export declare function Tree(type: TreeType, options?: ClosureTreeOptions): ClassDecorator;

package/websql/lib/typeorm/decorator/tree/TreeChildren.d.ts

@@ -1,8 +0,0 @@
-// @ts-nocheck
-/**
- * Marks a entity property as a children of the tree.
- * "Tree children" will contain all children (bind) of this entity.
- */
-export declare function TreeChildren(options?: {
-    cascade?: boolean | ("insert" | "update" | "remove" | "soft-remove" | "recover")[];
-}): PropertyDecorator;

package/websql/lib/typeorm/decorator/tree/TreeLevelColumn.d.ts

@@ -1,5 +0,0 @@
-// @ts-nocheck
-/**
- * Creates a "level"/"length" column to the table that holds a closure table.
- */
-export declare function TreeLevelColumn(): PropertyDecorator;

package/websql/lib/typeorm/decorator/tree/TreeParent.d.ts

@@ -1,9 +0,0 @@
-// @ts-nocheck
-import { OnDeleteType } from "../../metadata/types/OnDeleteType";
-/**
- * Marks a entity property as a parent of the tree.
- * "Tree parent" indicates who owns (is a parent) of this entity in tree structure.
- */
-export declare function TreeParent(options?: {
-    onDelete?: OnDeleteType;
-}): PropertyDecorator;

package/websql/lib/typeorm/driver/Driver.d.ts

@@ -1,208 +0,0 @@
-// @ts-nocheck
-import { QueryRunner } from "../query-runner/QueryRunner";
-import { ColumnMetadata } from "../metadata/ColumnMetadata";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-import { ColumnType } from "./types/ColumnTypes";
-import { CteCapabilities } from "./types/CteCapabilities";
-import { MappedColumnTypes } from "./types/MappedColumnTypes";
-import { SchemaBuilder } from "../schema-builder/SchemaBuilder";
-import { DataTypeDefaults } from "./types/DataTypeDefaults";
-import { BaseDataSourceOptions } from "../data-source/BaseDataSourceOptions";
-import { TableColumn } from "../schema-builder/table/TableColumn";
-import { EntityMetadata } from "../metadata/EntityMetadata";
-import { ReplicationMode } from "./types/ReplicationMode";
-import { Table } from "../schema-builder/table/Table";
-import { View } from "../schema-builder/view/View";
-import { TableForeignKey } from "../schema-builder/table/TableForeignKey";
-import { UpsertType } from "./types/UpsertType";
-export type ReturningType = "insert" | "update" | "delete";
-/**
- * Driver organizes TypeORM communication with specific database management system.
- */
-export interface Driver {
-    /**
-     * Connection options.
-     */
-    options: BaseDataSourceOptions;
-    /**
-     * Database version/release. Often requires a SQL query to the DB, so it is not always set
-     */
-    version?: string;
-    /**
-     * Database name used to perform all write queries.
-     *
-     * todo: probably move into query runner.
-     */
-    database?: string;
-    /**
-     * Schema name used to perform all write queries.
-     */
-    schema?: string;
-    /**
-     * Indicates if replication is enabled.
-     */
-    isReplicated: boolean;
-    /**
-     * Indicates if tree tables are supported by this driver.
-     */
-    treeSupport: boolean;
-    /**
-     * Represent transaction support by this driver
-     */
-    transactionSupport: "simple" | "nested" | "none";
-    /**
-     * Gets list of supported column data types by a driver.
-     */
-    supportedDataTypes: ColumnType[];
-    /**
-     * Returns type of upsert supported by driver if any
-     */
-    supportedUpsertType?: UpsertType;
-    /**
-     * Default values of length, precision and scale depends on column data type.
-     * Used in the cases when length/precision/scale is not specified by user.
-     */
-    dataTypeDefaults: DataTypeDefaults;
-    /**
-     * Gets list of spatial column data types.
-     */
-    spatialTypes: ColumnType[];
-    /**
-     * Gets list of column data types that support length by a driver.
-     */
-    withLengthColumnTypes: ColumnType[];
-    /**
-     * Gets list of column data types that support precision by a driver.
-     */
-    withPrecisionColumnTypes: ColumnType[];
-    /**
-     * Gets list of column data types that support scale by a driver.
-     */
-    withScaleColumnTypes: ColumnType[];
-    /**
-     * Orm has special columns and we need to know what database column types should be for those types.
-     * Column types are driver dependant.
-     */
-    mappedDataTypes: MappedColumnTypes;
-    /**
-     * Max length allowed by the DBMS for aliases (execution of queries).
-     */
-    maxAliasLength?: number;
-    cteCapabilities: CteCapabilities;
-    /**
-     * Performs connection to the database.
-     * Depend on driver type it may create a connection pool.
-     */
-    connect(): Promise<void>;
-    /**
-     * Makes any action after connection (e.g. create extensions in Postgres driver).
-     */
-    afterConnect(): Promise<void>;
-    /**
-     * Closes connection with database and releases all resources.
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Synchronizes database schema (creates tables, indices, etc).
-     */
-    createSchemaBuilder(): SchemaBuilder;
-    /**
-     * Creates a query runner used for common queries.
-     */
-    createQueryRunner(mode: ReplicationMode): QueryRunner;
-    /**
-     * Replaces parameters in the given sql with special escaping character
-     * and an array of parameter names to be passed to a query.
-     */
-    escapeQueryWithParameters(sql: string, parameters: ObjectLiteral, nativeParameters: ObjectLiteral): [string, any[]];
-    /**
-     * Escapes a table name, column name or an alias.
-     *
-     * todo: probably escape should be able to handle dots in the names and automatically escape them
-     */
-    escape(name: string): string;
-    /**
-     * Build full table name with database name, schema name and table name.
-     * E.g. myDB.mySchema.myTable
-     */
-    buildTableName(tableName: string, schema?: string, database?: string): string;
-    /**
-     * Parse a target table name or other types and return a normalized table definition.
-     */
-    parseTableName(target: EntityMetadata | Table | View | TableForeignKey | string): {
-        tableName: string;
-        schema?: string;
-        database?: string;
-    };
-    /**
-     * Prepares given value to a value to be persisted, based on its column type and metadata.
-     */
-    preparePersistentValue(value: any, column: ColumnMetadata): any;
-    /**
-     * Prepares given value to a value to be persisted, based on its column type.
-     */
-    prepareHydratedValue(value: any, column: ColumnMetadata): any;
-    /**
-     * Transforms type of the given column to a database column type.
-     */
-    normalizeType(column: {
-        type?: ColumnType | string;
-        length?: number | string;
-        precision?: number | null;
-        scale?: number;
-        isArray?: boolean;
-    }): string;
-    /**
-     * Normalizes "default" value of the column.
-     */
-    normalizeDefault(columnMetadata: ColumnMetadata): string | undefined;
-    /**
-     * Normalizes "isUnique" value of the column.
-     */
-    normalizeIsUnique(column: ColumnMetadata): boolean;
-    /**
-     * Calculates column length taking into account the default length values.
-     */
-    getColumnLength(column: ColumnMetadata): string;
-    /**
-     * Normalizes "default" value of the column.
-     */
-    createFullType(column: TableColumn): string;
-    /**
-     * Obtains a new database connection to a master server.
-     * Used for replication.
-     * If replication is not setup then returns default connection's database connection.
-     */
-    obtainMasterConnection(): Promise<any>;
-    /**
-     * Obtains a new database connection to a slave server.
-     * Used for replication.
-     * If replication is not setup then returns master (default) connection's database connection.
-     */
-    obtainSlaveConnection(): Promise<any>;
-    /**
-     * Creates generated map of values generated or returned by database after INSERT query.
-     */
-    createGeneratedMap(metadata: EntityMetadata, insertResult: any, entityIndex?: number, entityNum?: number): ObjectLiteral | undefined;
-    /**
-     * Differentiate columns of this table and columns from the given column metadatas columns
-     * and returns only changed.
-     */
-    findChangedColumns(tableColumns: TableColumn[], columnMetadatas: ColumnMetadata[]): ColumnMetadata[];
-    /**
-     * Returns true if driver supports RETURNING / OUTPUT statement.
-     */
-    isReturningSqlSupported(returningType: ReturningType): boolean;
-    /**
-     * Returns true if driver supports uuid values generation on its own.
-     */
-    isUUIDGenerationSupported(): boolean;
-    /**
-     * Returns true if driver supports fulltext indices.
-     */
-    isFullTextColumnTypeSupported(): boolean;
-    /**
-     * Creates an escaped parameter.
-     */
-    createParameter(parameterName: string, index: number): string;
-}

package/websql/lib/typeorm/driver/DriverFactory.d.ts

@@ -1,12 +0,0 @@
-// @ts-nocheck
-import { Driver } from "./Driver";
-import { DataSource } from "../data-source/DataSource";
-/**
- * Helps to create drivers.
- */
-export declare class DriverFactory {
-    /**
-     * Creates a new driver depend on a given connection's driver type.
-     */
-    create(connection: DataSource): Driver;
-}

package/websql/lib/typeorm/driver/DriverUtils.d.ts

@@ -1,62 +0,0 @@
-// @ts-nocheck
-import { Driver } from "./Driver";
-/**
- * Common driver utility functions.
- */
-export declare class DriverUtils {
-    /**
-     * Returns true if given driver is SQLite-based driver.
-     */
-    static isSQLiteFamily(driver: Driver): boolean;
-    /**
-     * Returns true if given driver is MySQL-based driver.
-     */
-    static isMySQLFamily(driver: Driver): boolean;
-    static isReleaseVersionOrGreater(driver: Driver, version: string): boolean;
-    static isPostgresFamily(driver: Driver): boolean;
-    /**
-     * Normalizes and builds a new driver options.
-     * Extracts settings from connection url and sets to a new options object.
-     */
-    static buildDriverOptions(options: any, buildOptions?: {
-        useSid: boolean;
-    }): any;
-    /**
-     * buildDriverOptions for MongodDB only to support replica set
-     */
-    static buildMongoDBDriverOptions(options: any, buildOptions?: {
-        useSid: boolean;
-    }): any;
-    /**
-     * Joins and shortens alias if needed.
-     *
-     * If the alias length is greater than the limit allowed by the current
-     * driver, replaces it with a shortend string, if the shortend string
-     * is still too long, it will then hash the alias.
-     *
-     * @param driver Current `Driver`.
-     * @param buildOptions Optional settings.
-     * @param alias Alias parts.
-     *
-     * @return An alias that is no longer than the divers max alias length.
-     */
-    static buildAlias({ maxAliasLength }: Driver, buildOptions: {
-        shorten?: boolean;
-        joiner?: string;
-    } | string, ...alias: string[]): string;
-    /**
-     * @deprecated use `buildAlias` instead.
-     */
-    static buildColumnAlias({ maxAliasLength }: Driver, buildOptions: {
-        shorten?: boolean;
-        joiner?: string;
-    } | string, ...alias: string[]): string;
-    /**
-     * Extracts connection data from the connection url.
-     */
-    private static parseConnectionUrl;
-    /**
-     * Extracts connection data from the connection url for MongoDB to support replica set.
-     */
-    private static parseMongoDBConnectionUrl;
-}

package/websql/lib/typeorm/driver/Query.d.ts

@@ -1,10 +0,0 @@
-// @ts-nocheck
-/**
- * This class stores query and its parameters
- */
-export declare class Query {
-    query: string;
-    parameters?: any[];
-    readonly "@instanceof": symbol;
-    constructor(query: string, parameters?: any[]);
-}

package/websql/lib/typeorm/driver/SqlInMemory.d.ts

@@ -1,9 +0,0 @@
-// @ts-nocheck
-import { Query } from "./Query";
-/**
- * This class stores up and down queries needed for migrations functionality.
- */
-export declare class SqlInMemory {
-    upQueries: Query[];
-    downQueries: Query[];
-}

package/websql/lib/typeorm/driver/cordova/CordovaConnectionOptions.d.ts

@@ -1,25 +0,0 @@
-// @ts-nocheck
-import { BaseDataSourceOptions } from "../../data-source/BaseDataSourceOptions";
-/**
- * Sqlite-specific connection options.
- */
-export interface CordovaConnectionOptions extends BaseDataSourceOptions {
-    /**
-     * Database type.
-     */
-    readonly type: "cordova";
-    /**
-     * Database name.
-     */
-    readonly database: string;
-    /**
-     * The driver object
-     * This defaults to `window.sqlitePlugin`
-     */
-    readonly driver?: any;
-    /**
-     * Storage Location
-     */
-    readonly location: string;
-    readonly poolSize?: never;
-}

package/websql/lib/typeorm/driver/cordova/CordovaDriver.d.ts

@@ -1,26 +0,0 @@
-// @ts-nocheck
-import { AbstractSqliteDriver } from "../sqlite-abstract/AbstractSqliteDriver";
-import { CordovaConnectionOptions } from "./CordovaConnectionOptions";
-import { QueryRunner } from "../../query-runner/QueryRunner";
-import { DataSource } from "../../data-source/DataSource";
-import { ReplicationMode } from "../types/ReplicationMode";
-export declare class CordovaDriver extends AbstractSqliteDriver {
-    options: CordovaConnectionOptions;
-    constructor(connection: DataSource);
-    /**
-     * Closes connection with database.
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Creates a query runner used to execute database queries.
-     */
-    createQueryRunner(mode: ReplicationMode): QueryRunner;
-    /**
-     * Creates connection with the database.
-     */
-    protected createDatabaseConnection(): Promise<any>;
-    /**
-     * If driver dependency is not given explicitly, then try to load it via "require".
-     */
-    protected loadDependencies(): void;
-}

package/websql/lib/typeorm/driver/cordova/CordovaQueryRunner.d.ts

@@ -1,81 +0,0 @@
-// @ts-nocheck
-import { ObjectLiteral } from "../../common/ObjectLiteral";
-import { AbstractSqliteQueryRunner } from "../sqlite-abstract/AbstractSqliteQueryRunner";
-import { CordovaDriver } from "./CordovaDriver";
-/**
- * Runs queries on a single sqlite database connection.
- */
-export declare class CordovaQueryRunner extends AbstractSqliteQueryRunner {
-    /**
-     * Database driver used by connection.
-     */
-    driver: CordovaDriver;
-    constructor(driver: CordovaDriver);
-    /**
-     * Called before migrations are run.
-     */
-    beforeMigration(): Promise<void>;
-    /**
-     * Called after migrations are run.
-     */
-    afterMigration(): Promise<void>;
-    /**
-     * Executes a given SQL query.
-     */
-    query(query: string, parameters?: any[], useStructuredResult?: boolean): Promise<any>;
-    /**
-     * Insert a new row with given values into the given table.
-     * Returns value of the generated column if given and generate column exist in the table.
-     // todo: implement new syntax
-    async insert(tableName: string, keyValues: ObjectLiteral): Promise<InsertResult> {
-        const keys = Object.keys(keyValues);
-        const columns = keys.map(key => `"${key}"`).join(", ");
-        const values = keys.map(key => "?").join(",");
-        const generatedColumns = this.connection.hasMetadata(tableName) ? this.connection.getMetadata(tableName).generatedColumns : [];
-        const sql = columns.length > 0 ? (`INSERT INTO "${tableName}"(${columns}) VALUES (${values})`) : `INSERT INTO "${tableName}" DEFAULT VALUES`;
-        const parameters = keys.map(key => keyValues[key]);
-
-        return new Promise<InsertResult>(async (ok, fail) => {
-            this.driver.connection.logger.logQuery(sql, parameters, this);
-            const __this = this;
-            const databaseConnection = await this.connect();
-            databaseConnection.executeSql(sql, parameters, (resultSet: any) => {
-                const generatedMap = generatedColumns.reduce((map, generatedColumn) => {
-                    const value = generatedColumn.isPrimary && generatedColumn.generationStrategy === "increment" && resultSet.insertId ? resultSet.insertId : keyValues[generatedColumn.databaseName];
-                    if (!value) return map;
-                    return OrmUtils.mergeDeep(map, generatedColumn.createValueMap(value));
-                }, {} as ObjectLiteral);
-
-                ok({
-                    result: undefined,
-                    generatedMap: Object.keys(generatedMap).length > 0 ? generatedMap : undefined
-                });
-            }, (err: any) => {
-                __this.driver.connection.logger.logQueryError(err, sql, parameters, this);
-                fail(err);
-            });
-        });
-    }*/
-    /**
-     * Would start a transaction but this driver does not support transactions.
-     */
-    startTransaction(): Promise<void>;
-    /**
-     * Would start a transaction but this driver does not support transactions.
-     */
-    commitTransaction(): Promise<void>;
-    /**
-     * Would start a transaction but this driver does not support transactions.
-     */
-    rollbackTransaction(): Promise<void>;
-    /**
-     * Removes all tables from the currently connected database.
-     * Be careful with using this method and avoid using it in production or migrations
-     * (because it can clear all your database).
-     */
-    clearDatabase(): Promise<void>;
-    /**
-     * Parametrizes given object of values. Used to create column=value queries.
-     */
-    protected parametrize(objectLiteral: ObjectLiteral, startIndex?: number): string[];
-}

package/websql/lib/typeorm/driver/mongodb/typings.d.ts

@@ -1,46 +0,0 @@
-// @ts-nocheck
-/**
- * Create a new ObjectID instance.
- *
- * @see http://mongodb.github.io/node-mongodb-native/2.1/api/ObjectID.html
- */
-export declare class ObjectID {
-    constructor(s?: string | number);
-    /**
-     * The generation time of this ObjectId instance.
-     */
-    generationTime: number;
-    /**
-     * Creates an ObjectID from a hex string representation of an ObjectID.
-     */
-    static createFromHexString(hexString: string): ObjectID;
-    /**
-     * Creates an ObjectID from a second based number, with the rest of the ObjectID zeroed out. Used for comparisons or sorting the ObjectID.
-     */
-    static createFromTime(time: number): ObjectID;
-    /**
-     * Checks if a value is a valid bson ObjectId.
-     */
-    static isValid(id: any): boolean;
-    /**
-     * Compares the equality of this ObjectID with otherID.
-     */
-    equals(otherID: ObjectID): boolean;
-    /**
-     * Generate a 12 byte id buffer used in ObjectID's.
-     */
-    generate(time?: number): string;
-    /**
-     * Returns the generation date (accurate up to the second) that this ID was generated.
-     *
-     */
-    getTimestamp(): Date;
-    /**
-     * Return the ObjectID id as a 24 byte hex string representation.
-     */
-    toHexString(): string;
-    /**
-     * Get the timestamp and validate correctness.
-     */
-    toString(): string;
-}