@orion-js/mongodb 4.3.1 → 4.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Orionjs Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/connect/connections.d.ts

@@ -0,0 +1,56 @@
+import { Db, MongoClient, MongoClientOptions } from 'mongodb';
+export interface OrionMongoClient {
+    client: MongoClient;
+    db: Db;
+    uri: string;
+    dbName: string;
+    /**
+     * @deprecated Use startConnection() instead. This property is not guaranteed to be resolved if the connection is not started.
+     * When using async calls startConnection or connectionPromise is no longer needed. Orion will automatically start the connection if it is not already started.
+     * Kept for backwards compatibility. startConnection does not re-start the connection if it is already started, so it is safe to use.
+     */
+    connectionPromise: Promise<MongoClient>;
+    connectionName: string;
+    encrypted: {
+        client: MongoClient;
+        db: Db;
+    };
+    /**
+     * Starts the connection if it is not already started.
+     * If the connection is already started, it resolves immediately.
+     */
+    startConnection: () => Promise<MongoClient>;
+    closeConnection: () => Promise<void>;
+}
+export declare const connectionWrappers: {
+    [key: string]: OrionMongoDatabaseWrapper;
+};
+declare class OrionMongoDatabaseWrapper implements OrionMongoClient {
+    uri: string;
+    dbName: string;
+    connectionName: string;
+    connectionPromise: Promise<MongoClient>;
+    private mongoOptions;
+    private connectionEvent;
+    private state;
+    client: MongoClient;
+    db: Db;
+    configured: boolean;
+    readonly encrypted: {
+        client: MongoClient;
+        db: Db;
+    };
+    readonly configTimeout: NodeJS.Timeout;
+    constructor(connectionName: string);
+    config(mongoURL: string, mongoOptions: MongoClientOptions): void;
+    awaitConnection(): Promise<this>;
+    connectWithRetry(client: MongoClient): Promise<MongoClient>;
+    startConnection(): Promise<MongoClient>;
+    closeConnection(): Promise<void>;
+}
+export declare function configureConnection(connectionName: string, mongoOptions: MongoClientOptions): Promise<OrionMongoDatabaseWrapper>;
+export declare function getExistingConnection(connectionName: string): OrionMongoDatabaseWrapper;
+export declare const connections: {
+    [key: string]: OrionMongoDatabaseWrapper;
+};
+export {};

package/dist/connect/getDBName.d.ts

@@ -0,0 +1 @@
+export default function getDBName(url: string): string;

package/dist/connect/getMongoConnection.d.ts

@@ -0,0 +1,8 @@
+import type { OrionMongoClient } from './connections';
+export declare const allConnectionPromises: any[];
+interface MongoConnectOptions {
+    name: string;
+    uri?: string;
+}
+export declare const getMongoConnection: ({ name, uri }: MongoConnectOptions) => OrionMongoClient;
+export {};

package/dist/connect/getMongoURLFromEnv.d.ts

@@ -0,0 +1,2 @@
+export declare const getMongoURLFromEnv: (connectionName: string) => string;
+export declare const requiresExplicitSetup: (connectionName: string) => boolean;

package/dist/connect/index.d.ts

@@ -0,0 +1,4 @@
+import { connections, configureConnection } from './connections';
+import { allConnectionPromises, getMongoConnection } from './getMongoConnection';
+import getDBName from './getDBName';
+export { getMongoConnection, connections, allConnectionPromises, configureConnection, getDBName };

package/dist/createCollection/collectionsRegistry.d.ts

@@ -0,0 +1,58 @@
+import type { Collection, CollectionIndex, ModelClassBase } from '../types';
+import { DeleteUnusedIndexesResult } from './deleteUnusedIndexes';
+/**
+ * Registry that tracks all collections created via createCollection().
+ * Maps connection name to a map of collection name to collection instance.
+ * When the same collection is registered multiple times, indexes are merged.
+ */
+export declare const collectionsRegistry: Map<string, Map<string, Collection<ModelClassBase>>>;
+/**
+ * Registers a collection in the registry.
+ * Called automatically when a collection is created via createCollection().
+ * If the same collection name is registered multiple times, indexes are merged
+ * to support multiple createCollection() calls for the same collection.
+ * @param connectionName - The name of the MongoDB connection
+ * @param collection - The collection instance to register
+ */
+export declare function registerCollection(connectionName: string, collection: Collection<ModelClassBase>): void;
+/**
+ * Gets all registered collections for a specific connection.
+ * @param connectionName - The name of the MongoDB connection (defaults to 'main')
+ * @returns Array of registered collections for the connection
+ */
+export declare function getRegisteredCollections(connectionName?: string): Array<Collection<ModelClassBase>>;
+/**
+ * Gets the merged indexes for a specific collection from the registry.
+ * This includes all indexes from all createCollection() calls for the same collection name.
+ * @param connectionName - The name of the MongoDB connection
+ * @param collectionName - The name of the collection
+ * @returns Array of merged index definitions, or empty array if collection not registered
+ */
+export declare function getMergedIndexes(connectionName: string, collectionName: string): CollectionIndex[];
+/**
+ * Deletes unused indexes from all registered collections for a connection.
+ * Iterates over all collections registered via createCollection() and
+ * removes indexes that exist in MongoDB but are not defined in the collection configuration.
+ *
+ * **Important**: This function waits for all pending index creation to complete before
+ * deleting any indexes, to avoid race conditions where an index being created might
+ * be incorrectly identified as unused.
+ *
+ * @param connectionName - The name of the MongoDB connection (defaults to 'main')
+ * @returns Array of results for each collection that had indexes deleted
+ *
+ * @example
+ * ```ts
+ * // Delete unused indexes from all collections on the main connection
+ * const results = await deleteAllUnusedIndexes()
+ *
+ * // Delete unused indexes from all collections on a specific connection
+ * const results = await deleteAllUnusedIndexes('secondary')
+ *
+ * // Log results
+ * for (const result of results) {
+ *   console.log(`${result.collectionName}: deleted ${result.deletedIndexes.length} indexes`)
+ * }
+ * ```
+ */
+export declare function deleteAllUnusedIndexes(connectionName?: string): Promise<DeleteUnusedIndexesResult[]>;

package/dist/createCollection/createIndexes.d.ts

@@ -0,0 +1,12 @@
+import { Collection, ModelClassBase } from '..';
+export interface MongoDBIndex {
+    key: Record<string, unknown>;
+    name: string;
+}
+/**
+ * Checks for indexes in the database that are not defined in the collection configuration.
+ * Uses merged indexes from all createCollection() calls for the same collection name.
+ * Logs a warning if unexpected indexes are found.
+ */
+export declare function checkIndexes<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): Promise<void>;
+export declare function loadIndexes<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): Promise<string[]>;

package/dist/createCollection/deleteUnusedIndexes.d.ts

@@ -0,0 +1,45 @@
+import { Collection, CollectionIndex, ModelClassBase } from '../types';
+/**
+ * Represents a MongoDB index as returned by the indexes() method
+ */
+interface MongoDBIndex {
+    key: Record<string, unknown>;
+    name: string;
+}
+/**
+ * Compares two index key specifications for equality.
+ * Handles key order and special index types (2dsphere, hashed, etc.)
+ * Note: Text indexes are handled separately due to their special structure.
+ * @param definitionKeys - The keys from the collection index definition
+ * @param currentIndexKey - The keys from the current MongoDB index
+ * @returns true if the keys match exactly in order and values
+ */
+export declare function keysMatch(definitionKeys: Record<string, unknown>, currentIndexKey: Record<string, unknown>): boolean;
+/**
+ * Checks if a current database index matches any of the defined indexes.
+ * First checks by custom name if provided (supports both flat and deprecated formats),
+ * then by key specification. Handles text indexes specially since MongoDB stores
+ * them with different key structure (_fts, _ftsx).
+ * @param definedIndexes - Array of index definitions from the collection
+ * @param currentIndex - The index from MongoDB to check
+ * @returns true if the index is defined in the collection configuration
+ */
+export declare function isIndexDefined(definedIndexes: CollectionIndex[], currentIndex: MongoDBIndex): boolean;
+/**
+ * Result of the deleteUnusedIndexes operation
+ */
+export interface DeleteUnusedIndexesResult {
+    /** Names of the indexes that were deleted */
+    deletedIndexes: string[];
+    /** Name of the collection that was cleaned */
+    collectionName: string;
+}
+/**
+ * Deletes indexes that exist in MongoDB but are not defined in the collection configuration.
+ * This helps clean up stale indexes that are no longer needed.
+ * Always preserves the _id_ index.
+ * @param collection - The collection to clean unused indexes from
+ * @returns Information about which indexes were deleted
+ */
+export declare function deleteUnusedIndexes<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): Promise<DeleteUnusedIndexesResult>;
+export {};

package/dist/createCollection/generateId.d.ts

@@ -0,0 +1,3 @@
+import { CreateCollectionOptions, ModelClassBase } from '..';
+declare const getIdGenerator: <DocumentType extends ModelClassBase>(options: CreateCollectionOptions) => (() => DocumentType['_id']);
+export default getIdGenerator;

package/dist/createCollection/getIndexOptions.d.ts

@@ -0,0 +1,30 @@
+import type { CreateIndexesOptions } from 'mongodb';
+import type { CollectionIndex } from '../types';
+/**
+ * Extracts the index options from a CollectionIndex definition.
+ * Handles both the new flat format and the deprecated nested options format.
+ *
+ * @example New format (recommended):
+ * ```ts
+ * { keys: { email: 1 }, unique: true, sparse: true }
+ * // Returns: { unique: true, sparse: true }
+ * ```
+ *
+ * @example Old format (deprecated):
+ * ```ts
+ * { keys: { email: 1 }, options: { unique: true } }
+ * // Returns: { unique: true }
+ * ```
+ *
+ * @param indexDef - The index definition from the collection configuration
+ * @returns The MongoDB CreateIndexesOptions to pass to createIndex()
+ */
+export declare function getIndexOptions(indexDef: CollectionIndex): CreateIndexesOptions | undefined;
+/**
+ * Gets the custom name from an index definition if one was specified.
+ * Handles both flat format and deprecated nested options format.
+ *
+ * @param indexDef - The index definition from the collection configuration
+ * @returns The custom index name if specified, undefined otherwise
+ */
+export declare function getIndexName(indexDef: CollectionIndex): string | undefined;

package/dist/createCollection/getMethods/cleanModifier.d.ts

@@ -0,0 +1,5 @@
+import * as MongoDB from 'mongodb';
+import { ModelClassBase } from '../../types';
+export default function cleanModifier<ModelClass extends ModelClassBase, TFilter extends MongoDB.UpdateFilter<ModelClass>>(schema: any, modifier: TFilter, { isUpsert }?: {
+    isUpsert: boolean;
+}): Promise<TFilter>;

package/dist/createCollection/getMethods/countDocuments.d.ts

@@ -0,0 +1,2 @@
+import { Collection, CountDocuments, ModelClassBase } from '../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): CountDocuments<DocumentType>;

package/dist/createCollection/getMethods/dataLoader/dataLoad/getDataLoader.d.ts

@@ -0,0 +1,9 @@
+import DataLoader from 'dataloader';
+export declare const cache: Map<string, DataLoader<any, any, any>>;
+interface Options {
+    key: string;
+    func: (ids: Array<string>) => Promise<any>;
+    timeout: number;
+}
+export declare const getDataLoader: (params: Options) => DataLoader<any, any>;
+export {};

package/dist/createCollection/getMethods/dataLoader/dataLoad/index.d.ts

@@ -0,0 +1,9 @@
+interface Options {
+    loaderKey: any;
+    load: (values: Array<string>) => Promise<any>;
+    timeout?: number;
+    ids?: Array<string>;
+    id?: string;
+}
+declare const dataLoad: (options: Options) => Promise<any>;
+export default dataLoad;

package/dist/createCollection/getMethods/dataLoader/index.d.ts

@@ -0,0 +1,5 @@
+import loadById from './loadById';
+import loadMany from './loadMany';
+import loadOne from './loadOne';
+import loadData from './loadData';
+export { loadData, loadById, loadOne, loadMany };

package/dist/createCollection/getMethods/dataLoader/loadById.d.ts

@@ -0,0 +1,2 @@
+import { Collection, DataLoader, ModelClassBase } from '../../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): DataLoader.LoadById<DocumentType>;

package/dist/createCollection/getMethods/dataLoader/loadData.d.ts

@@ -0,0 +1,2 @@
+import { Collection, DataLoader, ModelClassBase } from '../../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): DataLoader.LoadData<DocumentType>;

package/dist/createCollection/getMethods/dataLoader/loadMany.d.ts

@@ -0,0 +1,2 @@
+import { Collection, DataLoader, ModelClassBase } from '../../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): DataLoader.LoadMany<DocumentType>;

package/dist/createCollection/getMethods/dataLoader/loadOne.d.ts

@@ -0,0 +1,2 @@
+import { Collection, DataLoader, ModelClassBase } from '../../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): DataLoader.LoadOne<DocumentType>;

package/dist/createCollection/getMethods/deleteMany.d.ts

@@ -0,0 +1,2 @@
+import { Collection, DeleteMany, ModelClassBase } from '../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): DeleteMany<DocumentType>;

package/dist/createCollection/getMethods/deleteOne.d.ts

@@ -0,0 +1,2 @@
+import { Collection, DeleteOne, ModelClassBase } from '../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): DeleteOne<DocumentType>;

package/dist/createCollection/getMethods/estimatedDocumentCount.d.ts

@@ -0,0 +1,3 @@
+import { Collection, EstimatedDocumentCount, ModelClassBase } from '../../types';
+export default _default;
+declare function _default<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): EstimatedDocumentCount<DocumentType>;

package/dist/createCollection/getMethods/find.d.ts

@@ -0,0 +1,2 @@
+import { Collection, Find, ModelClassBase } from '../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): Find<DocumentType>;

package/dist/createCollection/getMethods/findOne.d.ts

@@ -0,0 +1,2 @@
+import { Collection, FindOne, ModelClassBase } from '../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): FindOne<DocumentType>;

package/dist/createCollection/getMethods/findOneAndUpdate.d.ts

@@ -0,0 +1,3 @@
+import { Collection, FindOneAndUpdate, ModelClassBase } from '../../types';
+export default _default;
+declare function _default<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): FindOneAndUpdate<DocumentType>;

package/dist/createCollection/getMethods/getSelector.d.ts

@@ -0,0 +1,3 @@
+import { Filter } from 'mongodb';
+import { ModelClassBase } from '../../types';
+export default function getSelector<ModelClass extends ModelClassBase>(args: IArguments | any[]): Filter<ModelClass>;

package/dist/createCollection/getMethods/index.d.ts

@@ -0,0 +1,16 @@
+import find from './find';
+import findOne from './findOne';
+import upsert from './upsert';
+import findOneAndUpdate from './findOneAndUpdate';
+import updateOne from './updateOne';
+import updateMany from './updateMany';
+import updateAndFind from './updateAndFind';
+import deleteOne from './deleteOne';
+import deleteMany from './deleteMany';
+import insertOne from './insertOne';
+import insertMany from './insertMany';
+import updateItem from './updateItem';
+import countDocuments from './countDocuments';
+import estimatedDocumentCount from './estimatedDocumentCount';
+import insertAndFind from './insertAndFind';
+export { findOne, find, findOneAndUpdate, insertOne, insertMany, insertAndFind, updateOne, updateMany, updateAndFind, updateItem, deleteOne, deleteMany, upsert, estimatedDocumentCount, countDocuments, };

package/dist/createCollection/getMethods/insertAndFind.d.ts

@@ -0,0 +1,3 @@
+import { Collection, InsertAndFind, ModelClassBase } from '../../types';
+export default _default;
+declare function _default<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): InsertAndFind<DocumentType>;

package/dist/createCollection/getMethods/insertMany.d.ts

@@ -0,0 +1,3 @@
+import { Collection, InsertMany, ModelClassBase } from '../../types';
+export default _default;
+declare function _default<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): InsertMany<DocumentType>;

package/dist/createCollection/getMethods/insertOne.d.ts

@@ -0,0 +1,3 @@
+import { Collection, InsertOne, ModelClassBase } from '../../types';
+export default _default;
+declare function _default<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): InsertOne<DocumentType>;

package/dist/createCollection/getMethods/updateAndFind.d.ts

@@ -0,0 +1,3 @@
+import { Collection, ModelClassBase, UpdateAndFind } from '../../types';
+export default _default;
+declare function _default<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): UpdateAndFind<DocumentType>;

package/dist/createCollection/getMethods/updateItem.d.ts

@@ -0,0 +1,2 @@
+import { Collection, ModelClassBase, UpdateItem } from '../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): UpdateItem<DocumentType>;

package/dist/createCollection/getMethods/updateMany.d.ts

@@ -0,0 +1,3 @@
+import { Collection, ModelClassBase, UpdateMany } from '../../types';
+export default _default;
+declare function _default<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): UpdateMany<DocumentType>;

package/dist/createCollection/getMethods/updateOne.d.ts

@@ -0,0 +1,3 @@
+import { Collection, ModelClassBase, UpdateOne } from '../../types';
+export default _default;
+declare function _default<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): UpdateOne<DocumentType>;

package/dist/createCollection/getMethods/upsert.d.ts

@@ -0,0 +1,3 @@
+import { Collection, ModelClassBase, Upsert } from '../../types';
+export default _default;
+declare function _default<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): Upsert<DocumentType>;

package/dist/createCollection/getMethods/validateModifier/index.d.ts

@@ -0,0 +1 @@
+export default function validateModifier(schema: any, modifier: any): Promise<void>;

package/dist/createCollection/getMethods/validateModifier/validateInc.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validates $inc
+ */
+export default function ({ schema, operationDoc }: {
+    operationDoc: any;
+    schema: any;
+}): Promise<void>;

package/dist/createCollection/getMethods/validateModifier/validateOperator.d.ts

@@ -0,0 +1,5 @@
+export default function ({ schema, operationDoc, operation }: {
+    operation: any;
+    operationDoc: any;
+    schema: any;
+}): Promise<void>;

package/dist/createCollection/getMethods/validateModifier/validatePush.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Validates $push and $addToSet
+ */
+export default function ({ schema, operationDoc, operation }: {
+    operation: any;
+    operationDoc: any;
+    schema: any;
+}): Promise<void>;

package/dist/createCollection/getMethods/validateModifier/validateSet.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validates $set
+ */
+export default function ({ schema, operationDoc }: {
+    operationDoc: any;
+    schema: any;
+}): Promise<void>;

package/dist/createCollection/getMethods/validateModifier/validateUnset.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validates $unset
+ */
+export default function ({ schema, operationDoc }: {
+    operationDoc: any;
+    schema: any;
+}): Promise<void>;

package/dist/createCollection/getMethods/validateModifier/validateUpsert.d.ts

@@ -0,0 +1 @@
+export default function (schema: any, selector: any, modifier: any): Promise<void>;

package/dist/createCollection/getMethods/wrapErrors.d.ts

@@ -0,0 +1 @@
+export declare const wrapErrors: <TFunc extends () => Promise<any>>(operation: TFunc) => Promise<ReturnType<TFunc>>;

package/dist/createCollection/getSchemaAndModel.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from '@orion-js/schema';
+import { CreateCollectionOptions } from '../types';
+export declare function prepareShema(schema: Schema): Schema;
+export declare function getSchema(options: CreateCollectionOptions): Schema;

package/dist/createCollection/index.d.ts

@@ -0,0 +1,10 @@
+import { Collection, CreateCollectionOptions, CreateCollectionOptionsWithSchemaType, CreateCollectionOptionsWithTypedSchema, InferSchemaTypeWithId, ModelClassBase, SchemaWithRequiredId } from '../types';
+import { InferSchemaType, TypedSchemaOnSchema } from '@orion-js/schema';
+export declare const createIndexesPromises: any[];
+export declare function createCollection<T extends SchemaWithRequiredId>(options: CreateCollectionOptionsWithSchemaType<T>): Collection<InferSchemaTypeWithId<T>>;
+export declare function createCollection<T extends TypedSchemaOnSchema & {
+    prototype: {
+        _id: string;
+    };
+}>(options: CreateCollectionOptionsWithTypedSchema<T>): Collection<InferSchemaType<T>>;
+export declare function createCollection<T extends ModelClassBase>(options: CreateCollectionOptions<T>): Collection<T>;

package/dist/createCollection/wrapMethods.d.ts

@@ -0,0 +1,2 @@
+import { Collection } from '../types';
+export declare function wrapMethods(collection: Partial<Collection>): void;

package/dist/encrypted/getOrCreateEncryptionKey.d.ts

@@ -0,0 +1,17 @@
+import { AWSEncryptionKeyOptions, KMSProviders, UUID } from 'mongodb';
+export declare function getOrCreateEncryptionKey({ keyAltName, kmsProvider, masterKey, connectionName, keyVaultDatabase, keyVaultCollection, kmsProviders, }: {
+    keyAltName: string;
+    kmsProvider: keyof KMSProviders;
+    masterKey?: AWSEncryptionKeyOptions;
+    connectionName?: string;
+    keyVaultDatabase?: string;
+    keyVaultCollection?: string;
+    kmsProviders: KMSProviders;
+}): Promise<{
+    key: UUID;
+    keyVaultNamespace: string;
+}>;
+export declare const ENCRYPTION_ALGORITHMS: {
+    DETERMINISTIC: string;
+    RANDOM: string;
+};

package/dist/helpers/fromDot.d.ts

@@ -0,0 +1 @@
+export default function fromDot(doc: any): any;

package/dist/helpers/toDot.d.ts

@@ -0,0 +1 @@
+export default function (doc: any): any;