@quan-erp/shared-backend-core 1.0.1

package/dist/types/0d45f5fd/ec0a65fc.d.ts

@@ -0,0 +1,32 @@
+import express from 'express';
+import serveStatic from 'serve-static';
+export declare const STATIC_FILE_METADATA_KEY = "static";
+export type StaticFileOptions = {
+    dir: string;
+    route: string;
+    plugin?: string;
+    name?: string;
+    options?: serveStatic.ServeStaticOptions<express.Response<any, Record<string, any>>>;
+};
+/**
+ * Class decorator to mark a class as serving static files.
+ *
+ * Stores metadata about the static file configuration, including
+ * the directory to serve, the route prefix, and optional plugin/name info.
+ *
+ * @param {StaticFileOptions} options - Configuration for the static file serving.
+ * @param {string} options.dir - The directory on the file system to serve files from.
+ * @param {string} options.route - The URL route prefix to serve the files.
+ * @param {string} [options.plugin] - Optional plugin name associated with these static files.
+ * @param {string} [options.name] - Optional name for this static file configuration.
+ *
+ * @returns {ClassDecorator} A decorator that attaches static file metadata to the class.
+ *
+ * @example
+ * ```ts
+ * @StaticFile({ dir: "public", route: "/assets" })
+ * class PublicAssets {}
+ * ```
+ */
+export declare function StaticFile(options: StaticFileOptions): ClassDecorator;
+export declare function getStaticConfig(target: any): StaticFileOptions | undefined;

package/dist/types/0d45f5fd/ed08a5cd.d.ts

@@ -0,0 +1,17 @@
+import { IPlugin } from "@quan-erp/shared-types";
+import { HealthStatus } from "./f7da2669.js";
+export type PluginRegistryValue = {
+    health: HealthStatus;
+    plugin: IPlugin;
+};
+export declare class PluginManager {
+    private readonly plugins;
+    register(plugin: IPlugin): void;
+    deRegister(pluginName: string): void;
+    getRegistry(): Map<string, PluginRegistryValue>;
+    getPlugin(pluginName: string): PluginRegistryValue | undefined;
+    isInstalled(pluginName: string): boolean;
+    setHealthStatus(pluginName: string, status: HealthStatus): void;
+    getHealStatus(pluginName: string): HealthStatus;
+    logDebugInfo(): void;
+}

package/dist/types/0d45f5fd/ee447758.d.ts

@@ -0,0 +1,3 @@
+export declare class QueueManager {
+    remove(plugin: string): void;
+}

package/dist/types/0d45f5fd/f7da2669.d.ts

@@ -0,0 +1,6 @@
+export type HealthStatus = 'ready' | 'pending' | 'failed';
+export interface IHealthCheck {
+    set(status: HealthStatus): void;
+}
+export declare function InjectHealthCheck(): (target: any, property: any) => void;
+export declare function getHealthCheckConfig(target: any, property: any): boolean | undefined;

package/dist/types/2ad56231/01dcea55/0a5f3cca.d.ts

@@ -0,0 +1,26 @@
+import { EntityManager } from "typeorm";
+import { DeveloperConfigDto } from "./1cdf989f.js";
+import { DeveloperConfigEntity } from "../../2cc49785/4b7aaf01.js";
+import { CreateServiceProps } from "../../abe2c417/8f79089f.js";
+import { ICache } from "../../0d45f5fd/9a2c73cf.js";
+import { Loggable } from "../../0d45f5fd/4dd6b41d.js";
+export declare class DeveloperConfigService {
+    private source;
+    logger: Loggable;
+    cacheClient: ICache;
+    private get repo();
+    authorizeDeveloper(password: string): Promise<boolean>;
+    set(props: CreateServiceProps<DeveloperConfigDto | DeveloperConfigDto[]>): Promise<void>;
+    private getKey;
+    getPublicConfigByKeyAndPlugin(pluginName: string, key: string, option?: {
+        manager?: EntityManager;
+        lock?: "pessimistic_read" | "pessimistic_write";
+    }): Promise<DeveloperConfigEntity | null>;
+    getAllPublicConfigs(skip: number, limit: number): Promise<DeveloperConfigEntity[]>;
+    getPrivateConfig(pluginName: string, key: string, option?: {
+        manager?: EntityManager;
+        lock?: "pessimistic_read" | "pessimistic_write";
+        decrypt?: boolean;
+    }): Promise<DeveloperConfigEntity | null>;
+    remove(key: string, pluginName: string): Promise<void>;
+}

package/dist/types/2ad56231/01dcea55/1cdf989f.d.ts

@@ -0,0 +1,13 @@
+import { DeveloperConfigDataType } from "../../2cc49785/4b7aaf01.js";
+export interface DeveloperConfigDto {
+    key: string;
+    value: any;
+    pluginName: string;
+    isVisibleToUser?: boolean;
+    private?: boolean;
+    displayName?: string;
+    description?: string;
+    expiry?: Date;
+    encrypt?: boolean;
+    datatype: DeveloperConfigDataType;
+}

package/dist/types/2ad56231/01dcea55/344c0cbf.d.ts

@@ -0,0 +1,12 @@
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { DeveloperConfigService } from "./0a5f3cca.js";
+export declare class DeveloperConfigController {
+    developerConfigService: DeveloperConfigService;
+    get(skip: number, limit: number, key?: string, pluginName?: string): Promise<ResponseDto<import("../../entities/developer-config.entity.js").DeveloperConfigEntity | null> | ResponseDto<import("../../entities/developer-config.entity.js").DeveloperConfigEntity[]>>;
+    isExpire(): Promise<ResponseDto<{
+        isExpire: boolean;
+        subscriptionEndDate: string | null | undefined;
+        graceDays: string | null | undefined;
+    }>>;
+    post(body: RequestDto<any>): Promise<ResponseDto<any>>;
+}

package/dist/types/2ad56231/01dcea55/3a555783.d.ts

@@ -0,0 +1,17 @@
+export declare const BuiltinDeveloperConfigKeys: {
+    MAX_USER_LIMIT: string;
+    MAX_ACTIVE_USER_LIMIT: string;
+    MAX_USER_SESSION_LIMIT_PER_USER: string;
+    MAX_ORGANIZATION_BRANCH: string;
+    MAX_ROLE_LIMIT: string;
+    MAX_CURRENCY_LMIT: string;
+    MAX_LOCAL_UPLOAD_FILE_SIZE: string;
+    MAX_LOCAL_FILE_SIZE_IN_MB: string;
+    MAX_S3_UPLOAD_FILE_SIZE: string;
+    MAX_S3_FILE_SIZE_IN_MB: string;
+    MAX_SUBSCRIPTION_GRACE_PERIOD_DAYS: string;
+    SUBSCRIPTION_END_DATE: string;
+    DEVELOPER_CONFIG_PASSWORD: string;
+    AI_REQUEST_COUNT_PER_HOUR: string;
+    MAX_AI_WORKFLOW_LIMIT: string;
+};

package/dist/types/2ad56231/1242ab99/21beedc5.d.ts

@@ -0,0 +1,53 @@
+import { NotificationTargetType } from "../../2cc49785/2a1b2f6a.js";
+import { CreateNotificationDto } from "./7b7754ee.js";
+import { ServiceProps } from "../../abe2c417/8f79089f.js";
+import { NotificationClickEntity } from "../../2cc49785/79c7a4c3.js";
+export declare class NotificationService {
+    private source;
+    private firebaseService;
+    private get notiRepo();
+    private get notiReadRepo();
+    /**
+     * Sends a system notification and triggers a push notification.
+     */
+    send(props: CreateNotificationDto): Promise<void>;
+    /**
+     * Retrieves notifications for a specific user.
+     */
+    get({ manager, userId, roleId, skip, limit }: ServiceProps<{
+        userId: number;
+        roleId: number;
+        skip: number;
+        limit: number;
+    }>): Promise<{
+        isRead: boolean;
+        id: number;
+        targetType: NotificationTargetType;
+        topic: string;
+        url: string;
+        user?: InstanceType<typeof import("../../index.js").UserEntity>[];
+        role?: InstanceType<typeof import("../../index.js").RoleEntity>[];
+        title: string;
+        subtitle?: string;
+        body?: string;
+        pluginName: string;
+        icon?: InstanceType<typeof import("../../index.js").FileEntity>;
+        data: Record<string, any>;
+        clicks: InstanceType<typeof NotificationClickEntity>[];
+        createDate: Date;
+        updateDate: Date;
+        deleteDate: Date;
+        version: number;
+    }[]>;
+    getUnreadNotiCount({ userId, roleId }: {
+        userId: number;
+        roleId: number;
+    }): Promise<number>;
+    /**
+     * Marks a specific notification as read by a user.
+     */
+    markRead({ manager, id, userId }: ServiceProps<{
+        id: number;
+        userId: number;
+    }>): Promise<void>;
+}

package/dist/types/2ad56231/1242ab99/7b7754ee.d.ts

@@ -0,0 +1,12 @@
+import { FirebaseNotificationData } from "../618b8c8d/f362ec51.js";
+export type CreateNotificationDto = {
+    userIds?: number[];
+    roleIds?: number[];
+    title: string;
+    subtitle: string;
+    body: string;
+    pluginName: string;
+    topic: string;
+    url?: string;
+    data?: FirebaseNotificationData;
+};

package/dist/types/2ad56231/1242ab99/abc978a7.d.ts

@@ -0,0 +1,32 @@
+import { RequestedUser } from "../../0d45f5fd/4b41f653.js";
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { CreateNotificationDto } from "./7b7754ee.js";
+import { NotificationService } from "./21beedc5.js";
+export declare class NotificationController {
+    service: NotificationService;
+    get(user: RequestedUser, skip: number, limit: number): Promise<ResponseDto<{
+        isRead: boolean;
+        id: number;
+        targetType: import("../../entities/notification.entity.js").NotificationTargetType;
+        topic: string;
+        url: string;
+        user?: InstanceType<typeof import("../../index.js").UserEntity>[];
+        role?: InstanceType<typeof import("../../index.js").RoleEntity>[];
+        title: string;
+        subtitle?: string;
+        body?: string;
+        pluginName: string;
+        icon?: InstanceType<typeof import("../../index.js").FileEntity>;
+        data: Record<string, any>;
+        clicks: InstanceType<typeof import("../../entities/notification-read.entity.js").NotificationClickEntity>[];
+        createDate: Date;
+        updateDate: Date;
+        deleteDate: Date;
+        version: number;
+    }[]>>;
+    unread(user: RequestedUser): Promise<ResponseDto<number>>;
+    onClicked(user: RequestedUser, body: RequestDto<{
+        id: number;
+    }>): Promise<ResponseDto<null>>;
+    sendNoti(body: RequestDto<CreateNotificationDto>): Promise<void>;
+}

package/dist/types/2ad56231/1242ab99/e5ff734c.d.ts

@@ -0,0 +1,6 @@
+export declare const BUILTIN_NOTIFICATION_TOPIC: {
+    NEW_DEVICE_LOGIN: string;
+    NEW_ACCESS_TOKEN_CREATED: string;
+    PASSWORD_RESET: string;
+    PASSWORD_CHANGED: string;
+};

package/dist/types/2ad56231/258b1873/2f33bb8d.d.ts

@@ -0,0 +1,10 @@
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { UpdateUnitOfConversionDto } from "./418b84b4.js";
+import { UnitConversionService } from "./f476762d.js";
+export declare class UnitConversionController {
+    service: UnitConversionService;
+    updateConversion(body: RequestDto<UpdateUnitOfConversionDto>): Promise<ResponseDto<null>>;
+    updateConversions(body: RequestDto<UpdateUnitOfConversionDto[]>): Promise<ResponseDto<null>>;
+    getConversion(fromId: number, toId: number | null): Promise<ResponseDto<any>>;
+    getAllConversion(): Promise<ResponseDto<import("../../index.js").UnitConversionEntity[]>>;
+}

package/dist/types/2ad56231/258b1873/418b84b4.d.ts

@@ -0,0 +1,5 @@
+export type UpdateUnitOfConversionDto = {
+    fromUnitId: number;
+    toUnitId: number;
+    conversionFactor: number;
+};

package/dist/types/2ad56231/258b1873/f476762d.d.ts

@@ -0,0 +1,56 @@
+import { DataSource } from "typeorm";
+import { GetByIdServiceProps, ServiceProps } from "../../abe2c417/8f79089f.js";
+import { UnitConversionEntity } from "../../2cc49785/1a4ff9f0.js";
+/**
+ * Service responsible for managing numerical conversion factors between units.
+ *
+ * This service enables the transformation of quantities across different
+ * measurement points (e.g., converting 'Box' to 'Kilograms' or 'Litres'
+ * to 'Millilitres'). It is central to the inventory valuation and
+ * production recipe calculations.
+ */
+export declare class UnitConversionService {
+    source: DataSource;
+    /**
+     * Internal repository for UnitConversionEntity.
+     */
+    get repo(): import("typeorm").Repository<UnitConversionEntity>;
+    /**
+     * Updates the conversion factor between two specific units.
+     *
+     * @param props - Includes fromUnitId, toUnitId, the new conversionFactor, and optional transaction manager.
+     */
+    updateConversion({ manager, fromUnitId, toUnitId, conversionFactor }: ServiceProps<{
+        fromUnitId: number;
+        toUnitId: number;
+        conversionFactor: number;
+    }>): Promise<void>;
+    /**
+     * Bulk updates multiple unit conversion factors.
+     *
+     * Uses an upsert strategy with conflicts handled on the (fromUnit, toUnit) pair.
+     *
+     * @param props - Array of conversion metadata and optional transaction manager.
+     */
+    updateConversionMany({ manager, data }: ServiceProps<{
+        data: {
+            fromUnitId: number;
+            toUnitId: number;
+            conversionFactor: number;
+        }[];
+    }>): Promise<void>;
+    /**
+     * Retrieves all conversion factors where the specified unit is the source.
+     * @param props - Target unit ID and optional transaction manager.
+     */
+    getConversionFrom({ manager, id }: GetByIdServiceProps): Promise<UnitConversionEntity[]>;
+    /**
+     * Retrieves the specific conversion factor between two units.
+     * @param props - From/To unit IDs and optional transaction manager.
+     */
+    getConversionFromTo({ manager, fromId, toId }: ServiceProps<{
+        fromId: number;
+        toId: number;
+    }>): Promise<UnitConversionEntity[]>;
+    getAllConversion({ manager }: ServiceProps<{}>): Promise<UnitConversionEntity[]>;
+}

package/dist/types/2ad56231/2c0a4857/2b466258.d.ts

@@ -0,0 +1,11 @@
+import WebSocket from "ws";
+import { ClientInfo, IWebsocket, WebsocketClient, WebsocketEvents } from "../../0d45f5fd/a1a2ec11.js";
+import { Loggable } from "../../0d45f5fd/4dd6b41d.js";
+import http from 'http';
+export declare class BuiltinWebsocket implements IWebsocket {
+    logger: Loggable;
+    onAuthenticate(ws: WebSocket, req: http.IncomingMessage): ClientInfo | null;
+    onUpgrade(ws: WebSocket, req: http.IncomingMessage): void;
+    on(event: WebsocketEvents, ws: WebsocketClient, data: any, isBinary: boolean): void;
+    onDestoryed(): void;
+}

package/dist/types/2ad56231/2d464c7d/55d4f50c.d.ts

@@ -0,0 +1,8 @@
+import { RequestedUser } from "../../0d45f5fd/4b41f653.js";
+import { SportlightSearchService } from "./e9a5b7d1.js";
+export declare const SPORTLIGHT_SEARCH_HISTORY = "sportlight-search-history";
+export declare class SportlightSearchController {
+    service: SportlightSearchService;
+    get(user: RequestedUser): void;
+    save(): void;
+}

package/dist/types/2ad56231/2d464c7d/e9a5b7d1.d.ts

@@ -0,0 +1,4 @@
+import { DataSource } from "typeorm";
+export declare class SportlightSearchService {
+    source: DataSource;
+}

package/dist/types/2ad56231/3549b002/8f6249d6.d.ts

@@ -0,0 +1,7 @@
+import { Loggable } from "../../0d45f5fd/4dd6b41d.js";
+export declare class DatabaseBackupService {
+    private file;
+    logger: Loggable;
+    createBackup(): Promise<string>;
+    importBackup(file: string): Promise<void>;
+}

package/dist/types/2ad56231/3549b002/9a52fb7c.d.ts

@@ -0,0 +1,10 @@
+import { Response as ExpressResponse, Request as ExpressRequest } from "express";
+import { Loggable } from "../../0d45f5fd/4dd6b41d.js";
+import { DatabaseBackupService } from "./8f6249d6.js";
+export declare class DatabaseBackupController {
+    service: DatabaseBackupService;
+    logger: Loggable;
+    private importFile;
+    createBackup(res: ExpressResponse): Promise<void>;
+    importBackup(response: ExpressResponse, request: ExpressRequest): Promise<unknown>;
+}

package/dist/types/2ad56231/3b9c358f/00c829a8.d.ts

@@ -0,0 +1,12 @@
+import { Request as ExpressRequest, Response as ExpressResponse } from "express";
+import { Loggable, RequestedUser } from "../../0d45f5fd/93c2615f.js";
+import { ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { FileService } from "./298aef08.js";
+export declare class FileController {
+    logger: Loggable;
+    service: FileService;
+    upload(request: ExpressRequest, response: ExpressResponse, user: RequestedUser): Promise<ResponseDto<any>>;
+    getFiles(skip: number, limit: number): Promise<ResponseDto<import("../../entities/file.entity.js").FileEntity[]>>;
+    serveFile(path: string, req: ExpressRequest, res: ExpressResponse, user: RequestedUser): Promise<ExpressResponse<any, Record<string, any>> | ResponseDto<any>>;
+    deleteFile(id: number): Promise<void>;
+}

package/dist/types/2ad56231/3b9c358f/298aef08.d.ts

@@ -0,0 +1,93 @@
+import { Env } from "../../0d45f5fd/93c2615f.js";
+import { FileAccess, FileEntity, FileStorageType } from "../../2cc49785/e8dcc4f1.js";
+import { DataSource } from "typeorm";
+import { S3Client } from "@aws-sdk/client-s3";
+import { BuiltinLogger } from "../../abe2c417/7e2c18ef.js";
+/**
+ * Service responsible for managing file storage, metadata, and access security.
+ *
+ * The `FileService` provides a unified interface for handling digital assets,
+ * supporting:
+ * 1. **Hybrid Storage**: Seamlessly switching between local filesystem and
+ *    AWS S3 storage types based on configuration.
+ * 2. **Access Control**: Managing file visibility through public, private, or
+ *    role-specific access rules defined in the database.
+ * 3. **Secure Delivery**: Generating Pre-Signed URLs for temporary, secure
+ *    access to cloud-hosted assets.
+ * 4. **Cleanup**: Orchestrating the removal of both physical assets and their
+ *    associated database metadata.
+ */
+export declare class FileService {
+    private STORAGE_DIR;
+    constructor();
+    source: DataSource;
+    s3Client: S3Client;
+    env: Env;
+    logger: BuiltinLogger;
+    /**
+     * Get temporary directory path for uploads
+     */
+    getTempDir(): string;
+    /**
+     * Returns the configured root directory for local file storage.
+     * @returns The absolute or relative path to the storage folder.
+     */
+    getStorageDir(): string;
+    /**
+     * Save file metadata into DB + move to storage folder
+     */
+    addFile(options: {
+        tempFilePath: string;
+        originalName: string;
+        mimeType: string;
+        metadata: Record<string, any>;
+        creatorId: number;
+        type: FileStorageType;
+        fileAccess: FileAccess;
+        accessRole: number[];
+        compression?: number;
+    }): Promise<FileEntity>;
+    /**
+     * Retrieves file metadata from the database using its unique identifier (filename).
+     *
+     * @param filename - The unique storage filename to look up.
+     * @returns The file entity with populated relations for access control.
+     */
+    findFile(filename: string): Promise<FileEntity | null>;
+    /**
+     * Atomically deletes a file from physical storage and removes its database record.
+     *
+     * @param id - The numeric ID of the file record to delete.
+     * @throws Error if the file record does not exist.
+     */
+    deleteFile(id: number): Promise<void>;
+    /**
+     * Returns a paginated list of all stored files.
+     *
+     * @param skip - Number of records to skip.
+     * @param limit - Maximum number of records to return.
+     */
+    getFiles(skip: number, limit: number): Promise<FileEntity[]>;
+    private get repo();
+    /**
+     * Generates a stable key (path) for storing an object in S3.
+     * @param filename - The filename to transform into an S3 key.
+     */
+    private generateS3Key;
+    /**
+     * Helper method to stream a local file to the configured S3 bucket.
+     *
+     * @param localFile - Absolute path to the source file on the local disk.
+     * @param key - The destination key (path) in the S3 bucket.
+     */
+    private uploadToS3;
+    /**
+     * Generates a time-limited, pre-signed URL for temporary access to a private S3 object.
+     *
+     * @param file - The unique filename of the object.
+     * @param expiresInSeconds - How long the URL remains valid (e.g., 3600 for 1 hour).
+     * @param mimeType - The content type to be set in the response headers.
+     * @returns A fully qualified URL for secure object retrieval.
+     */
+    generatePreSignedUrl(file: string, expiresInSeconds: number, mimeType: string): Promise<string>;
+}

package/dist/types/2ad56231/3b9c358f/8e609bb7.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/2ad56231/466e5b9c/b9f2cf40.d.ts

@@ -0,0 +1,12 @@
+import { RequestedUser } from "../../0d45f5fd/4b41f653.js";
+import { RequestDto, ResponseDto } from "../../9477dda6/a68fa9aa.js";
+import { CreateCurrencyDto, UpdateCurrencyDto } from "./cf4df18c.js";
+import { CurrencyService } from "./ba999e69.js";
+export declare class CurrencyController {
+    service: CurrencyService;
+    getCurrency(skip: number, limit: number): Promise<ResponseDto<import("../../index.js").CurrencyEntity[]>>;
+    update(id: number, body: RequestDto<UpdateCurrencyDto>, user: RequestedUser): Promise<ResponseDto<null>>;
+    getById(id: number): Promise<ResponseDto<import("../../index.js").CurrencyEntity | null>>;
+    create(body: RequestDto<CreateCurrencyDto>, user: RequestedUser): Promise<ResponseDto<null>>;
+    deleteCurrency(id: number): Promise<ResponseDto<null>>;
+}

package/dist/types/2ad56231/466e5b9c/ba999e69.d.ts

@@ -0,0 +1,63 @@
+import { DataSource } from "typeorm";
+import { CurrencyEntity } from "../../2cc49785/35b9365a.js";
+import { CreateCurrencyDto } from "./cf4df18c.js";
+import { ChangeLogService } from "../7f9ba364/e4ec6555.js";
+import { CreateServiceProps, OptionalCreatedByUser } from "../../abe2c417/8f79089f.js";
+import { DeveloperConfigService } from "../01dcea55/0a5f3cca.js";
+/**
+ * Service responsible for managing system-wide currencies.
+ *
+ * This service handles the lifecycle of currency definitions used across the
+ * Quan ERP financial modules. It ensures data consistency by:
+ * 1. **Limit Enforcement**: Validating the total number of currencies against
+ *    the `MAX_CURRENCY_LIMIT` defined in the developer configuration.
+ * 2. **Auditability**: Automatically logging every creation and update event
+ *    to the `ChangeLogService`, including property-level diffs for updates.
+ * 3. **Transactional Safety**: Using database transactions to ensure that
+ *    configuration checks and records are atomic.
+ */
+export declare class CurrencyService {
+    source: DataSource;
+    changeLogService: ChangeLogService;
+    developerConfigService: DeveloperConfigService;
+    get repo(): import("typeorm").Repository<CurrencyEntity>;
+    /**
+     * Calculates the total number of currencies defined in the system.
+     * @param props - Optional execution context (manager).
+     */
+    private countTotalCurrency;
+    /**
+     * Atomically creates or updates a currency entity, enforcing system limits.
+     *
+     * @param params - The currency metadata to persist.
+     * @throws Error if the MAX_CURRENCY_LIMIT defined in developer config is exceeded.
+     */
+    create(params: CreateServiceProps<CreateCurrencyDto & OptionalCreatedByUser>): Promise<void>;
+    /**
+     * Retrieves a paginated list of all system currencies.
+     *
+     * @param skip - Pagination offset.
+     * @param limit - Max records to return.
+     */
+    get(skip: number, limit: number): Promise<CurrencyEntity[]>;
+    /**
+     * Finds a specific currency by its symbol (e.g., 'USD').
+     */
+    findBySymbol(symbol: string): Promise<CurrencyEntity | null>;
+    /**
+     * Finds a specific currency by its unique primary key.
+     */
+    getById(id: number): Promise<CurrencyEntity | null>;
+    /**
+     * Updates an existing currency's metadata and records the change in the audit log.
+     *
+     * @param id - The ID of the currency to update.
+     * @param currency - The new currency metadata.
+     * @param updateByUserId - The ID of the user performing the update.
+     */
+    update(id: number, currency: CreateCurrencyDto, updateByUserId?: number): Promise<void>;
+    /**
+     * Permanently removes a currency from the system.
+     */
+    delete(id: number): Promise<import("typeorm").DeleteResult>;
+}

package/dist/types/2ad56231/466e5b9c/cf4df18c.d.ts

@@ -0,0 +1,19 @@
+export interface CreateCurrencyDto {
+    currency: string;
+    symbol: string;
+    code: string;
+    decimalPlace: number;
+}
+export interface UpdateCurrencyDto {
+    currency: string;
+    symbol: string;
+    code: string;
+    decimalPlace: number;
+}
+export interface CurrencyDto {
+    id: number;
+    currency: string;
+    symbol: string;
+    code: string;
+    decimalPlace: number;
+}

package/dist/types/2ad56231/517bc292.d.ts

@@ -0,0 +1,4 @@
+export declare const OWNER_UESR_ID = 1;
+export declare const OWNER_ROLE_ID = 1;
+export declare const BUILTIN_PLUGIN_NAME = "builtin";
+export declare const BUILTIN_VERSION = "1.0.0-beta.45";

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

@@ -0,0 +1,43 @@
+import { DataSource } from "typeorm";
+import { PartnerShippingAddressEntity } from "../../2cc49785/5b00ec2d.js";
+import { CreatePartnerShippingAddressDto, UpdatePartnerShippingAddressDto } from "./c766feba.js";
+import { CreateServiceProps, DeleteByIdServiceProps, UpdateByIdServiceProps } from "../../abe2c417/8f79089f.js";
+/**
+ * Service responsible for managing shipping addresses associated with partners.
+ *
+ * This service handles the logistical metadata for business entities
+ * (customers, vendors), allowing the system to track multiple delivery
+ * locations per partner. It ensures that addresses are correctly bound
+ * to active partners and supports soft-deletion for historical record integrity.
+ */
+export declare class PartnerShippingAddressService {
+    source: DataSource;
+    /**
+     * Creates and binds a new shipping address to a specific business partner.
+     *
+     * @param props - Includes the address details, target partner ID, and optional transaction manager.
+     * @throws Error if the target partner does not exist.
+     */
+    create(props: CreateServiceProps<CreatePartnerShippingAddressDto>): Promise<PartnerShippingAddressEntity>;
+    /**
+     * Updates an existing shipping address record.
+     *
+     * @param props - Includes the address ID, update data, and optional transaction manager.
+     */
+    update(props: UpdateByIdServiceProps<UpdatePartnerShippingAddressDto>): Promise<void>;
+    /**
+     * Soft-deletes a shipping address record from the system.
+     *
+     * @param props - Includes the numeric ID of the address and optional transaction manager.
+     * @throws Error if the address is not found or does not belong to a partner.
+     */
+    delete(props: DeleteByIdServiceProps): Promise<void>;
+    /**
+     * Retrieves all active shipping addresses for a specific partner.
+     *
+     * @param id - The ID of the business partner.
+     * @param skip - Pagination offset.
+     * @param limit - Maximum records per page.
+     */
+    findByPartnerId(id: number, skip: number, limit: number): Promise<PartnerShippingAddressEntity[]>;
+}