@eleva-io/erp-sdk 0.1.155 → 0.1.156

package/dist/cjs/package.json

@@ -0,0 +1,70 @@
+{
+    "name": "@eleva-io/erp-sdk",
+    "version": "0.1.155",
+    "description": "SDK oficial para el ERP de Eleva",
+    "main": "dist/cjs/index.js",
+    "module": "dist/esm/index.js",
+    "types": "dist/cjs/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/esm/index.js",
+            "require": "./dist/cjs/index.js",
+            "types": "./dist/cjs/index.d.ts"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "pnpm build:cjs && pnpm build:esm",
+        "build:cjs": "tsc --project tsconfig.cjs.json",
+        "build:esm": "tsc --project tsconfig.esm.json",
+        "test": "jest --config ./jest.config.ts",
+        "lint": "eslint 'src/**/*.{ts,tsx}' --fix",
+        "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+        "sandbox": "tsx sandbox/index.ts",
+        "sandbox:watch": "tsx watch sandbox/index.ts"
+    },
+    "keywords": [
+        "eleva",
+        "erp",
+        "sdk",
+        "proptech"
+    ],
+    "author": "Eleva",
+    "license": "MIT",
+    "devDependencies": {
+        "@types/jest": "30.0.0",
+        "@types/mime-types": "3.0.1",
+        "@types/node": "^20.19.41",
+        "@typescript-eslint/eslint-plugin": "8.35.0",
+        "@typescript-eslint/parser": "8.35.0",
+        "dotenv": "^16.6.1",
+        "eslint": "9.29.0",
+        "eslint-config-prettier": "10.1.5",
+        "eslint-plugin-jest": "29.0.1",
+        "eslint-plugin-prettier": "5.5.1",
+        "jest": "30.0.3",
+        "prettier": "3.6.1",
+        "ts-jest": "29.4.0",
+        "ts-node": "10.9.2",
+        "tsx": "^4.21.0",
+        "typescript": "^5.9.3"
+    },
+    "dependencies": {
+        "@eslint/eslintrc": "3.3.1",
+        "@eslint/js": "9.29.0",
+        "ibantools": "4.5.1",
+        "moment": "2.30.1",
+        "mrmime": "2.0.1",
+        "pino": "9.7.0",
+        "zod": "^3.25.76"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "engines": {
+        "node": ">=16",
+        "pnpm": ">=8"
+    }
+}

package/dist/cjs/src/erp.d.ts

@@ -0,0 +1,40 @@
+import { Logger as PinoLogger } from 'pino';
+import { HTTPClientConfig } from './utils/http';
+import { HorizontalAPI } from './modules/horizontal';
+import { TicketingAPI } from './modules/ticketing';
+import { ContactsAPI } from './modules/contacts/api';
+import { GlobalAPI } from './modules/global/api';
+import { DomainAPI } from './modules/domain/api';
+import { BankAccountsAPI } from './modules/bank_accounts';
+import { TagsAPI } from './modules/tags';
+/**
+ * Configuration options for the logger
+ */
+export interface LoggerConfig {
+    /**
+     * A custom logger instance to use instead of creating a new one.
+     */
+    instance?: PinoLogger;
+    /**
+     * The logging level to use. Only used when instance is undefined.
+     * Defaults to 'info' if not specified.
+     * Valid values are: 'fatal', 'error', 'warn', 'info', 'debug', 'trace'
+     */
+    level?: string;
+}
+export type ERPClientConfig = HTTPClientConfig & {
+    logger?: LoggerConfig;
+};
+export declare class ERPClient {
+    private readonly _baseUrl;
+    private readonly _httpClient;
+    constructor(config: ERPClientConfig);
+    domain(): DomainAPI;
+    global(): GlobalAPI;
+    contacts(): ContactsAPI;
+    horizontal(): HorizontalAPI;
+    ticketing(): TicketingAPI;
+    bankAccounts(): BankAccountsAPI;
+    tags(id?: string): TagsAPI;
+}
+//# sourceMappingURL=erp.d.ts.map

package/dist/cjs/src/erp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erp.d.ts","sourceRoot":"","sources":["../../../src/erp.ts"],"names":[],"mappings":"AAAA,OAAa,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,MAAM,CAAA;AACjD,OAAO,EAAc,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAExC;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,QAAQ,CAAC,EAAE,UAAU,CAAA;IAErB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,MAAM,eAAe,GAAG,gBAAgB,GAAG;IAC/C,MAAM,CAAC,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAE7C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAY;gBAE5B,MAAM,EAAE,eAAe;IA0BnC,MAAM,IAAI,SAAS;IAInB,MAAM,IAAI,SAAS;IAInB,QAAQ,IAAI,WAAW;IAIvB,UAAU,IAAI,aAAa;IAI3B,SAAS,IAAI,YAAY;IAIzB,YAAY,IAAI,eAAe;IAI/B,IAAI,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;CAG3B"}

package/dist/cjs/src/erp.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERPClient = void 0;
+const pino_1 = __importDefault(require("pino"));
+const http_1 = require("./utils/http");
+const horizontal_1 = require("./modules/horizontal");
+const ticketing_1 = require("./modules/ticketing");
+const api_1 = require("./modules/contacts/api");
+const api_2 = require("./modules/global/api");
+const api_3 = require("./modules/domain/api");
+const bank_accounts_1 = require("./modules/bank_accounts");
+const tags_1 = require("./modules/tags");
+class ERPClient {
+    _baseUrl = '/api/v1';
+    _httpClient;
+    constructor(config) {
+        if (!config.baseURL) {
+            throw new Error('Missing required baseURL configuration');
+        }
+        if ('token' in config) {
+            if (!config.token) {
+                throw new Error('Token is required when using token authentication');
+            }
+        }
+        else {
+            if (!config.apiKey || !config.apiSecret) {
+                throw new Error('API key and secret are required when using API key authentication');
+            }
+        }
+        let logger = config.logger?.instance;
+        if (!logger) {
+            logger = (0, pino_1.default)();
+            logger.level = config.logger?.level || 'info';
+        }
+        logger = logger.child({ client: 'eleva-erp' });
+        this._httpClient = new http_1.HTTPClient(config, logger);
+    }
+    domain() {
+        return new api_3.DomainAPI(this._httpClient, this._baseUrl); // TODO: auth http client
+    }
+    global() {
+        return new api_2.GlobalAPI(this._httpClient, this._baseUrl);
+    }
+    contacts() {
+        return new api_1.ContactsAPI(this._httpClient, this._baseUrl);
+    }
+    horizontal() {
+        return new horizontal_1.HorizontalAPI(this._httpClient, this._baseUrl);
+    }
+    ticketing() {
+        return new ticketing_1.TicketingAPI(this._httpClient, this._baseUrl);
+    }
+    bankAccounts() {
+        return new bank_accounts_1.BankAccountsAPI(this._httpClient, this._baseUrl);
+    }
+    tags(id) {
+        return new tags_1.TagsAPI(this._httpClient, this._baseUrl, id);
+    }
+}
+exports.ERPClient = ERPClient;
+//# sourceMappingURL=erp.js.map

package/dist/cjs/src/erp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"erp.js","sourceRoot":"","sources":["../../../src/erp.ts"],"names":[],"mappings":";;;;;;AAAA,gDAAiD;AACjD,uCAA2D;AAC3D,qDAAoD;AACpD,mDAAkD;AAClD,gDAAoD;AACpD,8CAAgD;AAChD,8CAAgD;AAChD,2DAAyD;AACzD,yCAAwC;AAuBxC,MAAa,SAAS;IACH,QAAQ,GAAW,SAAS,CAAA;IAE5B,WAAW,CAAY;IAExC,YAAY,MAAuB;QACjC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA;QAC3D,CAAC;QAED,IAAI,OAAO,IAAI,MAAM,EAAE,CAAC;YACtB,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;gBAClB,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAA;YACtE,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;gBACxC,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAA;YACtF,CAAC;QACH,CAAC;QAED,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAA;QACpC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,GAAG,IAAA,cAAI,GAAE,CAAA;YACf,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,IAAI,MAAM,CAAA;QAC/C,CAAC;QAED,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,CAAA;QAE9C,IAAI,CAAC,WAAW,GAAG,IAAI,iBAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnD,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,eAAS,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA,CAAC,yBAAyB;IACjF,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,eAAS,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;IACvD,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,iBAAW,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;IACzD,CAAC;IAED,UAAU;QACR,OAAO,IAAI,0BAAa,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;IAC3D,CAAC;IAED,SAAS;QACP,OAAO,IAAI,wBAAY,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;IAC1D,CAAC;IAED,YAAY;QACV,OAAO,IAAI,+BAAe,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;IAC7D,CAAC;IAED,IAAI,CAAC,EAAW;QACd,OAAO,IAAI,cAAO,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAA;IACzD,CAAC;CACF;AA1DD,8BA0DC"}

package/dist/cjs/src/errors/catalog.d.ts

@@ -0,0 +1,339 @@
+import { API_ERROR_CODES } from './catalog_api';
+import { BASE_ERROR_CODES } from './catalog_base';
+import { CatalogDetails } from './catalog_types';
+/** All valid error code constants (base + API). Use with `error.is()` and factory methods. */
+export declare const ERROR_CODES: {
+    FORBIDDEN_CONTACT: API_ERROR_CODES.FORBIDDEN_CONTACT;
+    HORIZONTAL_BULK_MESSAGING_ATTACHMENTS_TOO_LARGE: API_ERROR_CODES.HORIZONTAL_BULK_MESSAGING_ATTACHMENTS_TOO_LARGE;
+    HORIZONTAL_CLAIM_POLICY_COMMUNITY_MISMATCH: API_ERROR_CODES.HORIZONTAL_CLAIM_POLICY_COMMUNITY_MISMATCH;
+    HORIZONTAL_CLAIM_CONTACT_ALREADY_LINKED: API_ERROR_CODES.HORIZONTAL_CLAIM_CONTACT_ALREADY_LINKED;
+    HORIZONTAL_CLAIM_CLOSED_BEFORE_OPENED: API_ERROR_CODES.HORIZONTAL_CLAIM_CLOSED_BEFORE_OPENED;
+    TICKETING_TASK_CLAIM_SUBREF_NOT_ALLOWED: API_ERROR_CODES.TICKETING_TASK_CLAIM_SUBREF_NOT_ALLOWED;
+    TICKETING_TASK_CLAIM_ALREADY_ASSOCIATED: API_ERROR_CODES.TICKETING_TASK_CLAIM_ALREADY_ASSOCIATED;
+    VALIDATION: BASE_ERROR_CODES.VALIDATION;
+    BAD_REQUEST: BASE_ERROR_CODES.BAD_REQUEST;
+    AUTHENTICATION: BASE_ERROR_CODES.AUTHENTICATION;
+    UNAUTHORIZED: BASE_ERROR_CODES.UNAUTHORIZED;
+    NOT_FOUND: BASE_ERROR_CODES.NOT_FOUND;
+    NOT_ACCEPTABLE: BASE_ERROR_CODES.NOT_ACCEPTABLE;
+    CONFLICT: BASE_ERROR_CODES.CONFLICT;
+    GONE: BASE_ERROR_CODES.GONE;
+    UNPROCESSABLE_ENTITY: BASE_ERROR_CODES.UNPROCESSABLE_ENTITY;
+    MANDATORY_FIELD: BASE_ERROR_CODES.MANDATORY_FIELD;
+    INTERNAL_SERVER_ERROR: BASE_ERROR_CODES.INTERNAL_SERVER_ERROR;
+    BAD_GATEWAY: BASE_ERROR_CODES.BAD_GATEWAY;
+    SERVICE_UNAVAILABLE: BASE_ERROR_CODES.SERVICE_UNAVAILABLE;
+};
+/** Union of all valid error code strings. Derived from `ERROR_CODES` to stay in sync. */
+export type ErrorCode = keyof typeof ERROR_CODES;
+/**
+ * Strongly-typed `details` payload for a given error code `C`, resolved directly
+ * from `ERRORS_CATALOG`. Adding a new catalog only requires updating `ERRORS_CATALOG`.
+ *
+ * @example
+ * type ValidationDetails = ErrorDetails<'VALIDATION'>
+ * // → { errors: Array<{ validation: string; code: string; message: string; path: string[] }> }
+ */
+export type ErrorDetails<C extends ErrorCode> = CatalogDetails<C, typeof ERRORS_CATALOG>;
+/** Merged catalog of all error codes. Single runtime lookup table for `ElevaError` construction. */
+export declare const ERRORS_CATALOG: {
+    FORBIDDEN_CONTACT: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            contactId: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            contactId: string;
+        }, {
+            contactId: string;
+        }>;
+        message: string;
+    };
+    HORIZONTAL_BULK_MESSAGING_ATTACHMENTS_TOO_LARGE: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            maxBytes: import("zod").ZodNumber;
+            totalBytes: import("zod").ZodNumber;
+        }, "strip", import("zod").ZodTypeAny, {
+            maxBytes: number;
+            totalBytes: number;
+        }, {
+            maxBytes: number;
+            totalBytes: number;
+        }>;
+        message: string;
+    };
+    HORIZONTAL_CLAIM_POLICY_COMMUNITY_MISMATCH: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            policyId: import("zod").ZodString;
+            communityId: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            policyId: string;
+            communityId: string;
+        }, {
+            policyId: string;
+            communityId: string;
+        }>;
+        message: string;
+    };
+    HORIZONTAL_CLAIM_CONTACT_ALREADY_LINKED: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            claimId: import("zod").ZodString;
+            contactId: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            contactId: string;
+            claimId: string;
+        }, {
+            contactId: string;
+            claimId: string;
+        }>;
+        message: string;
+    };
+    HORIZONTAL_CLAIM_CLOSED_BEFORE_OPENED: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            openedAt: import("zod").ZodString;
+            closedAt: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            openedAt: string;
+            closedAt: string;
+        }, {
+            openedAt: string;
+            closedAt: string;
+        }>;
+        message: string;
+    };
+    TICKETING_TASK_CLAIM_SUBREF_NOT_ALLOWED: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            taskId: import("zod").ZodString;
+            refId: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            taskId: string;
+            refId: string;
+        }, {
+            taskId: string;
+            refId: string;
+        }>;
+        message: string;
+    };
+    TICKETING_TASK_CLAIM_ALREADY_ASSOCIATED: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            taskId: import("zod").ZodString;
+            refId: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            taskId: string;
+            refId: string;
+        }, {
+            taskId: string;
+            refId: string;
+        }>;
+        message: string;
+    };
+    VALIDATION: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            errors: import("zod").ZodArray<import("zod").ZodObject<{
+                validation: import("zod").ZodString;
+                code: import("zod").ZodString;
+                message: import("zod").ZodString;
+                path: import("zod").ZodArray<import("zod").ZodString, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                code: string;
+                message: string;
+                path: string[];
+                validation: string;
+            }, {
+                code: string;
+                message: string;
+                path: string[];
+                validation: string;
+            }>, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            errors: {
+                code: string;
+                message: string;
+                path: string[];
+                validation: string;
+            }[];
+        }, {
+            errors: {
+                code: string;
+                message: string;
+                path: string[];
+                validation: string;
+            }[];
+        }>;
+        message: string;
+    };
+    BAD_REQUEST: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            field: import("zod").ZodOptional<import("zod").ZodString>;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            field?: string | undefined;
+            reason?: string | undefined;
+        }, {
+            field?: string | undefined;
+            reason?: string | undefined;
+        }>;
+        message: string;
+    };
+    AUTHENTICATION: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            reason?: string | undefined;
+        }, {
+            reason?: string | undefined;
+        }>;
+        message: string;
+    };
+    UNAUTHORIZED: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            requiredScope: import("zod").ZodOptional<import("zod").ZodString>;
+            resource: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            requiredScope?: string | undefined;
+            resource?: string | undefined;
+        }, {
+            requiredScope?: string | undefined;
+            resource?: string | undefined;
+        }>;
+        message: string;
+    };
+    NOT_FOUND: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            entity: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            entity?: string | undefined;
+        }, {
+            entity?: string | undefined;
+        }>;
+        message: string;
+    };
+    NOT_ACCEPTABLE: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            acceptedTypes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, "strip", import("zod").ZodTypeAny, {
+            acceptedTypes?: string[] | undefined;
+        }, {
+            acceptedTypes?: string[] | undefined;
+        }>;
+        message: string;
+    };
+    CONFLICT: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodArray<import("zod").ZodObject<{
+            key: import("zod").ZodString;
+            value: import("zod").ZodString;
+            cause: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            value: string;
+            key: string;
+            cause: string;
+        }, {
+            value: string;
+            key: string;
+            cause: string;
+        }>, "many">;
+        message: string;
+    };
+    GONE: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            since: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            since?: string | undefined;
+        }, {
+            since?: string | undefined;
+        }>;
+        message: string;
+    };
+    UNPROCESSABLE_ENTITY: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            field: import("zod").ZodOptional<import("zod").ZodString>;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            field?: string | undefined;
+            reason?: string | undefined;
+        }, {
+            field?: string | undefined;
+            reason?: string | undefined;
+        }>;
+        message: string;
+    };
+    MANDATORY_FIELD: {
+        kind: import("./catalog_types").ErrorKind.DOMAIN;
+        status: number;
+        details: import("zod").ZodObject<{
+            field: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            field: string;
+        }, {
+            field: string;
+        }>;
+        message: string;
+    };
+    INTERNAL_SERVER_ERROR: {
+        kind: import("./catalog_types").ErrorKind.SYSTEM;
+        status: number;
+        details: import("zod").ZodObject<{
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            reason?: string | undefined;
+        }, {
+            reason?: string | undefined;
+        }>;
+        message: string;
+    };
+    BAD_GATEWAY: {
+        kind: import("./catalog_types").ErrorKind.SYSTEM;
+        status: number;
+        details: import("zod").ZodObject<{
+            upstream: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            upstream?: string | undefined;
+        }, {
+            upstream?: string | undefined;
+        }>;
+        message: string;
+    };
+    SERVICE_UNAVAILABLE: {
+        kind: import("./catalog_types").ErrorKind.SYSTEM;
+        status: number;
+        details: import("zod").ZodObject<{
+            retryAfter: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            retryAfter?: number | undefined;
+        }, {
+            retryAfter?: number | undefined;
+        }>;
+        message: string;
+    };
+};
+//# sourceMappingURL=catalog.d.ts.map

package/dist/cjs/src/errors/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../../src/errors/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAsB,MAAM,eAAe,CAAA;AACnE,OAAO,EAAE,gBAAgB,EAAuB,MAAM,gBAAgB,CAAA;AACtE,OAAO,EAAE,cAAc,EAAqB,MAAM,iBAAiB,CAAA;AAEnE,8FAA8F;AAC9F,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;CAGvB,CAAA;AAED,yFAAyF;AACzF,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,WAAW,CAAA;AAEhD;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,SAAS,IAAI,cAAc,CAAC,CAAC,EAAE,OAAO,cAAc,CAAC,CAAA;AAExF,oGAAoG;AACpG,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGqB,CAAA"}

package/dist/cjs/src/errors/catalog.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERRORS_CATALOG = exports.ERROR_CODES = void 0;
+const catalog_api_1 = require("./catalog_api");
+const catalog_base_1 = require("./catalog_base");
+/** All valid error code constants (base + API). Use with `error.is()` and factory methods. */
+exports.ERROR_CODES = {
+    ...catalog_base_1.BASE_ERROR_CODES,
+    ...catalog_api_1.API_ERROR_CODES,
+};
+/** Merged catalog of all error codes. Single runtime lookup table for `ElevaError` construction. */
+exports.ERRORS_CATALOG = {
+    ...catalog_base_1.BASE_ERRORS_CATALOG,
+    ...catalog_api_1.API_ERRORS_CATALOG,
+};
+//# sourceMappingURL=catalog.js.map

package/dist/cjs/src/errors/catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.js","sourceRoot":"","sources":["../../../../src/errors/catalog.ts"],"names":[],"mappings":";;;AAAA,+CAAmE;AACnE,iDAAsE;AAGtE,8FAA8F;AACjF,QAAA,WAAW,GAAG;IACzB,GAAG,+BAAgB;IACnB,GAAG,6BAAe;CACnB,CAAA;AAeD,oGAAoG;AACvF,QAAA,cAAc,GAAG;IAC5B,GAAG,kCAAmB;IACtB,GAAG,gCAAkB;CACyB,CAAA"}

package/dist/cjs/src/errors/catalog_api.d.ts

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+import { CatalogDetails, ErrorKind } from './catalog_types';
+/**
+ * ERP domain-specific error codes. Add here any code that does not fit
+ * the generic HTTP categories in `BASE_ERROR_CODES`.
+ */
+export declare enum API_ERROR_CODES {
+    FORBIDDEN_CONTACT = "FORBIDDEN_CONTACT",
+    HORIZONTAL_BULK_MESSAGING_ATTACHMENTS_TOO_LARGE = "HORIZONTAL_BULK_MESSAGING_ATTACHMENTS_TOO_LARGE",
+    HORIZONTAL_CLAIM_POLICY_COMMUNITY_MISMATCH = "HORIZONTAL_CLAIM_POLICY_COMMUNITY_MISMATCH",
+    HORIZONTAL_CLAIM_CONTACT_ALREADY_LINKED = "HORIZONTAL_CLAIM_CONTACT_ALREADY_LINKED",
+    HORIZONTAL_CLAIM_CLOSED_BEFORE_OPENED = "HORIZONTAL_CLAIM_CLOSED_BEFORE_OPENED",
+    TICKETING_TASK_CLAIM_SUBREF_NOT_ALLOWED = "TICKETING_TASK_CLAIM_SUBREF_NOT_ALLOWED",
+    TICKETING_TASK_CLAIM_ALREADY_ASSOCIATED = "TICKETING_TASK_CLAIM_ALREADY_ASSOCIATED"
+}
+/** Maps every `API_ERROR_CODES` member to its catalog entry. */
+export declare const API_ERRORS_CATALOG: {
+    FORBIDDEN_CONTACT: {
+        kind: ErrorKind.DOMAIN;
+        status: number;
+        details: z.ZodObject<{
+            /** UUID of the contact person the caller was denied access to. */
+            contactId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            contactId: string;
+        }, {
+            contactId: string;
+        }>;
+        message: string;
+    };
+    HORIZONTAL_BULK_MESSAGING_ATTACHMENTS_TOO_LARGE: {
+        kind: ErrorKind.DOMAIN;
+        status: number;
+        details: z.ZodObject<{
+            /** Maximum total size allowed for all attachments, in bytes. */
+            maxBytes: z.ZodNumber;
+            /** Total size of the submitted attachments, in bytes. */
+            totalBytes: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            maxBytes: number;
+            totalBytes: number;
+        }, {
+            maxBytes: number;
+            totalBytes: number;
+        }>;
+        message: string;
+    };
+    HORIZONTAL_CLAIM_POLICY_COMMUNITY_MISMATCH: {
+        kind: ErrorKind.DOMAIN;
+        status: number;
+        details: z.ZodObject<{
+            policyId: z.ZodString;
+            communityId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            policyId: string;
+            communityId: string;
+        }, {
+            policyId: string;
+            communityId: string;
+        }>;
+        message: string;
+    };
+    HORIZONTAL_CLAIM_CONTACT_ALREADY_LINKED: {
+        kind: ErrorKind.DOMAIN;
+        status: number;
+        details: z.ZodObject<{
+            claimId: z.ZodString;
+            contactId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            contactId: string;
+            claimId: string;
+        }, {
+            contactId: string;
+            claimId: string;
+        }>;
+        message: string;
+    };
+    HORIZONTAL_CLAIM_CLOSED_BEFORE_OPENED: {
+        kind: ErrorKind.DOMAIN;
+        status: number;
+        details: z.ZodObject<{
+            openedAt: z.ZodString;
+            closedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            openedAt: string;
+            closedAt: string;
+        }, {
+            openedAt: string;
+            closedAt: string;
+        }>;
+        message: string;
+    };
+    TICKETING_TASK_CLAIM_SUBREF_NOT_ALLOWED: {
+        kind: ErrorKind.DOMAIN;
+        status: number;
+        details: z.ZodObject<{
+            taskId: z.ZodString;
+            refId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            taskId: string;
+            refId: string;
+        }, {
+            taskId: string;
+            refId: string;
+        }>;
+        message: string;
+    };
+    TICKETING_TASK_CLAIM_ALREADY_ASSOCIATED: {
+        kind: ErrorKind.DOMAIN;
+        status: number;
+        details: z.ZodObject<{
+            taskId: z.ZodString;
+            refId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            taskId: string;
+            refId: string;
+        }, {
+            taskId: string;
+            refId: string;
+        }>;
+        message: string;
+    };
+};
+/**
+ * Strongly-typed `details` shape for a given `API_ERROR_CODES` member.
+ * @example
+ * type ForbiddenContactDetails = APIErrorDetails<API_ERROR_CODES.FORBIDDEN_CONTACT>
+ * // → { contactId: string }
+ */
+export type APIErrorDetails<C extends API_ERROR_CODES> = CatalogDetails<C, typeof API_ERRORS_CATALOG>;
+//# sourceMappingURL=catalog_api.d.ts.map