@orion-js/dogs 3.11.15 → 4.0.0-alpha.3

package/dist/index.d.ts

@@ -0,0 +1,748 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import * as MongoDB from 'mongodb';
+import { Db, MongoClient } from 'mongodb';
+
+export type Blackbox = {
+	[name: string]: any;
+};
+export type LogFunction = (message: string, metadata?: any) => void;
+export interface OrionLogger {
+	debug: LogFunction;
+	info: LogFunction;
+	warn: LogFunction;
+	error: LogFunction;
+	addContext: (module: NodeJS.Module) => OrionLogger;
+	addMetadata: (metadata: any) => OrionLogger;
+}
+export interface JobToRun {
+	jobId: string;
+	executionId: string;
+	name: string;
+	type: "event" | "recurrent";
+	params: Blackbox;
+	tries: number;
+	lockTime: number;
+	priority: number;
+	uniqueIdentifier?: string;
+}
+export interface ExecutionContext {
+	record: JobToRun;
+	definition: JobDefinition;
+	tries: number;
+	logger: OrionLogger;
+	extendLockTime: (extraTime: number) => Promise<void>;
+	clearStaleTimeout: () => void;
+}
+export interface WorkerInstance {
+	running: boolean;
+	workerIndex: number;
+	stop: () => Promise<void>;
+	respawn: () => Promise<void>;
+	promise?: Promise<any>;
+}
+export interface WorkersInstance {
+	running: boolean;
+	workersCount: number;
+	workers: WorkerInstance[];
+	/**
+	 * Stop all workers and wait for them to finish
+	 */
+	stop: () => Promise<void>;
+}
+export interface JobRetryResultBase {
+	action: "retry" | "dismiss";
+}
+export type JobRetryResultRunIn = JobRetryResultBase & {
+	runIn: number;
+};
+export type JobRetryResultRunAt = JobRetryResultBase & {
+	runAt: Date;
+};
+export type JobRetryResult = JobRetryResultRunIn | JobRetryResultRunAt | JobRetryResultBase;
+export interface BaseJobDefinition {
+	/**
+	 * The function to execute when the job is executed.
+	 */
+	resolve: (params: Blackbox, context: ExecutionContext) => Promise<Blackbox | void>;
+	/**
+	 * Called if the job fails.
+	 */
+	onError?: (error: Error, params: Blackbox, context: ExecutionContext) => Promise<JobRetryResult>;
+	/**
+	 * Called if the job locktime is expired. The job will be executed again.
+	 */
+	onStale?: (params: Blackbox, context: ExecutionContext) => Promise<void>;
+	/**
+	 * Save the executions of the job time in milliseconds. Default is 1 week. Set to 0 to disable.
+	 */
+	saveExecutionsFor?: number;
+}
+export interface RecurrentJobDefinition extends BaseJobDefinition {
+	/**
+	 * Type of the job.
+	 */
+	type: "recurrent";
+	/**
+	 * A function executed after each execution that returns the date of the next run.
+	 */
+	getNextRun?: () => Date;
+	/**
+	 * Run every x milliseconds. This will be ignored if getNextRun is defined.
+	 */
+	runEvery?: number;
+	/**
+	 * The priority of the job. Higher is more priority. Default is 100.
+	 */
+	priority?: number;
+}
+export interface EventJobDefinition extends BaseJobDefinition {
+	/**
+	 * Type of the job.
+	 */
+	type: "event";
+}
+export type JobDefinition = RecurrentJobDefinition | EventJobDefinition;
+export type JobDefinitionWithName = JobDefinition & {
+	name: string;
+};
+export interface JobsDefinition {
+	[jobName: string]: JobDefinition;
+}
+export declare const defineJob: (options: JobDefinition) => JobDefinition;
+export type LogLevels = "debug" | "info" | "warn" | "error" | "none";
+export interface StartWorkersConfig {
+	/**
+	 * Object map of the jobs that this workers will execute
+	 */
+	jobs: JobsDefinition;
+	/**
+	 * Time in milliseconds to wait between each look without results for a job
+	 * to run at the database. Default is 3000.
+	 */
+	pollInterval: number;
+	/**
+	 * Time in milliseconds to wait too look for a job after a job execution. Default is 100.
+	 */
+	cooldownPeriod: number;
+	/**
+	 * Number of workers to start. Default is 1.
+	 */
+	workersCount: number;
+	/**
+	 * Time in milliseconds to lock a job for execution. Default is 30000 (30 seconds).
+	 * If a job is locked for longer than this time, it will be considered as failed.
+	 * This is to prevent a job from being executed multiple times at the same time.
+	 * You can extend this time inside a job by calling extendLockTime from context.
+	 */
+	lockTime: number;
+}
+export interface ScheduleJobOptionsBase {
+	name: string;
+	params?: Blackbox;
+	priority?: number;
+	uniqueIdentifier?: string;
+}
+export type ScheduleJobOptionsRunIn = ScheduleJobOptionsBase & {
+	runIn: number;
+};
+export type ScheduleJobOptionsRunAt = ScheduleJobOptionsBase & {
+	runAt: Date;
+};
+export type ScheduleJobOptions = ScheduleJobOptionsRunIn | ScheduleJobOptionsRunAt | ScheduleJobOptionsBase;
+export interface ScheduleJobRecordOptions {
+	name: string;
+	params: Blackbox;
+	nextRunAt: Date;
+	priority: number;
+	uniqueIdentifier?: string;
+}
+// Generated by dts-bundle-generator v9.5.1
+// Generated by dts-bundle-generator v9.5.1
+// Generated by dts-bundle-generator v9.5.1
+export interface StoredCacheData {
+	value: any;
+	expires?: Date;
+}
+export interface SetCacheOptions {
+	ttl?: number;
+}
+export interface GetCacheOptions {
+	ttl?: number;
+	fallback?(): Promise<any>;
+}
+export interface OrionCache {
+	/**
+	 * Save data in the cache
+	 */
+	set(key: string, value: any, options?: SetCacheOptions): Promise<void> | void;
+	/**
+	 * Get data from the cache
+	 */
+	get(key: string, options?: GetCacheOptions): Promise<StoredCacheData>;
+	/**
+	 * Removes data from the cache
+	 */
+	invalidate(key: string): Promise<void> | void;
+}
+type Blackbox$1 = {
+	[name: string]: any;
+};
+export type ModelResolverResolve = (item: any, params: any, viewer: any, info?: any) => Promise<any>;
+export type GlobalCheckPermissions = (params: any, viewer: any, info?: any) => Promise<string | void>;
+export type ModelCheckPermissions = (parent: any, params: any, viewer: any, info?: any) => Promise<string | void>;
+export type GlobalGetCacheKey = (params: any, viewer: any, info: any) => Promise<any>;
+export type ModelGetCacheKey = (parent: any, params: any, viewer: any, info: any) => Promise<any>;
+export interface ExecuteOptions {
+	params: Blackbox$1;
+	viewer: any;
+	parent?: any;
+	info?: any;
+	options: ResolverOptions;
+}
+export type Parameters$1<T> = T extends (...args: infer P) => any ? P : never;
+export type ReturnType$1<T> = T extends (...args: any) => infer R ? R : any;
+export type ResolverParams<Resolve, IsModel> = IsModel extends undefined ? Parameters$1<Resolve>[0] : Parameters$1<Resolve>[1];
+export interface ExecuteParams<Resolve = Function, IsModel = undefined> {
+	params?: ResolverParams<Resolve, IsModel>;
+	viewer?: any;
+	parent?: IsModel extends undefined ? undefined : Parameters$1<Resolve>[0];
+	info?: any;
+}
+export type Execute<Resolve = Function, IsModel = undefined> = (executeOptions: ExecuteParams<Resolve, IsModel>) => ReturnType$1<Resolve>;
+export interface SharedResolverOptions {
+	resolverId?: string;
+	params?: any;
+	returns?: any;
+	mutation?: boolean;
+	private?: boolean;
+	checkPermission?: GlobalCheckPermissions | ModelCheckPermissions;
+	getCacheKey?: GlobalGetCacheKey | ModelGetCacheKey;
+	cache?: number;
+	cacheProvider?: OrionCache;
+	permissionsOptions?: any;
+	middlewares?: ResolverMiddleware[];
+}
+export interface ResolverOptions<Resolve = Function> extends SharedResolverOptions {
+	resolve: Resolve;
+}
+export type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;
+export interface Resolver<Resolve = Function, IsModel = undefined> extends SharedResolverOptions {
+	execute: Execute<Resolve, IsModel>;
+	resolve: Resolve;
+	modelResolve: IsModel extends undefined ? undefined : OmitFirstArg<Resolve>;
+}
+export type ModelResolver<Resolve = Function> = Resolver<Resolve, true>;
+export type ResolverMiddleware = (executeOptions: ExecuteOptions, next: () => Promise<any>) => Promise<any>;
+export interface FieldType {
+	name: string;
+	validate: ValidateFunction;
+	clean: CleanFunction;
+	meta?: any;
+	toGraphQLType?: (GraphQL: any) => any;
+	_isFieldType: boolean;
+}
+export type Constructor<T> = new (...args: any[]) => T;
+export type FieldTypesList = "string" | "date" | "integer" | "number" | "ID" | "boolean" | "email" | "blackbox" | "any";
+export type TypedModelOnSchema = Function;
+export type ConstructorsTypesList = Constructor<String> | Constructor<Number> | Constructor<Boolean> | Constructor<Date>;
+export type SchemaRecursiveNodeTypeExtras = {
+	_isFieldType?: boolean;
+	__clean?: CleanFunction;
+	__validate?: ValidateFunction;
+	__skipChildValidation?: (value: any, info: CurrentNodeInfo) => Promise<boolean>;
+};
+export interface Schema {
+	[key: string]: SchemaNode | Function;
+}
+export type SchemaRecursiveNodeType = Schema & SchemaRecursiveNodeTypeExtras;
+export type SchemaMetaFieldTypeSingle = FieldTypesList | ConstructorsTypesList | SchemaRecursiveNodeType | FieldType | TypedModelOnSchema;
+export type SchemaMetaFieldType = SchemaMetaFieldTypeSingle | SchemaMetaFieldTypeSingle[];
+export type ValidateFunction = (value: any, info?: Partial<CurrentNodeInfo>, ...args: any[]) => object | string | void | Promise<object | string | void>;
+export type CleanFunction = (value: any, info?: Partial<CurrentNodeInfo>, ...args: any[]) => any | Promise<any>;
+export interface SchemaNode {
+	/**
+	 * The type of the field. Used for type validations. Can also contain a subschema.
+	 */
+	type: SchemaMetaFieldType;
+	/**
+	 * Defaults to false
+	 */
+	optional?: boolean;
+	allowedValues?: Array<any>;
+	defaultValue?: ((info: CurrentNodeInfo, ...args: any[]) => any | Promise<any>) | any;
+	/**
+	 * Function that takes a value and returns an error message if there are any errors. Must return null or undefined otherwise.
+	 */
+	validate?: ValidateFunction;
+	/**
+	 * Function that preprocesses a value before it is set.
+	 */
+	clean?: CleanFunction;
+	autoValue?: (value: any, info: CurrentNodeInfo, ...args: any[]) => any | Promise<any>;
+	/**
+	 * The minimum value if it's a number, the minimum length if it's a string or array.
+	 */
+	min?: number;
+	/**
+	 * The maximum value if it's a number, the maximum length if it's a string or array.
+	 */
+	max?: number;
+	/**
+	 * Internal use only.
+	 */
+	isBlackboxChild?: boolean;
+	/**
+	 * @deprecated
+	 */
+	custom?: ValidateFunction;
+	/**
+	 * Used in GraphQL. If true, the field will be omitted from the schema.
+	 */
+	private?: boolean;
+	/**
+	 * Used in GraphQL. When in GraphQL, this resolver will replace the static field.
+	 */
+	graphQLResolver?: (...args: any) => any;
+	/**
+	 * Used in GraphQL. Sets the key of the field in the GraphQL schema. You must set this value when building your schema.
+	 */
+	key?: string;
+	/**
+	 * The name that would be displayed in a front-end form
+	 */
+	label?: string;
+	/**
+	 * The description that would be displayed in a front-end form
+	 */
+	description?: string;
+	/**
+	 * The placeholder that would be displayed in a front-end form
+	 */
+	placeholder?: string;
+	/**
+	 * The field type that would be used in a front-end form
+	 */
+	fieldType?: string;
+	/**
+	 * The field options that will be passed as props to the front-end field
+	 */
+	fieldOptions?: any;
+}
+export interface CurrentNodeInfoOptions {
+	autoConvert?: boolean;
+	filter?: boolean;
+	trimStrings?: boolean;
+	removeEmptyStrings?: boolean;
+	forceDoc?: any;
+	omitRequired?: boolean;
+}
+export interface CurrentNodeInfo {
+	/**
+	 * The global schema, prefaced by {type: {...}} to be compatible with subschemas
+	 * Sometimes it's given without {type: {...}}. TODO: Normalize this.
+	 */
+	schema?: SchemaNode | Schema;
+	/**
+	 * The current node subschema
+	 */
+	currentSchema?: Partial<SchemaNode>;
+	value: any;
+	doc?: any;
+	currentDoc?: any;
+	options?: CurrentNodeInfoOptions;
+	args?: any[];
+	type?: SchemaMetaFieldType;
+	keys?: string[];
+	addError?: (keys: string[], code: string | object) => void;
+}
+export interface ModelResolversMap {
+	[key: string]: ModelResolver<ModelResolverResolve>;
+}
+export interface CloneOptions {
+	name: string;
+	omitFields?: string[];
+	pickFields?: string[];
+	mapFields?: (field: any, key: string) => any;
+	extendSchema?: Schema;
+	extendResolvers?: ModelResolversMap;
+}
+export interface Model<TSchema = any> {
+	__isModel: boolean;
+	/**
+	 * The name of the model, used for example for GraphQL
+	 */
+	name: string;
+	/**
+	 * Returns the schema of the model
+	 */
+	getSchema: () => Schema & {
+		__model: Model;
+	};
+	/**
+	 * Returns the schema without adding __model to the schema
+	 */
+	getCleanSchema: () => Schema;
+	/**
+	 * Returns the model resolvers
+	 */
+	getResolvers: () => ModelResolversMap;
+	/**
+	 * Adds the model resolvers to a item
+	 */
+	initItem: (item: any) => any;
+	/**
+	 * Validates an item using @orion-js/schema
+	 */
+	validate: (item: any) => Promise<any>;
+	/**
+	 * Cleans an item using @orion-js/schema
+	 */
+	clean: (item: any) => Promise<TSchema>;
+	/**
+	 * Cleans and validates an item using @orion-js/schema
+	 */
+	cleanAndValidate: (item: any) => Promise<TSchema>;
+	/**
+	 * Creates a new model using this one as a base
+	 */
+	clone: (cloneOptions: CloneOptions) => Model;
+	/**
+	 * The type of the model. Only use this in typescript
+	 */
+	type: TSchema;
+}
+export interface FieldType$1 {
+	name: string;
+	validate: ValidateFunction$1;
+	clean: CleanFunction$1;
+	meta?: any;
+	toGraphQLType?: (GraphQL: any) => any;
+	_isFieldType: boolean;
+}
+export type Constructor$1<T> = new (...args: any[]) => T;
+export type Blackbox$1 = {
+	[name: string]: any;
+};
+export type FieldTypesList$1 = "string" | "date" | "integer" | "number" | "ID" | "boolean" | "email" | "blackbox" | "any";
+export type TypedModelOnSchema$1 = Function;
+export type ConstructorsTypesList$1 = Constructor$1<String> | Constructor$1<Number> | Constructor$1<Boolean> | Constructor$1<Date>;
+export type SchemaRecursiveNodeTypeExtras$1 = {
+	_isFieldType?: boolean;
+	__clean?: CleanFunction$1;
+	__validate?: ValidateFunction$1;
+	__skipChildValidation?: (value: any, info: CurrentNodeInfo$1) => Promise<boolean>;
+};
+export interface Schema$1 {
+	[key: string]: SchemaNode$1 | Function;
+}
+export type SchemaRecursiveNodeType$1 = Schema$1 & SchemaRecursiveNodeTypeExtras$1;
+export type SchemaMetaFieldTypeSingle$1 = FieldTypesList$1 | ConstructorsTypesList$1 | SchemaRecursiveNodeType$1 | FieldType$1 | TypedModelOnSchema$1;
+export type SchemaMetaFieldType$1 = SchemaMetaFieldTypeSingle$1 | SchemaMetaFieldTypeSingle$1[];
+export type ValidateFunction$1 = (value: any, info?: Partial<CurrentNodeInfo$1>, ...args: any[]) => object | string | void | Promise<object | string | void>;
+export type CleanFunction$1 = (value: any, info?: Partial<CurrentNodeInfo$1>, ...args: any[]) => any | Promise<any>;
+export interface SchemaNode$1 {
+	/**
+	 * The type of the field. Used for type validations. Can also contain a subschema.
+	 */
+	type: SchemaMetaFieldType$1;
+	/**
+	 * Defaults to false
+	 */
+	optional?: boolean;
+	allowedValues?: Array<any>;
+	defaultValue?: ((info: CurrentNodeInfo$1, ...args: any[]) => any | Promise<any>) | any;
+	/**
+	 * Function that takes a value and returns an error message if there are any errors. Must return null or undefined otherwise.
+	 */
+	validate?: ValidateFunction$1;
+	/**
+	 * Function that preprocesses a value before it is set.
+	 */
+	clean?: CleanFunction$1;
+	autoValue?: (value: any, info: CurrentNodeInfo$1, ...args: any[]) => any | Promise<any>;
+	/**
+	 * The minimum value if it's a number, the minimum length if it's a string or array.
+	 */
+	min?: number;
+	/**
+	 * The maximum value if it's a number, the maximum length if it's a string or array.
+	 */
+	max?: number;
+	/**
+	 * Internal use only.
+	 */
+	isBlackboxChild?: boolean;
+	/**
+	 * @deprecated
+	 */
+	custom?: ValidateFunction$1;
+	/**
+	 * Used in GraphQL. If true, the field will be omitted from the schema.
+	 */
+	private?: boolean;
+	/**
+	 * Used in GraphQL. When in GraphQL, this resolver will replace the static field.
+	 */
+	graphQLResolver?: (...args: any) => any;
+	/**
+	 * Used in GraphQL. Sets the key of the field in the GraphQL schema. You must set this value when building your schema.
+	 */
+	key?: string;
+	/**
+	 * The name that would be displayed in a front-end form
+	 */
+	label?: string;
+	/**
+	 * The description that would be displayed in a front-end form
+	 */
+	description?: string;
+	/**
+	 * The placeholder that would be displayed in a front-end form
+	 */
+	placeholder?: string;
+	/**
+	 * The field type that would be used in a front-end form
+	 */
+	fieldType?: string;
+	/**
+	 * The field options that will be passed as props to the front-end field
+	 */
+	fieldOptions?: any;
+}
+export interface CurrentNodeInfoOptions$1 {
+	autoConvert?: boolean;
+	filter?: boolean;
+	trimStrings?: boolean;
+	removeEmptyStrings?: boolean;
+	forceDoc?: any;
+	omitRequired?: boolean;
+}
+export interface CurrentNodeInfo$1 {
+	/**
+	 * The global schema, prefaced by {type: {...}} to be compatible with subschemas
+	 * Sometimes it's given without {type: {...}}. TODO: Normalize this.
+	 */
+	schema?: SchemaNode$1 | Schema$1;
+	/**
+	 * The current node subschema
+	 */
+	currentSchema?: Partial<SchemaNode$1>;
+	value: any;
+	doc?: any;
+	currentDoc?: any;
+	options?: CurrentNodeInfoOptions$1;
+	args?: any[];
+	type?: SchemaMetaFieldType$1;
+	keys?: string[];
+	addError?: (keys: string[], code: string | object) => void;
+}
+export interface OrionMongoClient {
+	client: MongoClient;
+	db: Db;
+	uri: string;
+	dbName: string;
+	connectionPromise: Promise<MongoClient>;
+	connectionName: string;
+}
+export type RemoveFunctions<T extends ModelClassBase> = Pick<T, {
+	[Key in keyof T]-?: T[Key] extends Function ? never : Key;
+}[keyof T]> & {
+	_id: ModelClassBase["_id"];
+};
+export type ModelClassBase = {
+	_id: string;
+} & Blackbox$1;
+export type DocumentWithIdOptional<T extends ModelClassBase> = Omit<T, "_id"> & {
+	/**
+	 * The ID of the document
+	 */
+	_id?: T["_id"];
+};
+export type DocumentWithoutId<T> = Omit<T, "_id">;
+export type ModelToDocumentType<ModelClass extends ModelClassBase> = RemoveFunctions<ModelClass>;
+export type ModelToDocumentTypeWithoutId<ModelClass extends ModelClassBase> = DocumentWithoutId<ModelToDocumentType<ModelClass>>;
+export type ModelToDocumentTypeWithIdOptional<ModelClass extends ModelClassBase> = DocumentWithIdOptional<ModelToDocumentType<ModelClass>>;
+export type ModelToMongoSelector<ModelClass extends ModelClassBase> = MongoSelector<ModelToDocumentType<ModelClass>>;
+export type ModelToUpdateFilter<ModelClass extends ModelClassBase> = MongoDB.UpdateFilter<ModelToDocumentTypeWithoutId<ModelClass>> | Partial<ModelToDocumentTypeWithoutId<ModelClass>>;
+export interface CollectionIndex {
+	keys: MongoDB.IndexSpecification;
+	options?: MongoDB.CreateIndexesOptions;
+}
+declare namespace DataLoader {
+	interface LoadDataOptionsBase<ModelClass extends ModelClassBase> {
+		key: keyof ModelClass;
+		match?: MongoFilter<ModelClass>;
+		sort?: MongoDB.Sort;
+		project?: MongoDB.Document;
+		timeout?: number;
+		debug?: boolean;
+	}
+	export interface LoadDataOptions<ModelClass extends ModelClassBase> extends LoadDataOptionsBase<ModelClass> {
+		value?: any;
+		values?: Array<any>;
+	}
+	export interface LoadOneOptions<ModelClass extends ModelClassBase> extends LoadDataOptionsBase<ModelClass> {
+		value: any;
+	}
+	export type LoadData<ModelClass extends ModelClassBase> = (options: LoadDataOptions<ModelClass>) => Promise<Array<ModelClass>>;
+	export type LoadOne<ModelClass extends ModelClassBase> = (options: LoadOneOptions<ModelClass>) => Promise<ModelClass>;
+	export type LoadMany<ModelClass extends ModelClassBase> = (options: LoadDataOptions<ModelClass>) => Promise<Array<ModelClass>>;
+	export type LoadById<ModelClass extends ModelClassBase> = (id: ModelClass["_id"]) => Promise<ModelClass>;
+	export {};
+}
+export type MongoFilter<ModelClass extends ModelClassBase = ModelClassBase> = MongoDB.Filter<ModelClass> & ({
+	_id?: ModelClass["_id"];
+} | {
+	_id?: {
+		$in: ModelClass["_id"][];
+	};
+});
+export type MongoSelector<ModelClass extends ModelClassBase = ModelClassBase> = ModelClass["_id"] | MongoFilter<ModelClass>;
+export interface FindCursor<ModelClass> extends MongoDB.FindCursor {
+	toArray: () => Promise<Array<ModelClass>>;
+}
+export interface UpdateOptions {
+	clean?: boolean;
+	validate?: boolean;
+	mongoOptions?: MongoDB.UpdateOptions;
+}
+export interface FindOneAndUpdateUpdateOptions {
+	clean?: boolean;
+	validate?: boolean;
+	mongoOptions?: MongoDB.FindOneAndUpdateOptions;
+}
+export interface InsertOptions {
+	clean?: boolean;
+	validate?: boolean;
+	mongoOptions?: MongoDB.InsertOneOptions;
+}
+export type InitItem<ModelClass extends ModelClassBase> = (doc: any) => ModelClass;
+export type FindOne<ModelClass extends ModelClassBase> = (selector?: ModelToMongoSelector<ModelClass>, options?: MongoDB.FindOptions) => Promise<ModelClass>;
+export type Find<ModelClass extends ModelClassBase> = (selector?: ModelToMongoSelector<ModelClass>, options?: MongoDB.FindOptions) => FindCursor<ModelClass>;
+export type FindOneAndUpdate<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<ModelClass>;
+export type UpdateAndFind<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<ModelClass>;
+export type UpdateItem<ModelClass extends ModelClassBase> = (item: ModelClass, modifier: ModelToUpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<void>;
+export type InsertOne<ModelClass extends ModelClassBase> = (doc: ModelToDocumentTypeWithIdOptional<ModelClass>, options?: InsertOptions) => Promise<ModelClass["_id"]>;
+export type InsertMany<ModelClass extends ModelClassBase> = (doc: Array<ModelToDocumentTypeWithIdOptional<ModelClass>>, options?: InsertOptions) => Promise<Array<ModelClass["_id"]>>;
+export type InsertAndFind<ModelClass extends ModelClassBase> = (doc: ModelToDocumentTypeWithIdOptional<ModelClass>, options?: InsertOptions) => Promise<ModelClass>;
+export type DeleteMany<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.DeleteOptions) => Promise<MongoDB.DeleteResult>;
+export type DeleteOne<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.DeleteOptions) => Promise<MongoDB.DeleteResult>;
+export type UpdateOne<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult>;
+export type UpdateMany<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult | MongoDB.Document>;
+export type Upsert<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult>;
+export type EstimatedDocumentCount<ModelClass extends ModelClassBase> = (options?: MongoDB.EstimatedDocumentCountOptions) => Promise<number>;
+export type CountDocuments<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.CountDocumentsOptions) => Promise<number>;
+declare class Collection<ModelClass extends ModelClassBase = ModelClassBase> {
+	name: string;
+	connectionName?: string;
+	schema?: Schema$1;
+	/**
+	 * @deprecated Use schema instead. If you use model, all items will be initialized with the model to add resolvers (which are also deprecated)
+	 */
+	model?: Model;
+	indexes: Array<CollectionIndex>;
+	generateId: () => ModelClass["_id"];
+	getSchema: () => Schema$1;
+	db: MongoDB.Db;
+	client: OrionMongoClient;
+	rawCollection: MongoDB.Collection<ModelClass>;
+	initItem: InitItem<ModelClass>;
+	findOne: FindOne<ModelClass>;
+	find: Find<ModelClass>;
+	insertOne: InsertOne<ModelClass>;
+	insertMany: InsertMany<ModelClass>;
+	insertAndFind: InsertAndFind<ModelClass>;
+	deleteMany: DeleteMany<ModelClass>;
+	deleteOne: DeleteOne<ModelClass>;
+	updateOne: UpdateOne<ModelClass>;
+	updateMany: UpdateMany<ModelClass>;
+	upsert: Upsert<ModelClass>;
+	findOneAndUpdate: FindOneAndUpdate<ModelClass>;
+	/**
+	 * Updates a document and returns the updated document with the changes
+	 */
+	updateAndFind: UpdateAndFind<ModelClass>;
+	updateItem: UpdateItem<ModelClass>;
+	estimatedDocumentCount: EstimatedDocumentCount<ModelClass>;
+	countDocuments: CountDocuments<ModelClass>;
+	aggregate: <T = MongoDB.Document>(pipeline?: MongoDB.Document[], options?: MongoDB.AggregateOptions) => MongoDB.AggregationCursor<T>;
+	watch: <T = MongoDB.Document>(pipeline?: MongoDB.Document[], options?: MongoDB.ChangeStreamOptions) => MongoDB.ChangeStream<T>;
+	loadData: DataLoader.LoadData<ModelClass>;
+	loadOne: DataLoader.LoadOne<ModelClass>;
+	loadMany: DataLoader.LoadMany<ModelClass>;
+	loadById: DataLoader.LoadById<ModelClass>;
+	/**
+	 * Use this function if you are using tests and you pass the
+	 * env var DONT_CREATE_INDEXES_AUTOMATICALLY and you need to
+	 * create the indexes for this collection
+	 */
+	createIndexes: () => Promise<string[]>;
+	createIndexesPromise: Promise<string[]>;
+	connectionPromise: Promise<MongoDB.MongoClient>;
+}
+export declare class HistoryRecord {
+	_id: string;
+	jobId: string;
+	executionId: string;
+	jobName: string;
+	type: "recurrent" | "event";
+	priority: number;
+	tries: number;
+	uniqueIdentifier?: string;
+	startedAt: Date;
+	endedAt: Date;
+	duration: number;
+	expiresAt?: Date;
+	status: "success" | "error" | "stale";
+	errorMessage?: string;
+	params?: Blackbox;
+	result?: Blackbox;
+}
+declare class JobsHistoryRepo {
+	history: () => Collection<HistoryRecord>;
+	saveExecution(record: ModelToDocumentTypeWithoutId<HistoryRecord>): Promise<void>;
+	getExecutions(jobName: string, limit?: number, skip?: number): Promise<HistoryRecord[]>;
+}
+export declare class JobRecord {
+	_id: string;
+	jobName: string;
+	type: "recurrent" | "event";
+	priority: number;
+	uniqueIdentifier?: string;
+	nextRunAt: Date;
+	lastRunAt?: Date;
+	lockedUntil?: Date;
+	tries?: number;
+	params?: any;
+}
+declare class JobsRepo {
+	jobs: () => Collection<JobRecord>;
+	getJobAndLock(jobNames: string[], lockTime: number): Promise<JobToRun>;
+	setJobRecordPriority(jobId: string, priority: number): Promise<void>;
+	scheduleNextRun(options: {
+		jobId: string;
+		nextRunAt: Date;
+		addTries: boolean;
+		priority: number;
+	}): Promise<void>;
+	deleteEventJob(jobId: string): Promise<void>;
+	extendLockTime(jobId: string, extraTime: number): Promise<void>;
+	ensureJobRecord(job: JobDefinitionWithName): Promise<void>;
+	scheduleJob(options: ScheduleJobRecordOptions): Promise<void>;
+}
+export declare function Jobs(): ClassDecorator;
+export interface JobsPropertyDescriptor extends Omit<PropertyDecorator, "value"> {
+	value?: JobDefinition["resolve"];
+}
+export declare function RecurrentJob(options: Omit<RecurrentJobDefinition, "resolve" | "type">): (target: any, propertyKey: string, descriptor: JobsPropertyDescriptor) => void;
+export declare function EventJob(options?: Omit<EventJobDefinition, "resolve" | "type">): (target: any, propertyKey: string, descriptor: JobsPropertyDescriptor) => void;
+export declare function getServiceJobs(target: any): {
+	[key: string]: JobDefinition;
+};
+export declare const jobsHistoryRepo: JobsHistoryRepo;
+export declare const jobsRepo: JobsRepo;
+export declare const startWorkers: (config: Partial<StartWorkersConfig>) => WorkersInstance;
+export declare const scheduleJob: (options: ScheduleJobOptions) => Promise<void>;
+
+export {};