@quan-erp/shared-backend-core 1.0.1

package/dist/types/2ad56231/54246ca2/c766feba.d.ts

@@ -0,0 +1,38 @@
+import { PartnerDto } from "../7f3fa48c/66bbc22d.js";
+import { CountryDto, DivisionDto, StateDto, TownshipDto } from "../e6eaea18/29b1bffc.js";
+export declare class CreatePartnerShippingAddressDto {
+    partnerId: number;
+    address: string;
+    countryId: number;
+    divisionId: number;
+    stateId: number;
+    townshipId: number;
+    postalCode?: string;
+    isDefault?: boolean;
+    lat?: number;
+    lng?: number;
+}
+export declare class UpdatePartnerShippingAddressDto {
+    address?: string;
+    countryId?: number;
+    divisionId?: number;
+    stateId?: number;
+    townshipId?: number;
+    postalCode?: string;
+    isDefault?: boolean;
+    lat?: number;
+    lng?: number;
+}
+export declare class PartnerShippingAddressDto {
+    partnerId: number;
+    partner: PartnerDto;
+    address?: string;
+    country: CountryDto;
+    division: DivisionDto;
+    state: StateDto;
+    township: TownshipDto;
+    postalCode?: string;
+    isDefault: boolean;
+    lat?: number;
+    lng?: number;
+}

package/dist/types/2ad56231/54246ca2/ddde299e.d.ts

@@ -0,0 +1,10 @@
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { CreatePartnerShippingAddressDto, UpdatePartnerShippingAddressDto } from "./c766feba.js";
+import { PartnerShippingAddressService } from "./ba53415c.js";
+export declare class PartnerShippingAddressController {
+    service: PartnerShippingAddressService;
+    post(body: RequestDto<CreatePartnerShippingAddressDto>): Promise<import("../../entities/partner-shipping.entity.js").PartnerShippingAddressEntity>;
+    get(partnerId: number, skip: number, limit: number): Promise<ResponseDto<import("../../entities/partner-shipping.entity.js").PartnerShippingAddressEntity[]>>;
+    update(body: RequestDto<UpdatePartnerShippingAddressDto>, partnerId: number): Promise<ResponseDto<null>>;
+    delete(id: number): Promise<void>;
+}

package/dist/types/2ad56231/60be9861/b353ab56.d.ts

@@ -0,0 +1,6 @@
+import { Response as ExpressResponse, Request as ExpressRequest } from "express";
+import { Loggable } from "../../0d45f5fd/4dd6b41d.js";
+export declare class MapController {
+    logger: Loggable;
+    getMap(res: ExpressResponse, req: ExpressRequest): Promise<ExpressResponse<any, Record<string, any>>>;
+}

package/dist/types/2ad56231/618b8c8d/328b7669.d.ts

@@ -0,0 +1,29 @@
+import { DataSource } from "typeorm";
+import { FirebaseFCMEntity } from "../../2cc49785/abb76582.js";
+import { Loggable } from "../../0d45f5fd/4dd6b41d.js";
+import { BasicNotificationInfo, FirebaseNotificationData } from "./f362ec51.js";
+export declare class FirebaseService {
+    source: DataSource;
+    logger: Loggable;
+    get fcmRepo(): import("typeorm").Repository<FirebaseFCMEntity>;
+    private initializeFirebase;
+    registerToken(userId: number, token: string): Promise<void>;
+    deleteTokenByTokenString(token: string | string[]): Promise<void>;
+    getTokens(props: {
+        userIds?: number[];
+        roleIds?: number[];
+    }): Promise<string[]>;
+    private getAllValidTokens;
+    sendNotificationToAllAdminUser(props: BasicNotificationInfo & {
+        data?: FirebaseNotificationData;
+    }): Promise<void>;
+    /**
+     * Sends a direct push notification via Firebase FCM.
+     */
+    sendNotification(props: BasicNotificationInfo & {
+        userIds?: number[];
+        roleIds?: number[];
+        data?: FirebaseNotificationData;
+    }): Promise<void>;
+    private sendToTokens;
+}

package/dist/types/2ad56231/618b8c8d/f362ec51.d.ts

@@ -0,0 +1,11 @@
+export type FirebaseNotificationData = {
+    topic: string;
+    pluginName: string;
+    payload?: string;
+    url?: string;
+} & Record<string, string>;
+export type BasicNotificationInfo = {
+    title?: string;
+    body?: string;
+    imageUrl?: string;
+};

package/dist/types/2ad56231/618b8c8d/febc0d90.d.ts

@@ -0,0 +1,9 @@
+import { RequestedUser } from "../../0d45f5fd/4b41f653.js";
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { FirebaseService } from "./328b7669.js";
+export declare class FirebaseController {
+    firebaseService: FirebaseService;
+    register(user: RequestedUser, body: RequestDto<{
+        token: string;
+    }>): Promise<ResponseDto<null>>;
+}

package/dist/types/2ad56231/7f3fa48c/33ac582f.d.ts

@@ -0,0 +1,14 @@
+import { RequestedUser } from "../../0d45f5fd/4b41f653.js";
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { SportlightSearchDto } from "../../9477dda6/a16c3886.js";
+import { CreatePartnerDto } from "./66bbc22d.js";
+import { PartnerService } from "./5319afba.js";
+export declare class ParterController {
+    service: PartnerService;
+    get(skip: number, limit: number, search?: string, isSupplier?: boolean, isCustomer?: boolean): Promise<ResponseDto<import("../../index.js").PartnerEntity[]>>;
+    getById(id: number): Promise<ResponseDto<import("../../index.js").PartnerEntity | null>>;
+    create(body: RequestDto<CreatePartnerDto>, user: RequestedUser): Promise<ResponseDto<null>>;
+    update(id: number, body: RequestDto<any>, user: RequestedUser): Promise<ResponseDto<null>>;
+    delete(id: number): Promise<ResponseDto<null>>;
+    search(body: RequestDto<SportlightSearchDto>, user: RequestedUser): Promise<ResponseDto<import("../../index.js").PartnerEntity[]>>;
+}

package/dist/types/2ad56231/7f3fa48c/5319afba.d.ts

@@ -0,0 +1,93 @@
+import { DataSource } from "typeorm";
+import { PartnerEntity } from "../../2cc49785/290169fd.js";
+import { CreatePartnerDto } from "./66bbc22d.js";
+import { TagEntity } from "../../871f3f39/f2188d12.js";
+import { CreateServiceProps, OptionalCreatedByUser } from "../../abe2c417/8f79089f.js";
+import { ChangeLogService } from "../7f9ba364/e4ec6555.js";
+import { SportlightSearchDto } from "../../9477dda6/a16c3886.js";
+import { RequestedUser } from "../../0d45f5fd/4b41f653.js";
+import { PermissionService } from "../../6610c73e/fdeb3389/16152e20.js";
+/**
+ * Service responsible for managing business partners (Customers and Suppliers).
+ *
+ * This service serves as the core CRM/SRM engine of the system, handling:
+ * 1. **Identity Management**: Lifecycle of partners including complex metadata
+ *    syncing (address, tags, contact info).
+ * 2. **Relationship Syncing**: Manual orchestration of many-to-many tag
+ *    relationships during updates to ensure transactional consistency.
+ * 3. **Search Discovery**: Powerful ILIKE-based filtering and integration with
+ *    the global Spotlight search, protected by RBAC permission checks.
+ * 4. **Auditability**: Detailed property-level change logging for all
+ *    partner modifications.
+ */
+export declare class PartnerService {
+    source: DataSource;
+    changeLogService: ChangeLogService;
+    permissionService: PermissionService;
+    /**
+     * Internal TypeORM repository for PartnerEntity.
+     */
+    get repo(): import("typeorm").Repository<PartnerEntity>;
+    /**
+     * Internal TypeORM repository for TagEntity.
+     */
+    get tagRepo(): import("typeorm").Repository<TagEntity>;
+    /**
+     * Retrieves partners based on search criteria and type filters.
+     *
+     * @param options - Includes search query, type flags (isCustomer, isSupplier), and pagination.
+     * @returns A list of partners with their tags and shipping addresses populated.
+     */
+    getPartner({ search, isCustomer, isSupplier, skip, limit }: {
+        search?: string;
+        isSupplier?: boolean;
+        isCustomer?: boolean;
+        skip: number;
+        limit: number;
+    }): Promise<PartnerEntity[]>;
+    /**
+     * Finds a single partner by their primary ID.
+     * @param id - The numeric ID of the partner.
+     */
+    getPartnerById(id: number): Promise<PartnerEntity | null>;
+    /**
+     * Creates a new business partner and handles initial tag mapping.
+     *
+     * Automates the creation of an audit trail via ChangeLogService and
+     * invalidates relevant partner caches.
+     *
+     * @param props - Partner data and creation context (creatorId, manager).
+     */
+    create(props: CreateServiceProps<CreatePartnerDto & OptionalCreatedByUser>): Promise<import("typeorm").InsertResult>;
+    /**
+     * Bulk creates multiple partners in a single operation.
+     * @param props - Array of partner data and context.
+     */
+    createMany(props: CreateServiceProps<CreatePartnerDto[] & OptionalCreatedByUser>): Promise<import("typeorm").InsertResult>;
+    /**
+     * Updates an existing partner's metadata and synchronizes many-to-many tag relationships.
+     *
+     * This method manually handles the deletion and insertion of join table records
+     * for tags to ensure atomic consistency within a single transaction.
+     *
+     * @param id - The ID of the partner to update.
+     * @param partner - The updated partner DTO.
+     * @param updateBy - The ID of the user performing the update.
+     */
+    update(id: number, partner: CreatePartnerDto, updateBy?: number): Promise<void>;
+    /**
+     * Permantently deletes a partner record.
+     * @param id - The ID of the partner to remove.
+     */
+    delete(id: number): Promise<void>;
+    /**
+     * Integrates partners into the global Spotlight search feature.
+     *
+     * Implements strict RBAC checks to ensure the requesting user has
+     * visibility into partner data before executing linguistic queries.
+     *
+     * @param dto - Global search query and strategy.
+     * @param user - Information about the requesting user (role, permissions).
+     */
+    sportlightSearch(dto: SportlightSearchDto, user: RequestedUser): Promise<PartnerEntity[]>;
+}

package/dist/types/2ad56231/7f3fa48c/66bbc22d.d.ts

@@ -0,0 +1,40 @@
+import { TagDto } from "../../6610c73e/2a1073a6/48a99f86.js";
+import { PartnerSex } from "../../2cc49785/290169fd.js";
+export interface CreatePartnerDto {
+    id?: number;
+    firstName: string;
+    lastName: string;
+    sex?: PartnerSex;
+    dob?: Date | string;
+    email?: string;
+    phone?: string;
+    phone2?: string;
+    phone3?: string;
+    address?: string;
+    city?: string;
+    country?: string;
+    isActive?: boolean;
+    internalNotes?: string;
+    isCustomer?: boolean;
+    isSupplier?: boolean;
+    tags?: number[];
+}
+export interface PartnerDto {
+    id: number;
+    firstName: string;
+    lastName: string;
+    sex?: PartnerSex | string;
+    dob?: Date | string;
+    email?: string;
+    phone?: string;
+    phone2?: string;
+    phone3?: string;
+    address?: string;
+    city?: string;
+    country?: string;
+    isActive?: boolean;
+    internalNotes?: string;
+    isCustomer: boolean;
+    isSupplier: boolean;
+    tags?: TagDto[];
+}

package/dist/types/2ad56231/7f9ba364/09265e63.d.ts

@@ -0,0 +1,19 @@
+export interface ChangeLogDto {
+    message: string;
+    createdBy?: number;
+    metadata?: any;
+    isCreatedBySystem?: boolean;
+    pluginName: string;
+    referencePrefix: string;
+    referenceNumber: string;
+    replyToId?: number;
+    passive?: boolean;
+}
+export interface GetChangeLogDto extends ChangeLogDto {
+    id: number;
+}
+export interface ChangeLogReactionDto {
+    reaction: string;
+    reactBy: number;
+    changeLogId: number;
+}

package/dist/types/2ad56231/7f9ba364/0ac71637.d.ts

@@ -0,0 +1,27 @@
+import { RequestedUser } from "../../0d45f5fd/4b41f653.js";
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { ChangeLogDto, ChangeLogReactionDto } from "./09265e63.js";
+import { ChangeLogService } from "./e4ec6555.js";
+export declare class ChangeLogController {
+    changeLogService: ChangeLogService;
+    create(body: RequestDto<ChangeLogDto>, user: RequestedUser): Promise<ResponseDto<null>>;
+    addReaction(body: RequestDto<ChangeLogReactionDto>, user: RequestedUser): Promise<ResponseDto<null>>;
+    removeReaction(id: number, user: RequestedUser): Promise<ResponseDto<null>>;
+    getById(pluginName: string, referencePrefix: string, referenceNumber: string, skip: number, limit: number, parentId?: number): Promise<ResponseDto<{
+        replyCount: number;
+        id: number;
+        message: string;
+        createdBy: InstanceType<typeof import("../../index.js").UserEntity>;
+        metadata: any;
+        isCreatedBySystem: boolean;
+        pluginName: string;
+        referencePrefix: string;
+        referenceNumber: string;
+        replyTo: InstanceType<typeof import("../../entities/change-log.entity.js").ChangeLogEntity>;
+        reactions: InstanceType<typeof import("../../entities/change-log.entity.js").ChangeLogReactionsEntity>[];
+        createDate: Date;
+        updateDate: Date;
+        deleteDate: Date;
+        version: number;
+    }[]>>;
+}

package/dist/types/2ad56231/7f9ba364/e4ec6555.d.ts

@@ -0,0 +1,45 @@
+import { DataSource } from "typeorm";
+import { CreateServiceProps, ServiceProps } from "../../abe2c417/8f79089f.js";
+import { ChangeLogDto, ChangeLogReactionDto } from "./09265e63.js";
+import { ChangeLogEntity, ChangeLogReactionsEntity } from "../../2cc49785/5442f571.js";
+import { ICache } from "../../0d45f5fd/9a2c73cf.js";
+import { NotificationService } from "../1242ab99/21beedc5.js";
+import { UserService } from "../../6610c73e/04f8996d/45843092.js";
+export declare class ChangeLogService {
+    datasource: DataSource;
+    cache: ICache;
+    notificationService: NotificationService;
+    userService: InstanceType<typeof UserService>;
+    private withManager;
+    addChangeLog(params: CreateServiceProps<ChangeLogDto>): Promise<void>;
+    addChangeLogs(params: CreateServiceProps<ChangeLogDto[]>): Promise<void>;
+    addReaction(params: CreateServiceProps<ChangeLogReactionDto>): Promise<void>;
+    removeReaction(params: ServiceProps<{
+        id: number;
+        removeByUserId: number;
+    }>): Promise<void>;
+    getChangeLogs(params: {
+        pluginName?: string;
+        referencePrefix?: string;
+        referenceNumber?: string;
+        parentId?: number;
+        skip: number;
+        limit: number;
+    }): Promise<{
+        replyCount: number;
+        id: number;
+        message: string;
+        createdBy: InstanceType<typeof import("../../index.js").UserEntity>;
+        metadata: any;
+        isCreatedBySystem: boolean;
+        pluginName: string;
+        referencePrefix: string;
+        referenceNumber: string;
+        replyTo: InstanceType<typeof ChangeLogEntity>;
+        reactions: InstanceType<typeof ChangeLogReactionsEntity>[];
+        createDate: Date;
+        updateDate: Date;
+        deleteDate: Date;
+        version: number;
+    }[]>;
+}

package/dist/types/2ad56231/83b99aea/14bdfadf.d.ts

@@ -0,0 +1,10 @@
+import { Request as ExpressRequest } from "express";
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { LocationTrackingDTO } from "./6244682b.js";
+import { LocationTrackingService } from "./fc1f5daa.js";
+import { RequestedUser } from "../../0d45f5fd/4b41f653.js";
+export declare class LocationTrackingController {
+    service: LocationTrackingService;
+    locationUpdate(req: ExpressRequest, user: RequestedUser, body: RequestDto<LocationTrackingDTO>): Promise<ResponseDto<null>>;
+    get(id: number): Promise<ResponseDto<import("../../index.js").LocationTrackingEntity[] | null>>;
+}

package/dist/types/2ad56231/83b99aea/6244682b.d.ts

@@ -0,0 +1,4 @@
+export interface LocationTrackingDTO {
+    lat: number;
+    lng: number;
+}

package/dist/types/2ad56231/83b99aea/fc1f5daa.d.ts

@@ -0,0 +1,10 @@
+import { LocationTrackingEntity } from "../../2cc49785/56873654.js";
+export declare class LocationTrackingService {
+    private source;
+    private get repo();
+    update(userId: number, pos: {
+        lat: number;
+        lng: number;
+    }): Promise<void>;
+    getByUserId(userId: number): Promise<LocationTrackingEntity[] | null>;
+}

package/dist/types/2ad56231/85000c0b/4024111d.d.ts

@@ -0,0 +1,34 @@
+export interface JsonRpcRequest<TParams = any> {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    method: string;
+    params?: TParams;
+}
+export interface JsonRpcSuccess {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result: any;
+}
+export interface JsonRpcError {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    error: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+}
+export interface ToolContext {
+    user: {
+        id: string;
+        tenant_id: string;
+        permissions: string[];
+    };
+}
+export type ToolHandler = (args: any, ctx: ToolContext) => Promise<any>;
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    schema: any;
+    handler: ToolHandler;
+}

package/dist/types/2ad56231/85000c0b/632c90fb.d.ts

@@ -0,0 +1,8 @@
+import { AIToolsService } from "../../6610c73e/87f29211/fc973325/1abe9fb9.js";
+import { JsonRpcError, JsonRpcRequest, JsonRpcSuccess } from "./4024111d.js";
+export declare class AIMcpController {
+    toolService: AIToolsService;
+    post(body: JsonRpcRequest): Promise<JsonRpcSuccess | JsonRpcError>;
+    private listTool;
+    private callTool;
+}

package/dist/types/2ad56231/9983e5f2/16ee99b3.d.ts

@@ -0,0 +1,58 @@
+import { DataSource } from "typeorm";
+import { CreateUnitMeasurementDto, UpdateUnitMeasurementDto } from "./587bf67d.js";
+import { ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { UnitEntity } from "../../2cc49785/265711a1.js";
+/**
+ * Service responsible for managing Unit of Measurement (UOM) definitions.
+ *
+ * This service handles the catalog of units (e.g., Kilograms, Litres, Meters)
+ * used across inventory, production, and sales modules. It ensures data
+ * integrity through conflict-aware upsert operations and provides
+ * category-based filtering to support physical measurement conversions.
+ */
+export declare class UnitMeasurementService {
+    source: DataSource;
+    /**
+     * Internal Repository for UnitEntity.
+     */
+    get repo(): import("typeorm").Repository<UnitEntity>;
+    /**
+     * Creates or updates a single Unit of Measurement.
+     *
+     * Uses an upsert strategy based on name, code, symbol, and categoryId
+     * to prevent duplicate units across the system.
+     *
+     * @param data - The unit metadata to save.
+     */
+    create(data: CreateUnitMeasurementDto): Promise<ResponseDto<UnitEntity>>;
+    /**
+     * Bulk creates or updates multiple units with conflict resolution.
+     * @param data - Array of unit metadata structures.
+     */
+    createMany(data: CreateUnitMeasurementDto[]): Promise<ResponseDto<UnitEntity[]>>;
+    /**
+     * Retrieves a paginated list of all units with their measurement categories.
+     *
+     * @param skip - Pagination offset.
+     * @param limit - Max records to return.
+     */
+    get(skip: number, limit: number): Promise<UnitEntity[]>;
+    /**
+     * Retrieves all units belonging to a specific measurement dimension (category).
+     *
+     * @param categoryId - The numeric ID of the UnitCategory (e.g., 'Weight').
+     */
+    getUnitByCategory(categoryId: number): Promise<UnitEntity[]>;
+    /**
+     * Finds a specific unit by its primary primary key.
+     * @param id - The numeric ID of the unit.
+     */
+    getById(id: number): Promise<UnitEntity | null>;
+    /**
+     * Updates an existing Unit of Measurement's parameters.
+     *
+     * @param id - The numeric ID of the record to update.
+     * @param data - Partial update metadata.
+     */
+    update(id: number, data: UpdateUnitMeasurementDto): Promise<void>;
+}

package/dist/types/2ad56231/9983e5f2/587bf67d.d.ts

@@ -0,0 +1,21 @@
+export interface CreateUnitMeasurementDto {
+    name: string;
+    symbol: string;
+    code: string;
+    isBase: boolean;
+    categoryId: number;
+}
+export interface UpdateUnitMeasurementDto {
+    id: number;
+    name: string;
+    symbol: string;
+    code: string;
+    isBase: boolean;
+}
+export interface UnitMeasurementDto {
+    id: number;
+    name: string;
+    symbol: string;
+    code: string;
+    isBase: boolean;
+}

package/dist/types/2ad56231/9983e5f2/9b6e3ed3.d.ts

@@ -0,0 +1,10 @@
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { CreateUnitMeasurementDto, UpdateUnitMeasurementDto } from "./587bf67d.js";
+import { UnitMeasurementService } from "./16ee99b3.js";
+export declare class UnitMeasurementController {
+    service: UnitMeasurementService;
+    getMeasurement(skip: number, limit: number): Promise<ResponseDto<import("../../index.js").UnitEntity[]>>;
+    getRelatedMeasurement(categoryId: any): Promise<ResponseDto<any>>;
+    create(body: RequestDto<CreateUnitMeasurementDto>): Promise<ResponseDto<null>>;
+    update(id: number, body: RequestDto<UpdateUnitMeasurementDto>): Promise<ResponseDto<null>>;
+}

package/dist/types/2ad56231/9ab6b92e.d.ts

@@ -0,0 +1,41 @@
+import { Env, ICache, Loggable } from "../0d45f5fd/93c2615f.js";
+import { PartnerService } from "./7f3fa48c/5319afba.js";
+import { UnitMeasurementService } from "./9983e5f2/16ee99b3.js";
+import { CurrencyService } from "./466e5b9c/ba999e69.js";
+import { UnitCategoryService } from "./e938ace2/c2e78ccc.js";
+import { DataSeedHistoryService } from "../6610c73e/6e1815de/1ec1270e.js";
+import { DeveloperConfigService } from "./01dcea55/0a5f3cca.js";
+import { ConcurrentTableLockService } from "../6610c73e/82de49c1/a1399ef0.js";
+import { EnvService } from "../6610c73e/b77349bf/6d87f127.js";
+import { UserService } from "../6610c73e/04f8996d/45843092.js";
+import { PluginService } from "../6610c73e/5e689e2b/08490b99.js";
+import { RoleService } from "../6610c73e/4b168d88/413ef4e3.js";
+import { PermissionService } from "../6610c73e/fdeb3389/16152e20.js";
+import { DataSource } from "typeorm";
+import { BranchService } from "../6610c73e/b96961ed.js";
+export declare const BUILTIN_MODULE: string;
+export declare class BuiltinModules {
+    permissionService: PermissionService;
+    userService: InstanceType<typeof UserService>;
+    roleService: RoleService;
+    pluginService: PluginService;
+    currencyService: CurrencyService;
+    branchService: BranchService;
+    partnerService: PartnerService;
+    seedHistory: DataSeedHistoryService;
+    developerConfigService: DeveloperConfigService;
+    concurrentTableLockService: ConcurrentTableLockService;
+    dataSource: DataSource;
+    env: Env;
+    envService: EnvService;
+    unitCategoryService: UnitCategoryService;
+    unitMeasurementService: UnitMeasurementService;
+    logger: Loggable;
+    cacheClient: ICache;
+    private get app();
+    uniqueByCode<T extends {
+        code: string;
+    }>(items: T[]): T[];
+    private sanitizeCode;
+    onInitialized(): Promise<void>;
+}

package/dist/types/2ad56231/9d263798/45449764.d.ts

@@ -0,0 +1,18 @@
+import { SettingService } from "../ec72b956/d75444a8.js";
+export declare class WebManifestController {
+    setting: SettingService;
+    get(): Promise<{
+        name: string;
+        short_name: string;
+        start_url: string;
+        display: string;
+        background_color: string;
+        theme_color: string;
+        icons: {
+            src: string;
+            sizes: string;
+            type: string;
+            purpose: string;
+        }[];
+    }>;
+}

package/dist/types/2ad56231/a7b85550/0024064d.d.ts

@@ -0,0 +1,51 @@
+import { DataSource } from "typeorm";
+import { CurrencyExchangeRateEnity } from "../../2cc49785/35b9365a.js";
+/**
+ * Service responsible for managing currency exchange rates and conversions.
+ *
+ * This service handles:
+ * 1. **Bi-directional Rate Updates**: When a rate is updated (e.g., USD to EUR),
+ *    it automatically calculates and persists the inverse rate (EUR to USD)
+ *    within an atomic transaction.
+ * 2. **Chronological Retrieval**: Fetching the most recent rates while
+ *    preserving a historical record of past fluctuations.
+ * 3. **Optimized Queries**: Using subqueries and aggregations to efficiently
+ *    retrieve the latest rates for all currency pairs relative to a base source.
+ */
+export declare class CurrencyExchangeService {
+    source: DataSource;
+    /**
+     * Internal TypeORM repository for CurrencyExchangeRateEnity.
+     */
+    get repo(): import("typeorm").Repository<CurrencyExchangeRateEnity>;
+    /**
+     * Updates the exchange rates between two currencies in both directions.
+     *
+     * This method ensures that if a rate is set from Currency A to Currency B,
+     * the inverse rate (B to A) is automatically calculated and persisted as 1/rate
+     * within an atomic transaction.
+     *
+     * @param fromCurrencyId - The source currency ID.
+     * @param toCurrencyId - The target currency ID.
+     * @param rate - The numeric exchange factor.
+     */
+    updateRate(fromCurrencyId: number, toCurrencyId: number, rate: number): Promise<void>;
+    /**
+     * Retrieves the most recent (current) exchange rate for a specific currency pair.
+     *
+     * @param fromCurrencyId - The ID of the source currency.
+     * @param toCurrencyId - The ID of the target currency.
+     * @returns The latest exchange rate record, ordered by creation date descending.
+     */
+    getRate(fromCurrencyId: number, toCurrencyId: number): Promise<CurrencyExchangeRateEnity | null>;
+    /**
+     * Retrieves the latest exchange rates for all available currencies relative to a source.
+     *
+     * This method uses a complex subquery join to ensure only the most recent
+     * record for each unique target currency is returned.
+     *
+     * @param fromCurrencyId - The source currency ID.
+     * @returns A collection of formatted rate objects with source/target metadata.
+     */
+    getLatestRates(fromCurrencyId: number): Promise<any>;
+}

package/dist/types/2ad56231/a7b85550/656e3fe6.d.ts

@@ -0,0 +1,5 @@
+export interface UpdateCurrencyExchangeRateDto {
+    fromCurrencyId: number;
+    toCurrencyId: number;
+    rate: number;
+}

package/dist/types/2ad56231/a7b85550/c98f53f7.d.ts

@@ -0,0 +1,8 @@
+import { CurrencyExchangeService } from "./0024064d.js";
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { UpdateCurrencyExchangeRateDto } from "./656e3fe6.js";
+export declare class CurrencyExchangeController {
+    service: CurrencyExchangeService;
+    getExchangeRate(from: number, to: any): Promise<ResponseDto<any>>;
+    updateRate(body: RequestDto<UpdateCurrencyExchangeRateDto>): Promise<ResponseDto<void>>;
+}