@lyxa.ai/core 1.0.145-debug → 1.0.145-debug.4

package/dist/core/README.md

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

package/dist/core/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@lyxa.ai/core",
+  "version": "1.0.145-debug.4",
+  "description": "The Core system of the Lyxa services.",
+  "author": "elie <42282499+Internalizable@users.noreply.github.com>",
+  "license": "MIT",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "**/*"
+  ],
+  "keywords": [
+    "lyxa",
+    "core",
+    "backend",
+    "typescript"
+  ],
+  "dependencies": {
+    "@google-cloud/secret-manager": "^5.6.0",
+    "@mapbox/polyline": "^1.2.1",
+    "@trpc/client": "^10.45.2",
+    "@trpc/server": "^10.45.2",
+    "@typegoose/typegoose": "^12.10.1",
+    "@types/amqplib": "^0.10.7",
+    "@types/node": "^22.10.2",
+    "@types/twilio": "^3.19.3",
+    "amqplib": "^0.10.5",
+    "bcryptjs": "^3.0.2",
+    "bullmq": "^5.56.0",
+    "dayjs": "^1.11.13",
+    "firebase": "^11.1.0",
+    "firebase-admin": "^13.0.1",
+    "ioredis": "^5.4.1",
+    "jsonwebtoken": "^9.0.2",
+    "libphonenumber-js": "^1.12.8",
+    "mime-types": "^3.0.1",
+    "moment": "^2.30.1",
+    "mongoose": "^8.13.0",
+    "nanoid": "^5.1.5",
+    "pino": "^9.5.0",
+    "pino-mongodb": "^4.3.0",
+    "pino-pretty": "^13.0.0",
+    "sharp": "^0.33.5",
+    "slugify": "^1.6.6",
+    "twilio": "^5.4.0",
+    "typedi": "^0.10.0",
+    "typescript": "^5.7.2",
+    "zod": "^3.24.1",
+    "@lyxa.ai/types": "^1.0.145-debug.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+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/libraries/auth/index.d.ts

@@ -0,0 +1,79 @@
+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/libraries/auth/refreshtoken.d.ts

@@ -0,0 +1,15 @@
+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/libraries/auth/repository.d.ts

@@ -0,0 +1,18 @@
+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/libraries/bullmq/bull-mq-service.d.ts

@@ -0,0 +1,9 @@
+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/libraries/cache/settings/index.d.ts

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

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

@@ -0,0 +1,32 @@
+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/libraries/configuration/types/EnvironmentConfigurationType.d.ts

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

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

@@ -0,0 +1,9 @@
+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/libraries/event/BaseEvent.d.ts

@@ -0,0 +1,7 @@
+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/libraries/event/EventEnums.d.ts

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

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

@@ -0,0 +1,13 @@
+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/libraries/event/decorators/subscribe.d.ts

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

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

@@ -0,0 +1,25 @@
+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/libraries/event/index.d.ts

@@ -0,0 +1,4 @@
+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/libraries/event/registry/SubscriptionRegistry.d.ts

@@ -0,0 +1,11 @@
+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/libraries/event/test/OrderCreationEvent.d.ts

@@ -0,0 +1,11 @@
+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/libraries/firebase/fcmService.d.ts

@@ -0,0 +1,14 @@
+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/libraries/firebase/index.d.ts

@@ -0,0 +1,14 @@
+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/libraries/index.d.ts

@@ -0,0 +1,29 @@
+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/libraries/logger/index.d.ts

@@ -0,0 +1,8 @@
+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/libraries/map/index.d.ts

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

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

@@ -0,0 +1,31 @@
+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/libraries/map/mapService.d.ts

@@ -0,0 +1,8 @@
+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/libraries/map/providers/google-maps.d.ts

@@ -0,0 +1,7 @@
+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/libraries/map/providers/index.d.ts

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

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

@@ -0,0 +1,4 @@
+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/libraries/mongo/models/activity-log.model.d.ts

@@ -0,0 +1,10 @@
+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;
+}

package/dist/libraries/mongo/models/admin-access-control.model.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { AdminRole, ShopOnlineStatus } from '../../../utilities/enum';
+import { Admin } from './admin.model';
+export declare class AdminAccessControl extends TimeStamps {
+    email: string;
+    password: string;
+    admin: Ref<Admin>;
+    role: AdminRole;
+    onlineStatus?: ShopOnlineStatus;
+}

package/dist/libraries/mongo/models/admin.model.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { AdminAccessControl } from './admin-access-control.model';
+export declare class Admin extends TimeStamps {
+    name: string;
+    profilePhoto?: string;
+    phoneNumber: string;
+    status?: string;
+    accessControl: Ref<AdminAccessControl>;
+}

package/dist/libraries/mongo/models/agent-performance.model.d.ts

@@ -0,0 +1,13 @@
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { Admin } from './admin.model';
+import { Ref } from '@typegoose/typegoose';
+export declare class AgentPerformance extends TimeStamps {
+    admin: Ref<Admin>;
+    totalTicketsOngoing: number;
+    totalTicketsResolved: number;
+    totalTicketsAccepted: number;
+    totalTicketsResolvedTime: number;
+    totalTicketsAcceptedTime: number;
+    totalScore: number;
+    lastCalculatedAt?: Date;
+}

package/dist/libraries/mongo/models/attribute.model.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { AttributeItem } from './embedded/attribute-item.model';
+import { Shop } from './shop.model';
+export declare class Attribute extends TimeStamps {
+    shop: Ref<Shop>;
+    name: string;
+    isMultiSelect?: boolean;
+    maxSelectableItems?: number;
+    isRequired?: boolean;
+    minRequiredItems?: number;
+    items: AttributeItem[];
+}

package/dist/libraries/mongo/models/banner.model.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { BannerClickType, BannerLinkType, BannerUserType, ItemType, Status } from '../../../utilities/enum';
+import { Shop } from './shop.model';
+import { Product } from './product.model';
+import { ListContainer } from './list-container.model';
+export declare class Banner extends TimeStamps {
+    title: string;
+    image: string;
+    itemType: ItemType;
+    status?: Status;
+    visibility?: BannerUserType;
+    isClickable?: boolean;
+    clickType?: BannerClickType;
+    linkType?: BannerLinkType;
+    link?: string;
+    shop?: Ref<Shop>;
+    product?: Ref<Product>;
+    listContainer?: Ref<ListContainer>;
+    sortingOrder?: number;
+}

package/dist/libraries/mongo/models/base/base-coupon.model.d.ts

@@ -0,0 +1,15 @@
+import { CouponExpirationReason, Status, ValueType } from '../../../../utilities/enum';
+import { Duration } from '../shared/duration.model';
+import { Coupon } from '../coupon.model';
+export declare class BaseCoupon extends Coupon {
+    valueType: ValueType;
+    value: number;
+    maxDiscountLimit?: number | null;
+    duration: Duration;
+    spendLimit?: number | null;
+    totalOrderLimit?: number | null;
+    minOrderValue?: number | null;
+    forNewUserOnly?: boolean;
+    status?: Status;
+    expirationReason?: CouponExpirationReason;
+}

package/dist/libraries/mongo/models/base/base-review.model.d.ts

@@ -0,0 +1,13 @@
+import { mongoose, Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { CoreUser } from '../core-user.model';
+import { Order } from '../order.model';
+export declare class BaseReview extends TimeStamps {
+    user: Ref<CoreUser>;
+    description: string;
+    rating: number;
+    order: Ref<Order>;
+    tags?: string[];
+    isVisible?: boolean;
+    deletedBy?: mongoose.Types.ObjectId;
+}

package/dist/libraries/mongo/models/bob-finance.model.d.ts

@@ -0,0 +1,28 @@
+import { Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { BobAccountType, BobModel, BobSettlementStatus, BobSettlementType, BobType, PaidCurrency } from '../../../utilities/enum';
+import { Admin } from './admin.model';
+import { Payout } from './payout.model';
+import { Rider } from './rider.model';
+import { Shop } from './shop.model';
+export declare class BOBFinance extends TimeStamps {
+    referenceId: string;
+    accountType: BobAccountType;
+    settlementType: BobSettlementType;
+    amount?: number;
+    secondaryAmount?: number;
+    status?: BobSettlementStatus;
+    admin?: Ref<Admin>;
+    shop?: Ref<Shop>;
+    rider?: Ref<Rider>;
+    payout?: Ref<Payout>;
+    bobModel?: BobModel;
+    bobType?: BobType;
+    referenceNumber?: string;
+    crmNumber?: string;
+    bobLocation?: string;
+    riderTips?: number;
+    secondaryRiderTips?: number;
+    paidCurrency?: PaidCurrency;
+    isRiderSeen?: boolean;
+}

package/dist/libraries/mongo/models/brand.model.d.ts

@@ -0,0 +1,5 @@
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+export declare class Brand extends TimeStamps {
+    name: string;
+    description?: string;
+}

package/dist/libraries/mongo/models/cancellation-reason.model.d.ts

@@ -0,0 +1,8 @@
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { SettingsReasonStatus, CancellationReasonTypeEnum } from '../../../utilities/enum';
+export declare class CancellationReason extends TimeStamps {
+    reason: string;
+    reasonType: CancellationReasonTypeEnum;
+    status: SettingsReasonStatus;
+    sortingOrder?: number;
+}