@design-edito/publisher-core 0.0.1

package/dist/types/errors/index.d.ts

@@ -0,0 +1,295 @@
+import type { Outcome } from '@design-edito/tools/agnostic/misc/outcome/index.js';
+export declare enum Codes {
+    HTTP_FORBIDDEN = "http-forbidden",
+    UNKNOWN_ERROR = "unknown-error",
+    DB_ERROR = "db-error",
+    DB_NO_DOCUMENT_MATCHES_FILTER = "db-no-document-matches-filter",
+    DB_RECURSION_LIMIT_REACHED = "db-recursion-limit-reached",
+    RESPONSE_STREAM_FAILED = "response-stream-failed",
+    USER_NOT_AUTHENTICATED = "user-not-authenticated",
+    USER_NOT_AUTHORIZED = "user-not-authorized",
+    USER_DOES_NOT_EXIST = "user-does-not-exist",
+    USER_EMAIL_DOES_NOT_EXIST = "user-email-does-not-exist",
+    USERNAME_ALREADY_TAKEN = "username-already-taken",
+    EMAIL_ADDRESS_ALREADY_TAKEN = "email-address-already-taken",
+    USER_EMAIL_VERIFICATION_TOKEN_NOT_PROVIDED = "user-email-verification-token-not-provided",
+    USER_EMAIL_VERIFICATION_TOKEN_DOES_NOT_EXIST = "user-email-verification-token-does-not-exist",
+    USER_EMAIL_VERIFICATION_PROCESS_FAILED = "user-email-verification-process-failed",
+    USER_EMAIL_ALREADY_VERIFIED = "user-email-already-verified",
+    INVALID_CREDENTIALS = "invalid-credentials",
+    USER_PASSWORD_RENEWAL_TOKEN_DOES_NOT_EXIST = "user-password-renewal-token-does-not-exist",
+    USER_REFRESH_TOKEN_MISSING = "user-refresh-token-missing",
+    USER_REFRESH_TOKEN_REVOKED = "user-refresh-token-revoked",
+    USER_REFRESH_TOKEN_MALFORMED = "user-refresh-token-malformed",
+    USER_REFRESH_TOKEN_EXPIRED = "user-refresh-token-expired",
+    USER_TOKENS_REVOCATION_FAILED = "user-tokens-revocation-failed",
+    USER_ACCESS_TOKEN_GENERATION_FAILED = "user-access-token-generation-failed",
+    USER_REFRESH_TOKEN_GENERATION_FAILED = "user-refresh-token-generation-failed",
+    INVALID_CSRF_TOKEN = "invalid-csrf-token",
+    INVALID_REQUEST_BODY = "invalid-request-body",
+    INVALID_REQUEST_QUERY = "invalid-request-query",
+    INVALID_REQUEST_FILES = "invalid-request-files",
+    INVALID_RESPONSE_BODY = "invalid-response-body",
+    TOO_MANY_REQUESTS = "too-many-requests",
+    USER_DAILY_UPLOAD_QUOTA_EXCEEDED = "user-daily-upload-quota-exceeded",
+    USER_MONTHLY_UPLOAD_QUOTA_EXCEEDED = "user-monthly-upload-quota-exceeded",
+    USER_TOTAL_UPLOAD_QUOTA_EXCEEDED = "user-total-upload-quota-exceeded",
+    USER_UPLOAD_QUOTA_EXCEEDED = "user-upload-quota-exceeded",
+    UPLOAD_FAILED = "upload-failed",
+    FILE_PATH_CIRCULAR_PATTERN_DETECTED = "file-path-circular-pattern-detected",
+    FILE_NOT_FOUND = "file-not-found",
+    FILE_ALREADY_IN_TRASH = "file-already-in-trash",
+    FILE_NOT_IN_TRASH = "file-not-in-trash",
+    FILE_CORRUPTED = "file-corrupted",
+    FILE_INFECTED = "file-infected",
+    FILE_EMPTY = "file-empty",
+    FILE_TOO_LARGE = "file-too-large",
+    FILE_HASH_FAILED = "file-hash-failed",
+    FILE_SCANNER_NOT_REACHABLE = "file-scanner-not-reachable",
+    IMAGE_FORMAT_FAILED = "image-format-failed",
+    IMAGE_TRANSFORM_FAILED = "image-transform-failed",
+    NOT_FOUND = "not-found"
+}
+export declare const register: {
+    readonly "http-forbidden": {
+        readonly message: "The connection must be made over HTTPS";
+        readonly detailsMaker: () => undefined;
+    };
+    readonly "unknown-error": {
+        readonly message: "An unknown error occured";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "db-error": {
+        readonly message: "The database returned an error";
+        readonly detailsMaker: (dbError: string) => {
+            dbError: string;
+        };
+    };
+    readonly "db-no-document-matches-filter": {
+        readonly message: "No document matches the provided filter";
+        readonly detailsMaker: (collectionName: string, filter: any) => {
+            collection: string;
+            filter: string;
+        };
+    };
+    readonly "db-recursion-limit-reached": {
+        readonly message: "The recursion limit has been reached";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "response-stream-failed": {
+        readonly message: "Failed to stream the file";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "user-not-authenticated": {
+        readonly message: "User must be authenticated";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "user-not-authorized": {
+        readonly message: "User has not sufficient permissions";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "user-does-not-exist": {
+        readonly message: "Impossible to retreive user information";
+        readonly detailsMaker: (userId: string) => {
+            userId: string;
+        };
+    };
+    readonly "user-email-does-not-exist": {
+        readonly message: "This email is not tied to any user account";
+        readonly detailsMaker: (email: string) => {
+            email: string;
+        };
+    };
+    readonly "username-already-taken": {
+        readonly message: "This username is already taken";
+        readonly detailsMaker: (username: string) => {
+            username: string;
+        };
+    };
+    readonly "email-address-already-taken": {
+        readonly message: "This email address is already taken";
+        readonly detailsMaker: (email: string) => {
+            email: string;
+        };
+    };
+    readonly "user-email-verification-token-not-provided": {
+        readonly message: "This endpoint expects a token in the URL to process the validation";
+        readonly detailsMaker: () => undefined;
+    };
+    readonly "user-email-verification-token-does-not-exist": {
+        readonly message: "The email verification token provided does not exist";
+        readonly detailsMaker: () => undefined;
+    };
+    readonly "user-email-verification-process-failed": {
+        readonly message: "Something went wrong while updating the user verification status";
+        readonly detailsMaker: (details: string) => string;
+    };
+    readonly "user-email-already-verified": {
+        readonly message: "This user already verified their email";
+        readonly detailsMaker: (email: string) => {
+            email: string;
+        };
+    };
+    readonly "invalid-credentials": {
+        readonly message: "The provided credentials are invalid";
+        readonly detailsMaker: () => undefined;
+    };
+    readonly "user-password-renewal-token-does-not-exist": {
+        readonly message: "The password renewal token provided does not exist";
+        readonly detailsMaker: (email: string, token: string) => {
+            email: string;
+            token: string;
+        };
+    };
+    readonly "user-refresh-token-missing": {
+        readonly message: "No refresh token provided";
+        readonly detailsMaker: () => undefined;
+    };
+    readonly "user-refresh-token-revoked": {
+        readonly message: "The refresh token provided has been revoked";
+        readonly detailsMaker: () => undefined;
+    };
+    readonly "user-refresh-token-malformed": {
+        readonly message: "The refresh token provided is malformed";
+        readonly detailsMaker: () => undefined;
+    };
+    readonly "user-refresh-token-expired": {
+        readonly message: "The refresh token provided has expired";
+        readonly detailsMaker: () => undefined;
+    };
+    readonly "user-tokens-revocation-failed": {
+        readonly message: "The user tokens revocation failed";
+        readonly detailsMaker: (userId: string, tokens: string[]) => {
+            userId: string;
+            tokens: string[];
+        };
+    };
+    readonly "user-access-token-generation-failed": {
+        readonly message: "The user access token generation failed";
+        readonly detailsMaker: (userId: string, error?: string) => {
+            userId: string;
+            error: string | undefined;
+        };
+    };
+    readonly "user-refresh-token-generation-failed": {
+        readonly message: "The user refresh token generation failed";
+        readonly detailsMaker: (userId: string, error?: string) => {
+            userId: string;
+            error: string | undefined;
+        };
+    };
+    readonly "invalid-csrf-token": {
+        readonly message: "The CSRF token provided is invalid";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "invalid-request-body": {
+        readonly message: "The request body provided could not be used for the operation";
+        readonly detailsMaker: (body: any, error: string) => {
+            body: any;
+            error: string;
+        };
+    };
+    readonly "invalid-request-query": {
+        readonly message: "The request query provided could not be used for the operation";
+        readonly detailsMaker: (query: any, error: string) => {
+            query: any;
+            error: string;
+        };
+    };
+    readonly "invalid-request-files": {
+        readonly message: "The files provided in the request are not valid";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "invalid-response-body": {
+        readonly message: "Internal server error: The response body provided could was not allowoed to be sent";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "too-many-requests": {
+        readonly message: "Too many requests";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "user-daily-upload-quota-exceeded": {
+        readonly message: "The user daily upload quota has been exceeded";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "user-monthly-upload-quota-exceeded": {
+        readonly message: "The user monthly upload quota has been exceeded";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "user-total-upload-quota-exceeded": {
+        readonly message: "The user total upload quota has been exceeded";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "user-upload-quota-exceeded": {
+        readonly message: "The user upload quota has been exceeded";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "upload-failed": {
+        readonly message: "The upload failed";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "file-path-circular-pattern-detected": {
+        readonly message: "The file path contains a circular pattern";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "file-not-found": {
+        readonly message: "The file could not be found";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "file-already-in-trash": {
+        readonly message: "The file is already in the trash";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "file-not-in-trash": {
+        readonly message: "The file is not in the trash";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "file-corrupted": {
+        readonly message: "The file has been damaged and cannot be read";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "file-infected": {
+        readonly message: "The file is infected";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "file-empty": {
+        readonly message: "The file is empty";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "file-too-large": {
+        readonly message: "The file is too large";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "file-hash-failed": {
+        readonly message: "The file hash failed";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "file-scanner-not-reachable": {
+        readonly message: "The file scanner is not reachable";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "image-format-failed": {
+        readonly message: "The formatting of the image failed";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "image-transform-failed": {
+        readonly message: "The image transform failed";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+    readonly "not-found": {
+        readonly message: "The requested resource was not found";
+        readonly detailsMaker: (details?: string) => string | undefined;
+    };
+};
+type Register = typeof register;
+export type MessageOf<C extends Codes> = Register[C]['message'];
+export type DetailsMaker<C extends Codes> = Register[C]['detailsMaker'];
+export type DetailsOf<C extends Codes> = ReturnType<DetailsMaker<C>>;
+export type ErrorData<C extends Codes> = {
+    code: C;
+    message: MessageOf<C>;
+    details: DetailsOf<C>;
+};
+export type MakeError = <C extends Codes>(code: C, ...params: Parameters<DetailsMaker<C>>) => ErrorData<C>;
+export type MakeFailureOutcome = <Code extends Codes>(code: Code, ...params: Parameters<DetailsMaker<Code>>) => Outcome.Failure<ErrorData<Code>>;
+export {};

package/dist/types/fs/index.d.ts

@@ -0,0 +1,110 @@
+import type { Readable } from 'node:stream';
+import { Bucket as GCSBucket } from '@google-cloud/storage';
+import { S3Client } from '@aws-sdk/client-s3';
+import { Client as FtpsClient } from 'basic-ftp';
+import SftpClient from 'ssh2-sftp-client';
+import { Outcome } from '@design-edito/tools/agnostic/misc/outcome/index.js';
+export type FileDescriptor = {
+    path: string;
+    hash: string;
+    byteSize: number;
+    mimeType: string;
+    description: string;
+    scannedFile: Buffer | Readable;
+};
+export type Client = GCSBucket | {
+    bucketName: string;
+    client: S3Client;
+} | FtpsClient | SftpClient;
+export type GetClient = () => Promise<Outcome.Either<Client, string>>;
+export declare enum UploadFileErrCode {
+    CLIENT_NOT_AVAILABLE = "client-not-available",
+    UPLOAD_FAILED = "upload-failed",
+    PATH_NOT_AllLOWED = "path-not-allowed"
+}
+export type UploadFile = (fileDescriptor: FileDescriptor, overwrite: boolean) => Promise<Outcome.Either<true, {
+    code: UploadFileErrCode;
+    details?: string;
+}>>;
+export declare enum CopyFileErrCode {
+    CLIENT_NOT_AVAILABLE = "client-not-available",
+    COPY_FAILED = "copy-failed",
+    DEST_PATH_NOT_AllLOWED = "dest-path-not-allowed"
+}
+export type CopyFile = (srcPath: string, destPath: string, overwrite: boolean) => Promise<Outcome.Either<true, {
+    code: CopyFileErrCode;
+    details?: string;
+}>>;
+export declare enum MoveFileErrCode {
+    CLIENT_NOT_AVAILABLE = "client-not-available",
+    MOVE_FAILED = "move-failed",
+    DEST_PATH_NOT_AllLOWED = "dest-path-not-allowed"
+}
+export type MoveFile = (srcPath: string, destPath: string, overwrite: boolean) => Promise<Outcome.Either<true, {
+    code: MoveFileErrCode;
+    details?: string;
+}>>;
+export declare enum DownloadFileErrCode {
+    CLIENT_NOT_AVAILABLE = "client-not-available",
+    DOWNLOAD_FAILED = "download-failed",
+    PATH_NOT_AllLOWED = "path-not-allowed"
+}
+export type DownloadFile = (targetPath: string) => Promise<Outcome.Either<boolean, {
+    code: DownloadFileErrCode;
+}>>;
+export declare enum ExistsFileErrCode {
+    CLIENT_NOT_AVAILABLE = "client-not-available",
+    EXISTS_FAILED = "exists-failed",
+    PATH_NOT_AllLOWED = "path-not-allowed"
+}
+export type ExistsFile = (targetPath: string) => Promise<Outcome.Either<boolean, {
+    code: ExistsFileErrCode;
+}>>;
+export declare enum StatFileErrCode {
+    CLIENT_NOT_AVAILABLE = "client-not-available",
+    STAT_FAILED = "stat-failed",
+    PATH_NOT_AllLOWED = "path-not-allowed"
+}
+export type StatFile = (targetPath: string) => Promise<Outcome.Either<boolean, {
+    code: StatFileErrCode;
+}>>;
+export declare enum RemoveFileErrCode {
+    CLIENT_NOT_AVAILABLE = "client-not-available",
+    REMOVE_FAILED = "remove-failed",
+    PATH_NOT_AllLOWED = "path-not-allowed"
+}
+export type RemoveFile = (targetPath: string) => Promise<Outcome.Either<true, {
+    code: RemoveFileErrCode;
+}>>;
+export declare enum CopyDirErrCode {
+    CLIENT_NOT_AVAILABLE = "client-not-available",
+    COPY_FAILED = "copy-failed",
+    DEST_PATH_NOT_AllLOWED = "dest-path-not-allowed"
+}
+export type CopyDir = (srcPath: string, destPath: string, overwrite: boolean) => Promise<Outcome.Either<true, {
+    code: CopyDirErrCode;
+}>>;
+export declare enum MoveDirErrCode {
+    CLIENT_NOT_AVAILABLE = "client-not-available",
+    MOVE_FAILED = "move-failed",
+    DEST_PATH_NOT_AllLOWED = "dest-path-not-allowed"
+}
+export type MoveDir = (srcPath: string, destPath: string, overwrite: boolean) => Promise<Outcome.Either<true, {
+    code: MoveDirErrCode;
+}>>;
+export declare enum ListDirErrCode {
+    CLIENT_NOT_AVAILABLE = "client-not-available",
+    LIST_FAILED = "list-failed",
+    PATH_NOT_AllLOWED = "path-not-allowed"
+}
+export type ListDir = (targetPath: string) => Promise<Outcome.Either<string[], {
+    code: ListDirErrCode;
+}>>;
+export declare enum RemoveDirErrCode {
+    CLIENT_NOT_AVAILABLE = "client-not-available",
+    REMOVE_FAILED = "remove-failed",
+    PATH_NOT_AllLOWED = "path-not-allowed"
+}
+export type RemoveDir = (targetPath: string) => Promise<Outcome.Either<true, {
+    code: RemoveDirErrCode;
+}>>;

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+import type * as Api from './api/index.js';
+import type * as ApiInternals from './api/internals.js';
+import type * as Auth from './auth/index.js';
+import type * as Csrf from './csrf/index.js';
+import type * as Database from './database/index.js';
+import type * as Dto from './dto/index.js';
+import type * as Email from './email/index.js';
+import type * as Env from './env/index.js';
+import type * as Errors from './errors/index.js';
+import type * as Fs from './fs/index.js';
+import type * as Init from './init/index.js';
+import type * as Jwt from './jwt/index.js';
+import type * as Logs from './logs/index.js';
+import type * as Plugins from './plugins/index.js';
+import type * as PluginsInternals from './plugins/internals.js';
+import type * as Schema from './schema/index.js';
+import type * as Temp from './temp/index.js';
+import type * as Transformers from './transformers/index.js';
+import type * as Uploads from './uploads/index.js';
+import type * as Validation from './validation/index.js';
+export { Api, ApiInternals, Auth, Csrf, Database, Dto, Email, Env, Errors, Fs, Init, Jwt, Logs, Plugins, PluginsInternals, Schema, Temp, Transformers, Uploads, Validation };

package/dist/types/index.js

@@ -0,0 +1 @@
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/types/init/index.d.ts

@@ -0,0 +1 @@
+export type Shutdown = (code: number) => Promise<void>;

package/dist/types/jwt/index.d.ts

@@ -0,0 +1,7 @@
+export type AccessTokenSigned = string;
+export type AccessTokenPayload = {
+    userId: string;
+    isAdmin: boolean;
+    exp: number;
+    refreshCount: number;
+};

package/dist/types/logs/index.d.ts

@@ -0,0 +1,46 @@
+export declare enum Level {
+    FATAL = "fatal",
+    ERROR = "error",
+    WARN = "warn",
+    INFO = "info",
+    HTTP = "http",
+    DEBUG = "debug"
+}
+export declare enum Category {
+    REQUEST = "request",
+    REQUEST_AUTH_DENIED = "request-auth-denied",
+    USER_SIGNUP = "user-creation",
+    USER_LOGIN = "user-login",
+    USER_LOGOUT = "user-logout",
+    USER_TOKENS_RENEWAL = "user-tokens-renewal",
+    USER_PASSWORD_RENEWAL = "user-password-renewal",
+    USER_LOOKUP = "user-lookup",
+    USER_ACCESS_TOKEN_GENERATION = "user-access-token-generation",
+    USER_REFRESH_TOKEN_GENERATION = "user-refresh-token-generation",
+    USER_TOKENS_REVOCATION = "user-tokens-revocation",
+    USER_ACCESS_TOKEN_VERIFICATION = "user-access-token-verification",
+    CRON = "cron",
+    DB = "db",
+    EMAIL = "email",
+    ENV = "env",
+    FS = "fs",
+    INIT = "init",
+    SSL = "ssl",
+    TEMP = "temp",
+    UPLOAD = "upload",
+    WWW = "www",
+    SHUTDOWN = "shutdown",
+    SECURITY = "security",
+    FILE_RESPONSE_STREAM = "file-response-stream",
+    REQUEST_CATCHALL = "request-catchall",
+    USER_EMAIL_VERIFICATION = "email-validation-token-deletion",
+    FILE_PROCESSING = "file-processing"
+}
+export type LogFatal = (category: Category, message: string, details?: {
+    [key: string]: unknown;
+}) => void;
+export type LogError = LogFatal;
+export type LogWarning = LogFatal;
+export type LogInfo = LogFatal;
+export type LogHttp = LogFatal;
+export type LogDebug = LogFatal;

package/dist/types/plugins/index.d.ts

@@ -0,0 +1,3 @@
+export declare enum ENDPOINT {
+}
+export type Contracts = {};

package/dist/types/plugins/internals.d.ts

@@ -0,0 +1,177 @@
+import type { StorageEngine } from 'multer';
+import type { ProcessContract, WorkerErrorResponseMaker, WorkerFileResponseMaker, WorkerJsonResponseMaker, WorkerListResponseMaker, WorkerVoidResponseMaker } from '../api/internals.js';
+import type { Allower } from '../auth/index.js';
+import type { DeleteMany, DeleteOne, FindMany, FindOne, InsertMany, InsertOne, UpdateMany, UpdateOne } from '../database/index.js';
+import type { Send } from '../email/index.js';
+import type { Env } from '../env/index.js';
+import type { register, MakeError, MakeFailureOutcome } from '../errors/index.js';
+import type { CopyDir, CopyFile, DownloadFile, ExistsFile, GetClient, ListDir, MoveDir, MoveFile, RemoveDir, RemoveFile, StatFile, UploadFile } from '../fs/index.js';
+import type { Shutdown } from '../init/index.js';
+import type { LogDebug, LogError, LogFatal, LogHttp, LogInfo, LogWarning } from '../logs/index.js';
+import type { DiscriminateUser, IBaseUserCoreSchema, IBaseUserModel, IBaseUserSchema, IGoogleUserCoreSchema, IGoogleUserModel, IGoogleUserSchema, IHistoryItemSchema, ILocalUserCoreSchema, ILocalUserModel, ILocalUserSchema, IMetaSchema, IUserAuthTokenModel, IUserAuthTokenSchema, IUserEmailValidationTokenModel, IUserEmailValidationTokenSchema, IUserPasswordRenewalTokenModel, IUserPasswordRenewalTokenSchema, IUserRevokedAuthTokenModel, IUserRevokedAuthTokenSchema, IUserUploadQuotaModel, IUserUploadQuotaSchema, AddHistoryToSchema, AddMetaToSchema, AddPasswordToSchema, UserAuthTokenCollectionName, UserCollectionName, UserEmailValidationTokenCollectionName, UserPasswordRenewalTokenCollectionName, UserRevokedAuthTokenCollectionName, UserUploadQuotaCollectionName } from '../schema/index.js';
+import type { CleanupOldFiles, Flush, GeneratePath, GetCurrentByteSize, GetRootPath, IncreaseCurrentByteSize, UpdateCurrentByteSize } from '../temp/index.js';
+import type { BaseUserToDTO, GoogleUserToDTO, LocalUserToDTO } from '../transformers/user/index.js';
+import type { UserUploadQuotaToDTO } from '../transformers/user-upload-quota/index.js';
+import type { GetFileHash, IHttpClamScanner, ScanFile, UpdateUserUploadsQuota } from '../uploads/index.js';
+import type { NoAuthNullValidation, StrongAuthNullValidation, WeakAuthNullValidation } from '../validation/index.js';
+export type PluginGeneratorHooks = {
+    api: {
+        utils: {
+            errorResponse: WorkerErrorResponseMaker;
+            voidResponse: WorkerVoidResponseMaker;
+            jsonResponse: WorkerJsonResponseMaker;
+            listResponse: WorkerListResponseMaker;
+            fileResponse: WorkerFileResponseMaker;
+        };
+    };
+    auth: {
+        allow: Allower;
+    };
+    database: {
+        insertOne: InsertOne;
+        insertMany: InsertMany;
+        findOne: FindOne;
+        findMany: FindMany;
+        updateOne: UpdateOne;
+        updateMany: UpdateMany;
+        deleteOne: DeleteOne;
+        deleteMany: DeleteMany;
+    };
+    email: {
+        send: Send;
+    };
+    env: Env;
+    errors: {
+        register: typeof register;
+        makeError: MakeError;
+        makeFailureOutcome: MakeFailureOutcome;
+    };
+    fs: {
+        getClient: GetClient;
+        uploadFile: UploadFile;
+        copyFile: CopyFile;
+        moveFile: MoveFile;
+        downloadFile: DownloadFile;
+        existsFile: ExistsFile;
+        statFile: StatFile;
+        removeFile: RemoveFile;
+        copyDir: CopyDir;
+        moveDir: MoveDir;
+        listDir: ListDir;
+        removeDir: RemoveDir;
+    };
+    init: {
+        shutdown: Shutdown;
+    };
+    logs: {
+        logFatal: LogFatal;
+        logError: LogError;
+        logWarning: LogWarning;
+        logInfo: LogInfo;
+        logHttp: LogHttp;
+        logDebug: LogDebug;
+    };
+    schema: {
+        _history: {
+            HistoryItemSchema: IHistoryItemSchema;
+            addHistoryToSchema: AddHistoryToSchema;
+        };
+        _meta: {
+            MetaSchema: IMetaSchema;
+            addMetaToSchema: AddMetaToSchema;
+        };
+        _password: {
+            addPasswordToSchema: AddPasswordToSchema;
+        };
+        user: {
+            authToken: {
+                collectionName: UserAuthTokenCollectionName;
+                UserAuthTokenSchema: IUserAuthTokenSchema;
+                UserAuthTokenModel: IUserAuthTokenModel;
+            };
+            emailValidationToken: {
+                collectionName: UserEmailValidationTokenCollectionName;
+                UserEmailValidationTokenSchema: IUserEmailValidationTokenSchema;
+                UserEmailValidationTokenModel: IUserEmailValidationTokenModel;
+            };
+            passwordRenewalToken: {
+                collectionName: UserPasswordRenewalTokenCollectionName;
+                UserPasswordRenewalTokenSchema: IUserPasswordRenewalTokenSchema;
+                UserPasswordRenewalTokenModel: IUserPasswordRenewalTokenModel;
+            };
+            revokedAuthToken: {
+                collectionName: UserRevokedAuthTokenCollectionName;
+                UserRevokedAuthTokenSchema: IUserRevokedAuthTokenSchema;
+                UserRevokedAuthTokenModel: IUserRevokedAuthTokenModel;
+            };
+            uploadQuota: {
+                collectionName: UserUploadQuotaCollectionName;
+                UserUploadQuotaSchema: IUserUploadQuotaSchema;
+                UserUploadQuotaModel: IUserUploadQuotaModel;
+            };
+            user: {
+                collectionName: UserCollectionName;
+                BaseUserCoreSchema: IBaseUserCoreSchema;
+                LocalUserCoreSchema: ILocalUserCoreSchema;
+                GoogleUserCoreSchema: IGoogleUserCoreSchema;
+                BaseUserSchema: IBaseUserSchema;
+                LocalUserSchema: ILocalUserSchema;
+                GoogleUserSchema: IGoogleUserSchema;
+                BaseUserModel: IBaseUserModel;
+                LocalUserModel: ILocalUserModel;
+                GoogleUserModel: IGoogleUserModel;
+                discriminateUser: DiscriminateUser;
+            };
+        };
+    };
+    temp: {
+        getRootPath: GetRootPath;
+        generatePath: GeneratePath;
+        cleanupOldFiles: CleanupOldFiles;
+        updateCurrentByteSize: UpdateCurrentByteSize;
+        getCurrentByteSize: GetCurrentByteSize;
+        increaseCurrentByteSize: IncreaseCurrentByteSize;
+        flush: Flush;
+    };
+    transformers: {
+        user: {
+            baseUserToDTO: BaseUserToDTO;
+            localUserToDTO: LocalUserToDTO;
+            googleUserToDTO: GoogleUserToDTO;
+        };
+        userUploadQuota: {
+            userUploadQuotaToDTO: UserUploadQuotaToDTO;
+        };
+    };
+    upload: {
+        multerStorage: StorageEngine;
+        scanner: IHttpClamScanner;
+        scanFile: ScanFile;
+        getFileHash: GetFileHash;
+        updateUserUploadsQuota: UpdateUserUploadsQuota;
+    };
+    validation: {
+        noAuthNullValidation: NoAuthNullValidation;
+        weakAuthNullValidation: WeakAuthNullValidation;
+        strongAuthNullValidation: StrongAuthNullValidation;
+    };
+};
+export type Task = {
+    name: string;
+    interval: string;
+    cronTask: () => void | Promise<void>;
+    errHandler?: (err: unknown) => Promise<void> | void;
+};
+export type TaskGenerator = (hooks: PluginGeneratorHooks) => Promise<Task>;
+export type Contract<T extends ProcessContract<any, any, any, any, any, any, any, any>> = T;
+export type ContractGenerator<T extends ProcessContract<any, any, any, any, any, any, any, any>> = (hooks: PluginGeneratorHooks) => Promise<Contract<T>>;
+export type Plugin<T extends Record<string, ProcessContract<any, any, any, any, any, any, any, any>>> = {
+    name: string;
+    contracts: T;
+    tasks: Task[];
+};
+export type PluginGenerator<T extends Record<string, ProcessContract<any, any, any, any, any, any, any, any>>> = {
+    name: string | ((hooks: PluginGeneratorHooks) => Promise<string> | string);
+    tasks: TaskGenerator[];
+    contracts: Record<keyof T, ContractGenerator<T[keyof T]>>;
+};