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

package/dist/libraries/mongo/models/shared/duration.model.d.ts

@@ -0,0 +1,4 @@
+export declare class Duration {
+    start: Date;
+    end?: Date;
+}

package/dist/libraries/mongo/models/shared/geo-location.model.d.ts

@@ -0,0 +1,5 @@
+import { GeoLocationType } from '../../../../utilities/enum';
+export declare class GeoLocation {
+    type?: GeoLocationType;
+    coordinates: number[];
+}

package/dist/libraries/mongo/models/shared/work-hour.model.d.ts

@@ -0,0 +1,19 @@
+import { HolidayWorkStatus, WeekDay, WorkStatus } from '../../../../utilities/enum';
+export declare class StartEndTime {
+    start: string;
+    end: string;
+}
+export declare class NormalHour {
+    day: WeekDay;
+    status: WorkStatus;
+    openingHours?: StartEndTime[];
+}
+export declare class HolidayHour {
+    date?: Date;
+    status: HolidayWorkStatus;
+    closingHour?: StartEndTime;
+}
+export declare class WorkHourSetting {
+    normalHours?: NormalHour[];
+    holidayHours?: HolidayHour[];
+}

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

@@ -0,0 +1,13 @@
+import { Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { ShopRole } from '../../../utilities/enum';
+import { Parent } from './parent.model';
+import { Shop } from './shop.model';
+export declare class ShopAccessControl extends TimeStamps {
+    name: string;
+    email: string;
+    password: string;
+    parent?: Ref<Parent>;
+    shops?: Ref<Shop>[];
+    role: ShopRole;
+}

package/dist/libraries/mongo/models/shop-category.model.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { Status } from '../../../utilities/enum';
+import { Category } from './category.model';
+import { Shop } from './shop.model';
+export declare class ShopCategory extends TimeStamps {
+    shop: Ref<Shop>;
+    category: Ref<Category>;
+    status: Status;
+    note?: string;
+    sortingOrder?: number;
+}

package/dist/libraries/mongo/models/shop-meal-plan.model.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { Dish } from './dish.model';
+import { Package } from './embedded/package.model';
+import { MealPlan } from './meal-plan.model';
+import { Shop } from './shop.model';
+export declare class ShopMealPlan extends TimeStamps {
+    mealPlan: Ref<MealPlan>;
+    shop: Ref<Shop>;
+    dishes?: Ref<Dish>[];
+    packages?: Package[];
+}

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

@@ -0,0 +1,8 @@
+import { Ref } from '@typegoose/typegoose';
+import { BaseReview } from './base/base-review.model';
+import { Shop } from './shop.model';
+import { Parent } from './parent.model';
+export declare class ShopReview extends BaseReview {
+    shop: Ref<Shop>;
+    parent: Ref<Parent>;
+}

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

@@ -0,0 +1,56 @@
+import { Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { ItemType, ShopOnlineStatus, Status } from '../../../utilities/enum';
+import { Brand } from './brand.model';
+import { ShopDocument } from './embedded/shop-document.model';
+import { Parent } from './parent.model';
+import { Address } from './shared/address.model';
+import { StartEndTime, WorkHourSetting } from './shared/work-hour.model';
+import { Tag } from './tag.model';
+import { Zone } from './zone.model';
+import { DeliveryInfo } from './embedded/delivery-info.model';
+export declare class Shop extends TimeStamps {
+    name: string;
+    ownerName: string;
+    email: string;
+    slug?: string;
+    parent: Ref<Parent>;
+    itemType: ItemType;
+    status: Status;
+    brand: Ref<Brand>;
+    priceRange?: number;
+    phoneNumber: string;
+    userPhoneNumber: string;
+    additionalPhoneNumbers?: string[];
+    address: Address;
+    zone: Ref<Zone>;
+    logo?: string;
+    banner?: string;
+    document?: ShopDocument;
+    onlineStatus?: ShopOnlineStatus;
+    workHourSetting?: WorkHourSetting;
+    dietaries?: string[];
+    tags?: Ref<Tag>[];
+    isBeirutAuthentic: boolean;
+    isVisibleToUser: boolean;
+    isShopDelivery?: boolean;
+    deliveryFee?: number;
+    minimumOrderAmount?: number;
+    orderCapacity?: number;
+    shopActiveTimingsOfCurrentDate?: StartEndTime[];
+    deliveryInfo?: DeliveryInfo;
+    sortingOrder?: number;
+    allowSpecialInstructions?: boolean;
+    isRiderNoteVisible?: boolean;
+    riderNote?: string;
+    defaultPreparationTime?: number;
+    exchangeRate?: number;
+    isFavouriteCategoryVisible?: boolean;
+    favouriteCategoryTitle?: string;
+    isBestSellerCategoryVisible?: boolean;
+    bestSellerCategoryTitle?: string;
+    orderCapacityEnabled: boolean;
+    avgRating?: number;
+    ordersCount?: number;
+    customersCount?: number;
+}

package/dist/libraries/mongo/models/subscription-setting.model.d.ts

@@ -0,0 +1,7 @@
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { Status, SubscriptionPackage } from '../../../utilities/enum';
+export declare class SubscriptionSetting extends TimeStamps {
+    package: SubscriptionPackage;
+    amount: number;
+    status?: Status;
+}

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

@@ -0,0 +1,22 @@
+import { Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { PaidCurrency, PaymentMethod, PaymentStatus, SubscriptionPackage, SubscriptionStatus } from '../../../utilities/enum';
+import { CoreUser } from './core-user.model';
+import { SubscriptionSummary } from './embedded/subscription-summary.model';
+import { Duration } from './shared/duration.model';
+import { Transaction } from './transaction.model';
+export declare class Subscription extends TimeStamps {
+    user: Ref<CoreUser>;
+    package?: SubscriptionPackage;
+    fee: number;
+    secondaryFee: number;
+    summary?: SubscriptionSummary;
+    duration: Duration;
+    status?: SubscriptionStatus;
+    autoRenew?: boolean;
+    cancelReason?: string;
+    paymentMethod: PaymentMethod;
+    paymentStatus?: PaymentStatus;
+    transactions?: Ref<Transaction>[];
+    paidCurrency?: PaidCurrency;
+}

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

@@ -0,0 +1,9 @@
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { SettingsReasonStatus, SupportReasonTypeEnum } from '../../../utilities/enum';
+import { SupportReasonInfo } from './embedded/support-reason-info.model';
+export declare class SupportReason extends TimeStamps {
+    reason: SupportReasonInfo;
+    reasonType: SupportReasonTypeEnum;
+    status: SettingsReasonStatus;
+    sortingOrder?: number;
+}

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

@@ -0,0 +1,9 @@
+import { ItemType, Status } from '../../../utilities/enum';
+export declare class Tag {
+    name: string;
+    image: string;
+    itemType: ItemType;
+    status?: Status;
+    isVisible?: boolean;
+    sortingOrder?: number;
+}

package/dist/libraries/mongo/models/terms-and-conditions.model.d.ts

@@ -0,0 +1,8 @@
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+export declare class TermsAndConditions extends TimeStamps {
+    privacyMessage: string;
+    userTermsAndConditions: string;
+    shopTermsAndConditions: string;
+    riderTermsAndConditions: string;
+    lyxaPlusTermsAndConditions: string;
+}

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

@@ -0,0 +1,25 @@
+import { Ref } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { User } from './user.model';
+import { Shop } from './shop.model';
+import { Order } from './order.model';
+import { Admin } from './admin.model';
+import { TicketType, TicketStatus, UserRef } from '../../../utilities/enum';
+import { Chatroom } from './chat-room.model';
+export declare class Ticket extends TimeStamps {
+    ticketId: string;
+    type: TicketType;
+    status: TicketStatus;
+    client: Ref<User | Shop>;
+    clientType: UserRef;
+    order?: Ref<Order>;
+    assignedAgent?: Ref<Admin>;
+    assignedAt?: Date;
+    assignmentAttempts?: number;
+    chatroom: Ref<Chatroom>;
+    resolvedAt?: Date;
+    closedAt?: Date;
+    resolutionTimeMinutes?: number;
+    customerRating?: number;
+    agentScore?: number;
+}

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

@@ -0,0 +1,2 @@
+export declare class Transaction {
+}

package/dist/libraries/mongo/models/user-app-section-setting.model.d.ts

@@ -0,0 +1,9 @@
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { Status, UserAppSectionItemType, UserAppSectionType } from '../../../utilities/enum';
+export declare class UserAppSectionSetting extends TimeStamps {
+    itemType: UserAppSectionItemType;
+    section: UserAppSectionType;
+    alias: string;
+    status?: Status;
+    sortingOrder?: number;
+}

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

@@ -0,0 +1,37 @@
+import { mongoose, Ref, ReturnModelType } from '@typegoose/typegoose';
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { CoreUser } from './core-user.model';
+import { Product } from './product.model';
+import { Shop } from './shop.model';
+import { UserAddress } from './shared/address.model';
+import { Coupon } from './coupon.model';
+import { Subscription } from './subscription.model';
+import { OnlineStatus, Status } from '../../../utilities/enum';
+import { OTPFields } from './embedded/otp-fields.model';
+export declare class User extends TimeStamps {
+    coreUser: Ref<CoreUser>;
+    favoriteProducts?: Ref<Product>[];
+    favoriteShops?: Ref<Shop>[];
+    addresses?: UserAddress[];
+    status?: Status;
+    orderCompleted?: number;
+    repeatedOrderAt?: Date;
+    walletBalance?: number;
+    coupons?: Ref<Coupon>[];
+    newUserCouponDiscountType?: string;
+    newUserCouponValue?: number;
+    newUserCouponMaximumDiscountLimit?: number;
+    isNewUserCouponShowed?: boolean;
+    referralCode?: Ref<Coupon>;
+    subscription?: Ref<Subscription>;
+    isSubscribed?: boolean;
+    phoneNumber?: string;
+    phoneOtpInfo?: OTPFields;
+    isPhoneVerified?: boolean;
+    onlineStatus?: OnlineStatus;
+    static updateWallet(this: ReturnModelType<typeof User>, userId: string, amount: number): Promise<(mongoose.Document<unknown, import("@typegoose/typegoose/lib/types").BeAnObject, User, import("@typegoose/typegoose/lib/types").BeAnyObject> & Omit<User & {
+        _id: mongoose.Types.ObjectId;
+    } & {
+        __v: number;
+    }, "typegooseName"> & import("@typegoose/typegoose/lib/types").IObjectWithTypegooseFunction) | null>;
+}

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

@@ -0,0 +1,15 @@
+import { TimeStamps } from '@typegoose/typegoose/lib/defaultClasses';
+import { ZoneStatus } from '../../../utilities/enum';
+import { ZoneGeometry } from './embedded/zone-geometry.mode';
+export declare class Zone extends TimeStamps {
+    name: string;
+    area?: string;
+    geometry: ZoneGeometry;
+    status?: ZoneStatus;
+    busyTitle?: string;
+    busyDescription?: string;
+    riderWeeklyTarget?: number;
+    riderWeeklyReward?: number;
+    areaSqKm: number;
+    isIncludedReward?: boolean;
+}

package/dist/libraries/mongo/plugins/soft-delete-plugin.d.ts

@@ -0,0 +1,32 @@
+import { Schema, Model } from 'mongoose';
+import { ReturnModelType, mongoose } from '@typegoose/typegoose';
+import { AnyParamConstructor } from '@typegoose/typegoose/lib/types';
+import { GetByIdInputDTO, GetOneQueryDTO } from '../../../utilities/validation';
+export interface SoftDeleteModel<T> extends Model<T> {
+    softDelete(_id: mongoose.Types.ObjectId): Promise<any>;
+    softDeleteOne(filter: object): Promise<any>;
+    softDeleteMany(filter?: object): Promise<any>;
+    deleteRecord(filter: object, softDelete: boolean): Promise<any>;
+    deleteRecords(filter: object, softDelete: boolean): Promise<any>;
+    restore(_id: mongoose.Types.ObjectId): Promise<any>;
+    restoreOne(filter: object): Promise<any>;
+    restoreMany(filter?: object): Promise<any>;
+    findWithDeleted(filter?: object): any;
+    findDeleted(filter?: object): any;
+    findRecordById(data: GetByIdInputDTO): Promise<any>;
+    findOneRecord(data: GetOneQueryDTO): Promise<any>;
+}
+export declare class SoftDeleteBase {
+    deletedAt?: Date | null;
+}
+export declare class SoftDelete {
+    static applyToSchema(schema: Schema): void;
+    static applyGlobally(): void;
+    static createModel<T extends SoftDeleteBase>(modelClass: AnyParamConstructor<T>): SoftDeleteModel<T> & ReturnModelType<AnyParamConstructor<T>>;
+    private static addQueryMiddleware;
+    private static addInstanceMethods;
+    private static addStaticMethods;
+}
+export declare const softDeletePlugin: (schema: Schema) => void;
+export declare const applySoftDeletePlugin: () => void;
+export declare const createSoftDeleteModel: <T extends SoftDeleteBase>(modelClass: AnyParamConstructor<T>) => SoftDeleteModel<T> & ReturnModelType<AnyParamConstructor<T>>;

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

@@ -0,0 +1,13 @@
+import Redis from 'ioredis';
+export declare class RedisService {
+    private _redisClient;
+    constructor(redisURL: string);
+    get redisClient(): Redis;
+    getCachedObject<T>(key: string): Promise<T | undefined>;
+    cacheObject<T>(key: string, object: T, expiry?: number): Promise<boolean>;
+    deleteCachedObject(key: string): Promise<boolean>;
+    getCachedObjectByGroup<T>(group: string, key: string): Promise<T | undefined>;
+    setCachedObjectByGroup<T>(group: string, key: string, object: T): Promise<boolean>;
+    deleteCachedObjectByGroup<T>(group: string, key: string): Promise<boolean>;
+    sanitizeKey(key: string): string;
+}

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

@@ -0,0 +1,10 @@
+import { RedisService } from '../redis';
+import { ConfigurationService } from '../configuration';
+export declare class SecretManagerService {
+    private _configurationService;
+    private _redisManager;
+    private _client;
+    constructor(configurationService: ConfigurationService, redisManager: RedisService);
+    getKey(key: string): Promise<string | undefined>;
+    setKey(key: string, value: string): Promise<string>;
+}

package/dist/libraries/trpc/context.d.ts

@@ -0,0 +1,18 @@
+import { CreateHTTPContextOptions } from '@trpc/server/dist/adapters/standalone';
+import { AuthEntityType } from '../auth';
+import jwt from 'jsonwebtoken';
+import { TokenType } from '../auth';
+export interface EntityContext extends jwt.JwtPayload {
+    id: string;
+    type: AuthEntityType;
+    parameters: Record<string, unknown>;
+}
+export interface LyxaContextParams {
+    entity?: EntityContext;
+    requestId?: string;
+    tokenType?: TokenType;
+    usedRefreshToken?: boolean;
+    tokenRenewed?: boolean;
+}
+export declare const createLyxaContext: (opts: CreateHTTPContextOptions) => Promise<CreateHTTPContextOptions & LyxaContextParams>;
+export type LyxaContext = Awaited<ReturnType<typeof createLyxaContext>>;

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

@@ -0,0 +1,178 @@
+export declare const t: {
+    _config: import("@trpc/server").RootConfig<{
+        ctx: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("./context").LyxaContextParams;
+        meta: object;
+        errorShape: {
+            message: string;
+            data: {
+                stack: undefined;
+                path: undefined;
+                code: import("@trpc/server/rpc").TRPC_ERROR_CODE_KEY;
+                httpStatus: number;
+            };
+            stack: undefined;
+            code: import("@trpc/server/rpc").TRPC_ERROR_CODE_NUMBER;
+        };
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>;
+    procedure: import("@trpc/server").ProcedureBuilder<{
+        _config: import("@trpc/server").RootConfig<{
+            ctx: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("./context").LyxaContextParams;
+            meta: object;
+            errorShape: {
+                message: string;
+                data: {
+                    stack: undefined;
+                    path: undefined;
+                    code: import("@trpc/server/rpc").TRPC_ERROR_CODE_KEY;
+                    httpStatus: number;
+                };
+                stack: undefined;
+                code: import("@trpc/server/rpc").TRPC_ERROR_CODE_NUMBER;
+            };
+            transformer: import("@trpc/server").DefaultDataTransformer;
+        }>;
+        _ctx_out: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("./context").LyxaContextParams;
+        _input_in: typeof import("@trpc/server").unsetMarker;
+        _input_out: typeof import("@trpc/server").unsetMarker;
+        _output_in: typeof import("@trpc/server").unsetMarker;
+        _output_out: typeof import("@trpc/server").unsetMarker;
+        _meta: object;
+    }>;
+    middleware: <TNewParams extends import("@trpc/server").ProcedureParams<import("@trpc/server").AnyRootConfig, unknown, unknown, unknown, unknown, unknown, unknown>>(fn: import("@trpc/server").MiddlewareFunction<{
+        _config: import("@trpc/server").RootConfig<{
+            ctx: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("./context").LyxaContextParams;
+            meta: object;
+            errorShape: {
+                message: string;
+                data: {
+                    stack: undefined;
+                    path: undefined;
+                    code: import("@trpc/server/rpc").TRPC_ERROR_CODE_KEY;
+                    httpStatus: number;
+                };
+                stack: undefined;
+                code: import("@trpc/server/rpc").TRPC_ERROR_CODE_NUMBER;
+            };
+            transformer: import("@trpc/server").DefaultDataTransformer;
+        }>;
+        _ctx_out: {};
+        _input_out: typeof import("@trpc/server").unsetMarker;
+        _input_in: unknown;
+        _output_in: unknown;
+        _output_out: unknown;
+        _meta: object;
+    }, TNewParams>) => import("@trpc/server").MiddlewareBuilder<{
+        _config: import("@trpc/server").RootConfig<{
+            ctx: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("./context").LyxaContextParams;
+            meta: object;
+            errorShape: {
+                message: string;
+                data: {
+                    stack: undefined;
+                    path: undefined;
+                    code: import("@trpc/server/rpc").TRPC_ERROR_CODE_KEY;
+                    httpStatus: number;
+                };
+                stack: undefined;
+                code: import("@trpc/server/rpc").TRPC_ERROR_CODE_NUMBER;
+            };
+            transformer: import("@trpc/server").DefaultDataTransformer;
+        }>;
+        _ctx_out: {};
+        _input_out: typeof import("@trpc/server").unsetMarker;
+        _input_in: unknown;
+        _output_in: unknown;
+        _output_out: unknown;
+        _meta: object;
+    }, TNewParams>;
+    router: <TProcRouterRecord extends import("@trpc/server").ProcedureRouterRecord>(procedures: TProcRouterRecord) => import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+        ctx: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("./context").LyxaContextParams;
+        meta: object;
+        errorShape: {
+            message: string;
+            data: {
+                stack: undefined;
+                path: undefined;
+                code: import("@trpc/server/rpc").TRPC_ERROR_CODE_KEY;
+                httpStatus: number;
+            };
+            stack: undefined;
+            code: import("@trpc/server/rpc").TRPC_ERROR_CODE_NUMBER;
+        };
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>, TProcRouterRecord>;
+    mergeRouters: typeof import("@trpc/server").mergeRouters;
+    createCallerFactory: <TRouter extends import("@trpc/server").Router<import("@trpc/server").AnyRouterDef<import("@trpc/server").RootConfig<{
+        ctx: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("./context").LyxaContextParams;
+        meta: object;
+        errorShape: {
+            message: string;
+            data: {
+                stack: undefined;
+                path: undefined;
+                code: import("@trpc/server/rpc").TRPC_ERROR_CODE_KEY;
+                httpStatus: number;
+            };
+            stack: undefined;
+            code: import("@trpc/server/rpc").TRPC_ERROR_CODE_NUMBER;
+        };
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>, any>>>(router: TRouter) => import("@trpc/server").RouterCaller<TRouter["_def"]>;
+};
+export declare const publicProcedure: import("@trpc/server").ProcedureBuilder<{
+    _config: import("@trpc/server").RootConfig<{
+        ctx: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("./context").LyxaContextParams;
+        meta: object;
+        errorShape: {
+            message: string;
+            data: {
+                stack: undefined;
+                path: undefined;
+                code: import("@trpc/server/rpc").TRPC_ERROR_CODE_KEY;
+                httpStatus: number;
+            };
+            stack: undefined;
+            code: import("@trpc/server/rpc").TRPC_ERROR_CODE_NUMBER;
+        };
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>;
+    _ctx_out: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("./context").LyxaContextParams;
+    _input_in: typeof import("@trpc/server").unsetMarker;
+    _input_out: typeof import("@trpc/server").unsetMarker;
+    _output_in: typeof import("@trpc/server").unsetMarker;
+    _output_out: typeof import("@trpc/server").unsetMarker;
+    _meta: object;
+}>;
+export declare const createTRPCRouter: <TProcRouterRecord extends import("@trpc/server").ProcedureRouterRecord>(procedures: TProcRouterRecord) => import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+    ctx: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("./context").LyxaContextParams;
+    meta: object;
+    errorShape: {
+        message: string;
+        data: {
+            stack: undefined;
+            path: undefined;
+            code: import("@trpc/server/rpc").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+        };
+        stack: undefined;
+        code: import("@trpc/server/rpc").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: import("@trpc/server").DefaultDataTransformer;
+}>, TProcRouterRecord>;
+export declare const createCallerFactory: <TRouter extends import("@trpc/server").Router<import("@trpc/server").AnyRouterDef<import("@trpc/server").RootConfig<{
+    ctx: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("./context").LyxaContextParams;
+    meta: object;
+    errorShape: {
+        message: string;
+        data: {
+            stack: undefined;
+            path: undefined;
+            code: import("@trpc/server/rpc").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+        };
+        stack: undefined;
+        code: import("@trpc/server/rpc").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: import("@trpc/server").DefaultDataTransformer;
+}>, any>>>(router: TRouter) => import("@trpc/server").RouterCaller<TRouter["_def"]>;

package/dist/libraries/trpc/middlewares/auth.d.ts

@@ -0,0 +1,39 @@
+import { AuthEntityType, TokenType } from '../../auth';
+interface AuthOptions {
+    entityTypes: AuthEntityType[];
+    allowRefreshToken?: boolean;
+    autoRefresh?: boolean;
+}
+export declare function createAuthenticatedProcedure(options: AuthOptions): import("@trpc/server").ProcedureBuilder<{
+    _config: import("@trpc/server").RootConfig<{
+        ctx: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("../context").LyxaContextParams;
+        meta: object;
+        errorShape: {
+            message: string;
+            data: {
+                stack: undefined;
+                path: undefined;
+                code: import("@trpc/server/rpc").TRPC_ERROR_CODE_KEY;
+                httpStatus: number;
+            };
+            stack: undefined;
+            code: import("@trpc/server/rpc").TRPC_ERROR_CODE_NUMBER;
+        };
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>;
+    _meta: object;
+    _ctx_out: {
+        requestId: string | undefined;
+        res: import("http").ServerResponse<import("http").IncomingMessage>;
+        tokenType: TokenType | undefined;
+        entity: import("../context").EntityContext | undefined;
+        req: import("http").IncomingMessage;
+        usedRefreshToken: boolean | undefined;
+        tokenRenewed: boolean | undefined;
+    };
+    _input_in: typeof import("@trpc/server").unsetMarker;
+    _input_out: typeof import("@trpc/server").unsetMarker;
+    _output_in: typeof import("@trpc/server").unsetMarker;
+    _output_out: typeof import("@trpc/server").unsetMarker;
+}>;
+export {};

package/dist/libraries/trpc/middlewares/cors.d.ts

@@ -0,0 +1,12 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+interface CorsOptions {
+    origin?: string | string[];
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+    preflightContinue?: boolean;
+}
+export declare function corsMiddleware(options?: CorsOptions): (req: IncomingMessage, res: ServerResponse, next: () => void) => void;
+export {};

package/dist/libraries/trpc/middlewares/phone-verified.d.ts

@@ -0,0 +1,37 @@
+import { AuthEntityType } from '../../auth';
+interface PhoneVerifiedOptions {
+    entityTypes: AuthEntityType[];
+}
+export declare function createPhoneVerifiedProcedure(options: PhoneVerifiedOptions): import("@trpc/server").ProcedureBuilder<{
+    _config: import("@trpc/server").RootConfig<{
+        ctx: import("@trpc/server/dist/adapters/standalone").CreateHTTPContextOptions & import("../context").LyxaContextParams;
+        meta: object;
+        errorShape: {
+            message: string;
+            data: {
+                stack: undefined;
+                path: undefined;
+                code: import("@trpc/server/rpc").TRPC_ERROR_CODE_KEY;
+                httpStatus: number;
+            };
+            stack: undefined;
+            code: import("@trpc/server/rpc").TRPC_ERROR_CODE_NUMBER;
+        };
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>;
+    _meta: object;
+    _ctx_out: {
+        requestId: string | undefined;
+        res: import("http").ServerResponse<import("http").IncomingMessage>;
+        tokenType: import("../../auth").TokenType | undefined;
+        entity: import("../context").EntityContext | undefined;
+        req: import("http").IncomingMessage;
+        usedRefreshToken: boolean | undefined;
+        tokenRenewed: boolean | undefined;
+    };
+    _input_in: typeof import("@trpc/server").unsetMarker;
+    _input_out: typeof import("@trpc/server").unsetMarker;
+    _output_in: typeof import("@trpc/server").unsetMarker;
+    _output_out: typeof import("@trpc/server").unsetMarker;
+}>;
+export {};