@lyxa.ai/core 1.0.144 → 1.0.145-debug

package/utilities/validation/common-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-validation.d.ts","sourceRoot":"/","sources":["utilities/validation/common-validation.ts"],"names":[],"mappings":"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"}

package/utilities/validation/global-validation.d.ts

@@ -0,0 +1,170 @@
+import { z } from 'zod';
+import { mongoose } from '@typegoose/typegoose';
+export declare class ZodValidation {
+    static objectId(field?: string): z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    static enumType<T extends z.EnumLike>(enumObj: T, field?: string): z.ZodNativeEnum<T>;
+    static number(field?: string, options?: {
+        min?: number;
+        max?: number;
+        isInt?: boolean;
+        isPositive?: boolean;
+        isNonpositive?: boolean;
+        isNegative?: boolean;
+        isNonnegative?: boolean;
+    }): z.ZodNumber;
+    static string(field?: string, options?: {
+        minLength?: number;
+        maxLength?: number;
+        minMessage?: string;
+        maxMessage?: string;
+        requiredMessage?: string;
+        regex?: {
+            pattern: RegExp;
+            message: string;
+        };
+        isTrimmed?: boolean;
+    }): z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    static email(field?: string, options?: {
+        requiredMessage?: string;
+        invalidMessage?: string;
+    }): z.ZodString;
+    static url(field?: string): z.ZodString;
+    static phoneNumber(field?: string): z.ZodEffects<z.ZodString, string, string>;
+    static date(field?: string, minDate?: Date, maxDate?: Date): z.ZodEffects<z.ZodEffects<z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Date, string>, z.ZodDate]>, Date, string | Date>, Date, string | Date>;
+    static boolean(field?: string): z.ZodBoolean;
+    static array<T extends z.ZodTypeAny>(schema: T, field?: string, minItems?: number, maxItems?: number): z.ZodArray<T, "many">;
+    static timestamps(): {
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+        deletedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    };
+    static trackingFields(): {
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+        deletedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+        createdBy: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>>;
+        updatedBy: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>>;
+        deletedBy: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>>;
+    };
+}
+export type ExcludeFromUpdate = {
+    createdAt?: true;
+    updatedAt?: true;
+    deletedAt?: true;
+    createdBy?: true;
+    _id?: true;
+} & Record<string, true>;
+export declare class SchemaBuilder<T extends z.ZodRawShape> {
+    private includeTimestamps;
+    private includeTracking;
+    private baseSchema;
+    constructor(baseFields: T, includeTimestamps?: boolean, includeTracking?: boolean);
+    private createBaseSchema;
+    getBaseSchema(): z.ZodObject<T, "strict", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any>[k]; } : never, z.baseObjectInputType<T> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<T>[k_1]; } : never>;
+    getEntitySchema(): z.ZodObject<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }> extends infer T_1 extends z.ZodRawShape ? { [k in keyof T_1]: z.ZodOptional<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }>[k]>; } : never, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }> extends infer T_2 extends z.ZodRawShape ? { [k in keyof T_2]: z.ZodOptional<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }>[k]>; } : never, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }> extends infer T_3 extends z.ZodRawShape ? { [k in keyof T_3]: z.ZodOptional<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }>[k]>; } : never, z.ZodTypeAny, "passthrough">>;
+    getIdSchema(): z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    getUpdateSchema(excludeFields?: ExcludeFromUpdate): z.ZodObject<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }> extends infer T_1 extends z.ZodRawShape ? { [k in keyof T_1]: z.ZodOptional<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }>[k]>; } : never, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }> extends infer T_2 extends z.ZodRawShape ? { [k in keyof T_2]: z.ZodOptional<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }>[k]>; } : never, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }> extends infer T_3 extends z.ZodRawShape ? { [k in keyof T_3]: z.ZodOptional<z.objectUtil.extendShape<T, {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+    }>[k]>; } : never, z.ZodTypeAny, "passthrough">> | z.ZodObject<{
+        [x: string]: z.ZodOptional<z.ZodTypeAny>;
+    }, "strict", z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }>;
+    getDeleteSchema(): z.ZodObject<{
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        softDelete: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        _id: mongoose.Types.ObjectId;
+        softDelete: boolean;
+    }, {
+        _id: string | mongoose.Types.ObjectId;
+        softDelete?: boolean | undefined;
+    }>;
+    updateBaseSchema(extendFields?: z.ZodRawShape, omitFields?: string[]): z.ZodObject<any, z.UnknownKeysParam, z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }>;
+    getAllSchemas(excludeFromUpdate?: ExcludeFromUpdate): {
+        BaseSchema: z.ZodObject<T, "strict", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any>[k]; } : never, z.baseObjectInputType<T> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<T>[k_1]; } : never>;
+        EntitySchema: z.ZodObject<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }> extends infer T_3 extends z.ZodRawShape ? { [k_2 in keyof T_3]: z.ZodOptional<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }>[k_2]>; } : never, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }> extends infer T_4 extends z.ZodRawShape ? { [k_2 in keyof T_4]: z.ZodOptional<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }>[k_2]>; } : never, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }> extends infer T_5 extends z.ZodRawShape ? { [k_2 in keyof T_5]: z.ZodOptional<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }>[k_2]>; } : never, z.ZodTypeAny, "passthrough">>;
+        IdSchema: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        UpdateSchema: z.ZodObject<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }> extends infer T_6 extends z.ZodRawShape ? { [k_2 in keyof T_6]: z.ZodOptional<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }>[k_2]>; } : never, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }> extends infer T_7 extends z.ZodRawShape ? { [k_2 in keyof T_7]: z.ZodOptional<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }>[k_2]>; } : never, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }> extends infer T_8 extends z.ZodRawShape ? { [k_2 in keyof T_8]: z.ZodOptional<z.objectUtil.extendShape<T, {
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+        }>[k_2]>; } : never, z.ZodTypeAny, "passthrough">> | z.ZodObject<{
+            [x: string]: z.ZodOptional<z.ZodTypeAny>;
+        }, "strict", z.ZodTypeAny, {
+            [x: string]: any;
+        }, {
+            [x: string]: any;
+        }>;
+        DeleteSchema: z.ZodObject<{
+            _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mongoose.Types.ObjectId, string>, z.ZodType<mongoose.Types.ObjectId, z.ZodTypeDef, mongoose.Types.ObjectId>]>;
+            softDelete: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            _id: mongoose.Types.ObjectId;
+            softDelete: boolean;
+        }, {
+            _id: string | mongoose.Types.ObjectId;
+            softDelete?: boolean | undefined;
+        }>;
+    };
+}
+export type DTO<T extends z.ZodType> = z.infer<T>;
+export type PaginatedResponse<T> = {
+    metadata: {
+        page: number;
+        size: number;
+        totalElements: number;
+        totalPages: number;
+    };
+    documents: T[];
+};
+export declare function createSchemaBuilder<T extends z.ZodRawShape>(baseFields: T, includeTimestamps?: boolean, includeTracking?: boolean): SchemaBuilder<T>;
+//# sourceMappingURL=global-validation.d.ts.map

package/utilities/validation/global-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-validation.d.ts","sourceRoot":"/","sources":["utilities/validation/global-validation.ts"],"names":[],"mappings":"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"}

package/utilities/validation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common-validation';
+export * from './global-validation';
+//# sourceMappingURL=index.d.ts.map

package/utilities/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"/","sources":["utilities/validation/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}

package/dist/core/README.md

@@ -1 +0,0 @@
-# lyxa-core

package/dist/core/index.d.ts

@@ -1,8 +0,0 @@
-import { LibraryManager } from './libraries';
-import { ConfigurationOptions } from './libraries/configuration';
-export { ConfigurationOptions } from './libraries/configuration';
-export { EnvironmentConfigurationType } from './libraries/configuration/types/EnvironmentConfigurationType';
-export { initGlobalConnection } from './libraries/mongo';
-export declare function bootstrapCore(options?: ConfigurationOptions): Promise<void>;
-export declare function registerLibraries(options?: ConfigurationOptions): Promise<void>;
-export declare function getLibraries(): LibraryManager;

package/dist/core/libraries/auth/index.d.ts

@@ -1,79 +0,0 @@
-import { SignOptions } from 'jsonwebtoken';
-import { EntityContext } from '../trpc/context';
-import { RefreshToken } from './refreshtoken';
-import { ReturnModelType } from '@typegoose/typegoose';
-export declare enum AuthEntityType {
-    USER = "USER",
-    SELLER = "SELLER",
-    DELIVERY_BOY = "DELIVERY_BOY",
-    CRM = "CRM"
-}
-export declare enum TokenType {
-    ACCESS = "ACCESS",
-    REFRESH = "REFRESH"
-}
-export interface RefreshTokenRecord {
-    token: string;
-    entityId: string;
-    entityType: AuthEntityType;
-    expiresAt: Date;
-    isRevoked: boolean;
-    metadata?: Record<string, unknown>;
-}
-export declare function getRefreshTokenModel(): ReturnModelType<typeof RefreshToken>;
-export declare function initializeRefreshTokenModel(globalConnection: any): void;
-export declare function signAccessToken(entity: {
-    id: string;
-    type: AuthEntityType;
-    parameters: Record<string, unknown>;
-}, options?: SignOptions): Promise<string>;
-export declare function generateRefreshToken(entity: {
-    id: string;
-    type: AuthEntityType;
-    parameters?: Record<string, unknown>;
-}, options?: {
-    expiresIn?: string | number;
-}): Promise<string>;
-export declare function verifyAccessToken(entityTypes: AuthEntityType[], token: string): Promise<EntityContext | undefined>;
-export declare function validateRefreshToken(token: string): Promise<{
-    valid: boolean;
-    entity?: {
-        id: string;
-        type: AuthEntityType;
-        parameters?: Record<string, unknown>;
-    };
-}>;
-export declare function refreshTokens(refreshToken: string): Promise<{
-    accessToken: string;
-    refreshToken: string;
-    entity: {
-        id: string;
-        type: AuthEntityType;
-    };
-} | null>;
-export declare function revokeRefreshToken(token: string): Promise<boolean>;
-export declare function revokeAllRefreshTokens(entityId: string, entityType: AuthEntityType): Promise<boolean>;
-export declare function signTokenPair(entity: {
-    id: string;
-    type: AuthEntityType;
-    parameters?: Record<string, unknown>;
-}, options?: {
-    accessTokenOptions?: SignOptions;
-    refreshTokenExpiresIn?: string | number;
-}): Promise<{
-    accessToken: string;
-    refreshToken: string;
-}>;
-export declare function handleTokenRenewal(refreshToken: string): Promise<{
-    success: boolean;
-    entity?: {
-        id: string;
-        type: AuthEntityType;
-        parameters: Record<string, unknown>;
-    };
-    tokenStatus: 'valid' | 'expired' | 'revoked' | 'invalid';
-    newTokens?: {
-        accessToken: string;
-        refreshToken?: string | null;
-    };
-}>;

package/dist/core/libraries/auth/refreshtoken.d.ts

@@ -1,15 +0,0 @@
-import { DocumentType, ReturnModelType } from '@typegoose/typegoose';
-import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
-import { AuthEntityType } from './index';
-export declare class RefreshToken extends TimeStamps {
-    token: string;
-    entityId: string;
-    entityType: AuthEntityType;
-    expiresAt?: Date | null;
-    isRevoked: boolean;
-    metadata?: Record<string, unknown>;
-    static findValidToken(this: ReturnModelType<typeof RefreshToken>, token: string): Promise<DocumentType<RefreshToken> | null>;
-    static revokeAllForEntity(this: ReturnModelType<typeof RefreshToken>, entityId: string, entityType: AuthEntityType): Promise<number>;
-    isExpired(): boolean;
-    static cleanupExpiredTokens(this: ReturnModelType<typeof RefreshToken>, olderThan?: Date): Promise<number>;
-}

package/dist/core/libraries/auth/repository.d.ts

@@ -1,18 +0,0 @@
-import { AuthEntityType } from './index';
-import { DocumentType } from '@typegoose/typegoose';
-import { RefreshToken } from './refreshtoken';
-export declare class TokenRepository {
-    saveRefreshToken(token: {
-        token: string;
-        entityId: string;
-        entityType: AuthEntityType;
-        expiresAt?: Date | null;
-        isRevoked?: boolean;
-        metadata?: Record<string, unknown>;
-    }): Promise<DocumentType<RefreshToken>>;
-    findRefreshToken(token: string): Promise<DocumentType<RefreshToken> | null>;
-    revokeRefreshToken(token: string): Promise<boolean>;
-    revokeAllRefreshTokensForEntity(entityId: string, entityType: AuthEntityType): Promise<boolean>;
-    getActiveTokensForEntity(entityId: string, entityType: AuthEntityType): Promise<DocumentType<RefreshToken>[]>;
-    cleanupExpiredTokens(olderThan?: Date): Promise<number>;
-}

package/dist/core/libraries/bullmq/bull-mq-service.d.ts

@@ -1,9 +0,0 @@
-import { Queue, Worker, Job, WorkerOptions } from 'bullmq';
-import { RedisService } from '../redis/index';
-export declare class BullMQService {
-    private redisService;
-    private connection;
-    constructor(redisService: RedisService);
-    createQueue(queueName: string): Queue;
-    createWorker<T>(queueName: string, processor: (job: Job<T>) => Promise<void>, options?: WorkerOptions): Worker;
-}

package/dist/core/libraries/cache/settings/index.d.ts

@@ -1,7 +0,0 @@
-import { RedisService } from '../../redis';
-export declare class CachedSettingsService {
-    private readonly redisService;
-    constructor(redisService: RedisService);
-    getSettings(): Promise<any>;
-    updateSettings(): Promise<string>;
-}

package/dist/core/libraries/configuration/index.d.ts

@@ -1,32 +0,0 @@
-import { ServiceAccount } from 'firebase-admin';
-import { EnvironmentConfigurationType } from './types/EnvironmentConfigurationType';
-export interface ConfigurationOptions {
-    tenet?: string;
-    redisURL?: string;
-    instanceType?: string;
-    firebaseAdmin?: {
-        super: {
-            firebaseAdminServiceAccount: ServiceAccount;
-            firebaseAdminAppName?: string;
-        };
-        user: {
-            firebaseAdminServiceAccount: ServiceAccount;
-            firebaseAdminAppName?: string;
-        };
-        shop: {
-            firebaseAdminServiceAccount: ServiceAccount;
-            firebaseAdminAppName?: string;
-        };
-        rider: {
-            firebaseAdminServiceAccount: ServiceAccount;
-            firebaseAdminAppName?: string;
-        };
-    };
-    environment: EnvironmentConfigurationType;
-}
-export declare class ConfigurationService {
-    private readonly _defaultOptions;
-    private readonly _options;
-    constructor(options?: ConfigurationOptions);
-    get options(): ConfigurationOptions;
-}

package/dist/core/libraries/configuration/types/EnvironmentConfigurationType.d.ts

@@ -1,7 +0,0 @@
-export declare enum EnvironmentConfigurationType {
-    LOCAL = "LOCAL",
-    MOCK = "MOCK",
-    DEV = "DEV",
-    PREPROD = "PREPROD",
-    PROD = "PROD"
-}

package/dist/core/libraries/dispatcher/index.d.ts

@@ -1,9 +0,0 @@
-import { AnyRouter } from '@trpc/server';
-import { SecretManagerService } from '../secrets';
-export declare class MicroServiceDispatcher {
-    private _secretService;
-    constructor(secretService: SecretManagerService);
-    getMicroService<T extends AnyRouter>(serviceName: string, customURL?: string, options?: {
-        headers?: Record<string, string>;
-    }): Promise<import("@trpc/client").CreateTRPCProxyClient<T>>;
-}

package/dist/core/libraries/event/BaseEvent.d.ts

@@ -1,7 +0,0 @@
-export declare abstract class BaseEvent<TPayload extends Record<string, unknown>> {
-    private readonly _eventId;
-    private readonly _payload;
-    protected constructor(eventId: string, payload: TPayload);
-    get eventId(): string;
-    get payload(): TPayload;
-}

package/dist/core/libraries/event/EventEnums.d.ts

@@ -1,3 +0,0 @@
-export declare enum PublishEventEnums {
-    ADMIN_ACTIVITY_LOGS_EVENT = "admin_activity_logs_event"
-}

package/dist/core/libraries/event/decorators/metadata.d.ts

@@ -1,13 +0,0 @@
-import { BaseEvent } from '../BaseEvent';
-export interface EventParameter {
-    name: string;
-    type: string;
-}
-export declare class EventRegistry {
-    private static eventsMetadata;
-    static registerMetadata(eventId: string, metadata: EventParameter[]): void;
-    static getMetadata(eventId: string): EventParameter[] | undefined;
-}
-export declare function EventMetadata(eventId: string, parameters?: EventParameter[]): <T extends {
-    new (...args: any[]): BaseEvent<any>;
-}>(constructor: T) => void;

package/dist/core/libraries/event/decorators/subscribe.d.ts

@@ -1 +0,0 @@
-export declare function Subscribe(eventId: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/core/libraries/event/events/admin-logs-event.d.ts

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-import { BaseEvent } from '../BaseEvent';
-import { AdminLogsUpdatedFieldsType } from '../../../utilities/enum';
-import { DTO } from '../../../utilities/validation/global-validation';
-declare const ActivityLogValidationSchema: z.ZodObject<{
-    admin: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
-    updatedField: z.ZodNativeEnum<typeof AdminLogsUpdatedFieldsType>;
-    oldDocument: z.ZodAny;
-    newDocument: z.ZodAny;
-}, "strict", z.ZodTypeAny, {
-    admin: import("mongoose").Types.ObjectId;
-    updatedField: AdminLogsUpdatedFieldsType;
-    oldDocument?: any;
-    newDocument?: any;
-}, {
-    admin: string | import("mongoose").Types.ObjectId;
-    updatedField: AdminLogsUpdatedFieldsType;
-    oldDocument?: any;
-    newDocument?: any;
-}>;
-type CreateActivityLogDTO = DTO<typeof ActivityLogValidationSchema>;
-export declare class AdminActivityLogsEvent extends BaseEvent<Record<string, unknown>> {
-    constructor(payload: CreateActivityLogDTO);
-}
-export {};

package/dist/core/libraries/event/index.d.ts

@@ -1,4 +0,0 @@
-import { BaseEvent } from './BaseEvent';
-export declare function initEventBus(rabbitMqUrl?: string): Promise<void>;
-export declare function publishEvent<TPayload extends Record<string, unknown>>(event: BaseEvent<TPayload>): Promise<void>;
-export declare function subscribeToEvent(eventId: string, onMessage: (payload: any) => Promise<void>): Promise<void>;

package/dist/core/libraries/event/registry/SubscriptionRegistry.d.ts

@@ -1,11 +0,0 @@
-interface SubscriptionMetadata {
-    eventId: string;
-    targetConstructor: Function;
-    methodName: string;
-}
-export declare class SubscriptionRegistry {
-    private static subscriptions;
-    static register(eventId: string, targetConstructor: Function, methodName: string): void;
-    static getAllSubscriptions(): SubscriptionMetadata[];
-}
-export {};

package/dist/core/libraries/event/test/OrderCreationEvent.d.ts

@@ -1,11 +0,0 @@
-import { BaseEvent } from '../BaseEvent';
-export type OrderCreationEventParams = {
-    user: string;
-    shop: string;
-};
-export declare class OrderCreationEvent extends BaseEvent<OrderCreationEventParams> {
-    constructor(parameters: OrderCreationEventParams);
-}
-export declare class OrderListenEvent {
-    doSomethingWithOrderCreation(parameters: Record<string, unknown>): void;
-}

package/dist/core/libraries/firebase/fcmService.d.ts

@@ -1,14 +0,0 @@
-import { App } from 'firebase-admin/app';
-export interface FCMNotificationPayload {
-    title: string;
-    body: string;
-    data?: Record<string, string>;
-}
-export declare class FCMService {
-    private messaging;
-    constructor(app?: App);
-    sendNotification(payload: FCMNotificationPayload, tokens: string[]): Promise<{
-        successTokens: string[];
-        failedTokens: string[];
-    }>;
-}

package/dist/core/libraries/firebase/index.d.ts

@@ -1,14 +0,0 @@
-import * as admin from 'firebase-admin';
-import { ConfigurationService } from '../configuration';
-export declare class FirebaseService {
-    private configService;
-    private readonly _superApp;
-    private readonly _userApp;
-    private readonly _shopApp;
-    private readonly _riderApp;
-    constructor(configService: ConfigurationService);
-    get superApp(): admin.app.App;
-    get userApp(): admin.app.App;
-    get shopApp(): admin.app.App;
-    get riderApp(): admin.app.App;
-}

package/dist/core/libraries/index.d.ts

@@ -1,29 +0,0 @@
-import { TwilioService } from './twilio';
-import { LyxaLogger } from './logger';
-import { MicroServiceDispatcher } from './dispatcher';
-import { SecretManagerService } from './secrets';
-import { RedisService } from './redis';
-import { ConfigurationService } from './configuration';
-import { UploadService } from './upload';
-import { FirebaseService } from './firebase';
-import { TokenRepository } from './auth/repository';
-import { MapService } from './map';
-import { CachedSettingsService } from './cache/settings';
-import { FCMService } from './firebase/fcmService';
-import { BullMQService } from './bullmq/bull-mq-service';
-export declare class LibraryManager {
-    getLogger(): LyxaLogger;
-    getMicroServiceDispatcher(): MicroServiceDispatcher;
-    getTwilioService(): TwilioService;
-    getSecretsService(): SecretManagerService;
-    getRedisService(): RedisService;
-    getConfigurationService(): ConfigurationService;
-    getFirebaseService(): FirebaseService;
-    getAuthTokenRepository(): TokenRepository;
-    getGlobalUploadService(): UploadService;
-    getTenetUploadService(): UploadService;
-    getMapService(): MapService;
-    getCachedSettingsService(): CachedSettingsService;
-    getFCMService(): FCMService;
-    getBullMQService(): BullMQService;
-}

package/dist/core/libraries/logger/index.d.ts

@@ -1,8 +0,0 @@
-import { Logger } from 'pino';
-export declare class LyxaLogger {
-    private readonly _logger;
-    private readonly logDirectory;
-    constructor(identifier: string, mongoURI: string);
-    private ensureLogDirectoryExists;
-    get logger(): Logger;
-}

package/dist/core/libraries/map/index.d.ts

@@ -1,2 +0,0 @@
-export * from './mapService';
-export * from './providers';

package/dist/core/libraries/map/interfaces/IMapService.d.ts

@@ -1,31 +0,0 @@
-export interface ICoordinate {
-    longitude: number;
-    latitude: number;
-}
-export interface IDistance {
-    value: number;
-    text: string;
-}
-export interface IDuration {
-    value: number;
-    text: string;
-}
-export interface ILeg {
-    distance: IDistance;
-    duration: IDuration;
-    overviewPolyline: Array<[number, number]>;
-}
-export interface IDistanceInfo {
-    distance: IDistance;
-    duration: IDuration;
-}
-export interface IWaypointDistanceInfo {
-    distance: IDistance;
-    duration: IDuration;
-    legs: Array<ILeg>;
-    overviewPolyline: Array<[number, number]>;
-}
-export interface IMapService {
-    getDistanceInfo(origin: ICoordinate, destination: ICoordinate): Promise<IDistanceInfo>;
-    getWaypointsDistanceInfo(origin: ICoordinate, destination: ICoordinate, waypoints: Array<ICoordinate>): Promise<IWaypointDistanceInfo>;
-}

package/dist/core/libraries/map/mapService.d.ts

@@ -1,8 +0,0 @@
-import { IMapService, ICoordinate, IDistanceInfo, IWaypointDistanceInfo } from './interfaces/IMapService';
-export declare class MapService {
-    private service;
-    constructor(service: IMapService);
-    calculateDistanceBetweenCoordinates(coord1: [number, number], coord2: [number, number]): number;
-    getDistanceInfo(origin: ICoordinate, destination: ICoordinate): Promise<IDistanceInfo>;
-    getWaypointsDistanceInfo(origin: ICoordinate, destination: ICoordinate, waypoints: Array<ICoordinate>): Promise<IWaypointDistanceInfo>;
-}

package/dist/core/libraries/map/providers/google-maps.d.ts

@@ -1,7 +0,0 @@
-import { IMapService, ICoordinate, IDistanceInfo, IWaypointDistanceInfo } from '../interfaces/IMapService';
-export declare class GoogleMapsService implements IMapService {
-    private _apiKey;
-    constructor(apiKey: string);
-    getDistanceInfo(origin: ICoordinate, destination: ICoordinate): Promise<IDistanceInfo>;
-    getWaypointsDistanceInfo(origin: ICoordinate, destination: ICoordinate, waypoints: Array<ICoordinate>): Promise<IWaypointDistanceInfo>;
-}

package/dist/core/libraries/map/providers/index.d.ts

@@ -1 +0,0 @@
-export * from './google-maps';

package/dist/core/libraries/mongo/index.d.ts

@@ -1,4 +0,0 @@
-import { Connection } from 'mongoose';
-export declare function initGlobalConnection(uri: string, environment: string): Promise<Connection>;
-export declare function isGlobalConnectionInitialized(): boolean;
-export declare function getGlobalConnection(): Connection;

package/dist/core/libraries/mongo/models/activity-log.model.d.ts

@@ -1,10 +0,0 @@
-import { Ref } from '@typegoose/typegoose';
-import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
-import { Admin } from './admin.model';
-import { AdminLogsUpdatedFieldsType } from '../../../utilities/enum';
-export declare class ActivityLog extends TimeStamps {
-    admin: Ref<Admin>;
-    updatedField: AdminLogsUpdatedFieldsType;
-    oldDocument: any;
-    newDocument: any;
-}