@gigapay-dev/contracts 1.8.6 → 3.0.0

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAahC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWf,CAAC;AACX,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC;AAE/C,MAAM,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC;AAC3C,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,SAAS,IAAI,MAAM,YAAY,CAAC,CAAC,CAAC,CAAC;AACrE,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,SAAS,EAAE,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/build/index.js

@@ -14,4 +14,38 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./commands"), exports);
+exports.AllEndpoints = void 0;
+__exportStar(require("./shared"), exports);
+__exportStar(require("./domains/auth"), exports);
+__exportStar(require("./domains/users"), exports);
+__exportStar(require("./domains/orders"), exports);
+__exportStar(require("./domains/catalog"), exports);
+__exportStar(require("./domains/products"), exports);
+__exportStar(require("./domains/payments"), exports);
+__exportStar(require("./domains/promo-codes"), exports);
+__exportStar(require("./domains/stats"), exports);
+__exportStar(require("./domains/config"), exports);
+__exportStar(require("./domains/admin"), exports);
+const auth_1 = require("./domains/auth");
+const users_1 = require("./domains/users");
+const orders_1 = require("./domains/orders");
+const catalog_1 = require("./domains/catalog");
+const products_1 = require("./domains/products");
+const payments_1 = require("./domains/payments");
+const promo_codes_1 = require("./domains/promo-codes");
+const stats_1 = require("./domains/stats");
+const config_1 = require("./domains/config");
+const admin_1 = require("./domains/admin");
+exports.AllEndpoints = {
+    auth: auth_1.AuthEndpoints,
+    users: users_1.UsersEndpoints,
+    orders: orders_1.OrderEndpoints,
+    catalog: catalog_1.CatalogEndpoints,
+    products: products_1.ProductEndpoints,
+    payments: payments_1.PaymentEndpoints,
+    promoCodes: promo_codes_1.PromoCodeEndpoints,
+    stats: stats_1.StatsEndpoints,
+    config: config_1.ConfigEndpoints,
+    admin: admin_1.AdminEndpoints,
+};
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,iDAA+B;AAC/B,kDAAgC;AAChC,mDAAiC;AACjC,oDAAkC;AAClC,qDAAmC;AACnC,qDAAmC;AACnC,wDAAsC;AACtC,kDAAgC;AAChC,mDAAiC;AACjC,kDAAgC;AAEhC,yCAA+C;AAC/C,2CAAiD;AACjD,6CAAkD;AAClD,+CAAqD;AACrD,iDAAsD;AACtD,iDAAsD;AACtD,uDAA2D;AAC3D,2CAAiD;AACjD,6CAAmD;AACnD,2CAAiD;AAEpC,QAAA,YAAY,GAAG;IAC3B,IAAI,EAAE,oBAAa;IACnB,KAAK,EAAE,sBAAc;IACrB,MAAM,EAAE,uBAAc;IACtB,OAAO,EAAE,0BAAgB;IACzB,QAAQ,EAAE,2BAAgB;IAC1B,QAAQ,EAAE,2BAAgB;IAC1B,UAAU,EAAE,gCAAkB;IAC9B,KAAK,EAAE,sBAAc;IACrB,MAAM,EAAE,wBAAe;IACvB,KAAK,EAAE,sBAAc;CACZ,CAAC"}

package/build/shared/api-response.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare function ApiResponseSchema<T extends z.ZodTypeAny>(dataSchema: T): z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: T;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ApiErrorSchema: z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ApiError = z.infer<typeof ApiErrorSchema>;
+//# sourceMappingURL=api-response.d.ts.map

package/build/shared/api-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-response.d.ts","sourceRoot":"","sources":["../../src/shared/api-response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,CAAC;;;;kBAMtE;AAED,eAAO,MAAM,cAAc;;;;;;;;iBAQzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/build/shared/api-response.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiErrorSchema = void 0;
+exports.ApiResponseSchema = ApiResponseSchema;
+const zod_1 = require("zod");
+function ApiResponseSchema(dataSchema) {
+    return zod_1.z.object({
+        ok: zod_1.z.literal(true),
+        data: dataSchema,
+        requestId: zod_1.z.string().optional(),
+    });
+}
+exports.ApiErrorSchema = zod_1.z.object({
+    ok: zod_1.z.literal(false),
+    error: zod_1.z.object({
+        code: zod_1.z.string(),
+        message: zod_1.z.string(),
+        details: zod_1.z.unknown().optional(),
+    }),
+    requestId: zod_1.z.string().optional(),
+});
+//# sourceMappingURL=api-response.js.map

package/build/shared/api-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-response.js","sourceRoot":"","sources":["../../src/shared/api-response.ts"],"names":[],"mappings":";;;AAEA,8CAMC;AARD,6BAAwB;AAExB,SAAgB,iBAAiB,CAAyB,UAAa;IACtE,OAAO,OAAC,CAAC,MAAM,CAAC;QACf,EAAE,EAAE,OAAC,CAAC,OAAO,CAAC,IAAI,CAAC;QACnB,IAAI,EAAE,UAAU;QAChB,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAChC,CAAC,CAAC;AACJ,CAAC;AAEY,QAAA,cAAc,GAAG,OAAC,CAAC,MAAM,CAAC;IACtC,EAAE,EAAE,OAAC,CAAC,OAAO,CAAC,KAAK,CAAC;IACpB,KAAK,EAAE,OAAC,CAAC,MAAM,CAAC;QACf,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;QAChB,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE;QACnB,OAAO,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;KAC/B,CAAC;IACF,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC"}

package/build/shared/common.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const IdParamSchema: z.ZodObject<{
+    id: z.ZodCoercedNumber<unknown>;
+}, z.core.$strip>;
+export type IdParam = z.infer<typeof IdParamSchema>;
+export declare const SlugParamSchema: z.ZodObject<{
+    slug: z.ZodString;
+}, z.core.$strip>;
+export type SlugParam = z.infer<typeof SlugParamSchema>;
+export declare const SuccessResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type SuccessResponse = z.infer<typeof SuccessResponseSchema>;
+//# sourceMappingURL=common.d.ts.map

package/build/shared/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/shared/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,aAAa;;iBAAuD,CAAC;AAClF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,eAAO,MAAM,eAAe;;iBAAgD,CAAC;AAC7E,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,qBAAqB;;iBAAoC,CAAC;AACvE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/build/shared/common.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuccessResponseSchema = exports.SlugParamSchema = exports.IdParamSchema = void 0;
+const zod_1 = require("zod");
+exports.IdParamSchema = zod_1.z.object({ id: zod_1.z.coerce.number().int().positive() });
+exports.SlugParamSchema = zod_1.z.object({ slug: zod_1.z.string().min(1).max(64) });
+exports.SuccessResponseSchema = zod_1.z.object({ ok: zod_1.z.literal(true) });
+//# sourceMappingURL=common.js.map

package/build/shared/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/shared/common.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,aAAa,GAAG,OAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,OAAC,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;AAGrE,QAAA,eAAe,GAAG,OAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AAGhE,QAAA,qBAAqB,GAAG,OAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,OAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC"}

package/build/shared/errors.d.ts

@@ -0,0 +1,34 @@
+export declare const ERROR_CODES: {
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly FORBIDDEN: "FORBIDDEN";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly CAPTCHA_REQUIRED: "CAPTCHA_REQUIRED";
+    readonly CAPTCHA_INVALID: "CAPTCHA_INVALID";
+    readonly RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED";
+    readonly IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT";
+    readonly USER_NOT_FOUND: "USER_NOT_FOUND";
+    readonly EMAIL_TAKEN: "EMAIL_TAKEN";
+    readonly INVALID_CREDENTIALS: "INVALID_CREDENTIALS";
+    readonly SESSION_EXPIRED: "SESSION_EXPIRED";
+    readonly TOTP_REQUIRED: "TOTP_REQUIRED";
+    readonly TOTP_INVALID: "TOTP_INVALID";
+    readonly PRODUCT_NOT_FOUND: "PRODUCT_NOT_FOUND";
+    readonly VARIANT_NOT_FOUND: "VARIANT_NOT_FOUND";
+    readonly PRODUCT_ALREADY_EXISTS: "PRODUCT_ALREADY_EXISTS";
+    readonly OUT_OF_STOCK: "OUT_OF_STOCK";
+    readonly ORDER_NOT_FOUND: "ORDER_NOT_FOUND";
+    readonly ORDER_FORBIDDEN: "ORDER_FORBIDDEN";
+    readonly PAYMENT_RATE_UNAVAILABLE: "PAYMENT_RATE_UNAVAILABLE";
+    readonly PAYMENT_PROVIDER_UNAVAILABLE: "PAYMENT_PROVIDER_UNAVAILABLE";
+    readonly WEBHOOK_SIGNATURE_INVALID: "WEBHOOK_SIGNATURE_INVALID";
+    readonly UNKNOWN_PAYMENT_STRATEGY: "UNKNOWN_PAYMENT_STRATEGY";
+    readonly PROMO_NOT_FOUND: "PROMO_NOT_FOUND";
+    readonly PROMO_EXPIRED: "PROMO_EXPIRED";
+    readonly PROMO_LIMIT_REACHED: "PROMO_LIMIT_REACHED";
+    readonly PROMO_BUDGET_EXCEEDED: "PROMO_BUDGET_EXCEEDED";
+    readonly CATALOG_NOT_FOUND: "CATALOG_NOT_FOUND";
+    readonly CATALOG_HAS_LINKED_NODES: "CATALOG_HAS_LINKED_NODES";
+};
+export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+//# sourceMappingURL=errors.d.ts.map

package/build/shared/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/shared/errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCd,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC"}

package/build/shared/errors.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_CODES = void 0;
+exports.ERROR_CODES = {
+    UNAUTHORIZED: "UNAUTHORIZED",
+    FORBIDDEN: "FORBIDDEN",
+    NOT_FOUND: "NOT_FOUND",
+    VALIDATION_ERROR: "VALIDATION_ERROR",
+    CAPTCHA_REQUIRED: "CAPTCHA_REQUIRED",
+    CAPTCHA_INVALID: "CAPTCHA_INVALID",
+    RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+    IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT",
+    USER_NOT_FOUND: "USER_NOT_FOUND",
+    EMAIL_TAKEN: "EMAIL_TAKEN",
+    INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
+    SESSION_EXPIRED: "SESSION_EXPIRED",
+    TOTP_REQUIRED: "TOTP_REQUIRED",
+    TOTP_INVALID: "TOTP_INVALID",
+    PRODUCT_NOT_FOUND: "PRODUCT_NOT_FOUND",
+    VARIANT_NOT_FOUND: "VARIANT_NOT_FOUND",
+    PRODUCT_ALREADY_EXISTS: "PRODUCT_ALREADY_EXISTS",
+    OUT_OF_STOCK: "OUT_OF_STOCK",
+    ORDER_NOT_FOUND: "ORDER_NOT_FOUND",
+    ORDER_FORBIDDEN: "ORDER_FORBIDDEN",
+    PAYMENT_RATE_UNAVAILABLE: "PAYMENT_RATE_UNAVAILABLE",
+    PAYMENT_PROVIDER_UNAVAILABLE: "PAYMENT_PROVIDER_UNAVAILABLE",
+    WEBHOOK_SIGNATURE_INVALID: "WEBHOOK_SIGNATURE_INVALID",
+    UNKNOWN_PAYMENT_STRATEGY: "UNKNOWN_PAYMENT_STRATEGY",
+    PROMO_NOT_FOUND: "PROMO_NOT_FOUND",
+    PROMO_EXPIRED: "PROMO_EXPIRED",
+    PROMO_LIMIT_REACHED: "PROMO_LIMIT_REACHED",
+    PROMO_BUDGET_EXCEEDED: "PROMO_BUDGET_EXCEEDED",
+    CATALOG_NOT_FOUND: "CATALOG_NOT_FOUND",
+    CATALOG_HAS_LINKED_NODES: "CATALOG_HAS_LINKED_NODES",
+};
+//# sourceMappingURL=errors.js.map

package/build/shared/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/shared/errors.ts"],"names":[],"mappings":";;;AAAa,QAAA,WAAW,GAAG;IAC1B,YAAY,EAAE,cAAc;IAC5B,SAAS,EAAE,WAAW;IACtB,SAAS,EAAE,WAAW;IACtB,gBAAgB,EAAE,kBAAkB;IACpC,gBAAgB,EAAE,kBAAkB;IACpC,eAAe,EAAE,iBAAiB;IAClC,mBAAmB,EAAE,qBAAqB;IAC1C,oBAAoB,EAAE,sBAAsB;IAE5C,cAAc,EAAE,gBAAgB;IAChC,WAAW,EAAE,aAAa;IAC1B,mBAAmB,EAAE,qBAAqB;IAC1C,eAAe,EAAE,iBAAiB;IAClC,aAAa,EAAE,eAAe;IAC9B,YAAY,EAAE,cAAc;IAE5B,iBAAiB,EAAE,mBAAmB;IACtC,iBAAiB,EAAE,mBAAmB;IACtC,sBAAsB,EAAE,wBAAwB;IAChD,YAAY,EAAE,cAAc;IAE5B,eAAe,EAAE,iBAAiB;IAClC,eAAe,EAAE,iBAAiB;IAElC,wBAAwB,EAAE,0BAA0B;IACpD,4BAA4B,EAAE,8BAA8B;IAC5D,yBAAyB,EAAE,2BAA2B;IACtD,wBAAwB,EAAE,0BAA0B;IAEpD,eAAe,EAAE,iBAAiB;IAClC,aAAa,EAAE,eAAe;IAC9B,mBAAmB,EAAE,qBAAqB;IAC1C,qBAAqB,EAAE,uBAAuB;IAE9C,iBAAiB,EAAE,mBAAmB;IACtC,wBAAwB,EAAE,0BAA0B;CAC3C,CAAC"}

package/build/shared/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types";
+export * from "./money";
+export * from "./pagination";
+export * from "./api-response";
+export * from "./common";
+export * from "./errors";
+//# sourceMappingURL=index.d.ts.map

package/build/shared/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/build/{commands/orders → shared}/index.js

@@ -14,9 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./enums"), exports);
-__exportStar(require("./create"), exports);
-__exportStar(require("./update"), exports);
-__exportStar(require("./read"), exports);
-__exportStar(require("./query"), exports);
-__exportStar(require("./endpoints"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./money"), exports);
+__exportStar(require("./pagination"), exports);
+__exportStar(require("./api-response"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./errors"), exports);
+//# sourceMappingURL=index.js.map

package/build/shared/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,0CAAwB;AACxB,+CAA6B;AAC7B,iDAA+B;AAC/B,2CAAyB;AACzB,2CAAyB"}

package/build/shared/money.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const CurrencySchema: z.ZodEnum<{
+    USD: "USD";
+    RUB: "RUB";
+    UAH: "UAH";
+}>;
+export type Currency = z.infer<typeof CurrencySchema>;
+export declare const MoneyAmountSchema: z.ZodString;
+export type MoneyAmount = z.infer<typeof MoneyAmountSchema>;
+export declare const MoneyTripletSchema: z.ZodObject<{
+    usd: z.ZodString;
+    rub: z.ZodString;
+    uah: z.ZodString;
+}, z.core.$strip>;
+export type MoneyTriplet = z.infer<typeof MoneyTripletSchema>;
+export declare const ExchangeRateSnapshotSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        dessly: "dessly";
+        cbr: "cbr";
+        nbu: "nbu";
+        cache: "cache";
+        fallback: "fallback";
+        mixed: "mixed";
+    }>;
+    fetchedAt: z.ZodString;
+    rates: z.ZodObject<{
+        usdRub: z.ZodString;
+        usdUah: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ExchangeRateSnapshot = z.infer<typeof ExchangeRateSnapshotSchema>;
+//# sourceMappingURL=money.d.ts.map

package/build/shared/money.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"money.d.ts","sourceRoot":"","sources":["../../src/shared/money.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;EAAgC,CAAC;AAC5D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,iBAAiB,aAA0F,CAAC;AACzH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;iBAOrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/build/shared/money.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExchangeRateSnapshotSchema = exports.MoneyTripletSchema = exports.MoneyAmountSchema = exports.CurrencySchema = void 0;
+const zod_1 = require("zod");
+exports.CurrencySchema = zod_1.z.enum(["USD", "RUB", "UAH"]);
+exports.MoneyAmountSchema = zod_1.z.string().regex(/^\d+(\.\d{1,8})?$/, "must be a decimal string with up to 8 decimals");
+exports.MoneyTripletSchema = zod_1.z.object({
+    usd: exports.MoneyAmountSchema,
+    rub: exports.MoneyAmountSchema,
+    uah: exports.MoneyAmountSchema,
+});
+exports.ExchangeRateSnapshotSchema = zod_1.z.object({
+    source: zod_1.z.enum(["dessly", "cbr", "nbu", "cache", "fallback", "mixed"]),
+    fetchedAt: zod_1.z.string(),
+    rates: zod_1.z.object({
+        usdRub: exports.MoneyAmountSchema,
+        usdUah: exports.MoneyAmountSchema,
+    }),
+});
+//# sourceMappingURL=money.js.map

package/build/shared/money.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"money.js","sourceRoot":"","sources":["../../src/shared/money.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,cAAc,GAAG,OAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAG/C,QAAA,iBAAiB,GAAG,OAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,mBAAmB,EAAE,gDAAgD,CAAC,CAAC;AAG5G,QAAA,kBAAkB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC1C,GAAG,EAAE,yBAAiB;IACtB,GAAG,EAAE,yBAAiB;IACtB,GAAG,EAAE,yBAAiB;CACtB,CAAC,CAAC;AAGU,QAAA,0BAA0B,GAAG,OAAC,CAAC,MAAM,CAAC;IAClD,MAAM,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IACtE,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE;IACrB,KAAK,EAAE,OAAC,CAAC,MAAM,CAAC;QACf,MAAM,EAAE,yBAAiB;QACzB,MAAM,EAAE,yBAAiB;KACzB,CAAC;CACF,CAAC,CAAC"}

package/build/shared/pagination.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare function PaginatedResponseSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
+    items: z.ZodArray<T>;
+    total: z.ZodNumber;
+    skip: z.ZodNumber;
+    take: z.ZodNumber;
+}, z.core.$strip>;
+export type PaginatedResponse<T> = {
+    items: T[];
+    total: number;
+    skip: number;
+    take: number;
+};
+export declare const PaginationQuerySchema: z.ZodObject<{
+    skip: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    take: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type PaginationQuery = z.infer<typeof PaginationQuerySchema>;
+export declare const SortQuerySchema: z.ZodObject<{
+    sortBy: z.ZodDefault<z.ZodString>;
+    sortDir: z.ZodDefault<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+}, z.core.$strip>;
+export type SortQuery = z.infer<typeof SortQuerySchema>;
+//# sourceMappingURL=pagination.d.ts.map

package/build/shared/pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../src/shared/pagination.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,CAAC;;;;;kBAO5E;AAED,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IAClC,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;iBAGhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,eAAe;;;;;;iBAG1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/build/shared/pagination.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortQuerySchema = exports.PaginationQuerySchema = void 0;
+exports.PaginatedResponseSchema = PaginatedResponseSchema;
+const zod_1 = require("zod");
+function PaginatedResponseSchema(itemSchema) {
+    return zod_1.z.object({
+        items: zod_1.z.array(itemSchema),
+        total: zod_1.z.number().int().nonnegative(),
+        skip: zod_1.z.number().int().nonnegative(),
+        take: zod_1.z.number().int().nonnegative(),
+    });
+}
+exports.PaginationQuerySchema = zod_1.z.object({
+    skip: zod_1.z.coerce.number().int().nonnegative().default(0),
+    take: zod_1.z.coerce.number().int().min(1).max(100).default(20),
+});
+exports.SortQuerySchema = zod_1.z.object({
+    sortBy: zod_1.z.string().default("createdAt"),
+    sortDir: zod_1.z.enum(["asc", "desc"]).default("desc"),
+});
+//# sourceMappingURL=pagination.js.map

package/build/shared/pagination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.js","sourceRoot":"","sources":["../../src/shared/pagination.ts"],"names":[],"mappings":";;;AAEA,0DAOC;AATD,6BAAwB;AAExB,SAAgB,uBAAuB,CAAyB,UAAa;IAC5E,OAAO,OAAC,CAAC,MAAM,CAAC;QACf,KAAK,EAAE,OAAC,CAAC,KAAK,CAAC,UAAU,CAAC;QAC1B,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;QACrC,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;QACpC,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;KACpC,CAAC,CAAC;AACJ,CAAC;AASY,QAAA,qBAAqB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC7C,IAAI,EAAE,OAAC,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IACtD,IAAI,EAAE,OAAC,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;CACzD,CAAC,CAAC;AAGU,QAAA,eAAe,GAAG,OAAC,CAAC,MAAM,CAAC;IACvC,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC;IACvC,OAAO,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;CAChD,CAAC,CAAC"}

package/build/shared/types.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export type RequestMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export type CaptchaAction = "order_create" | "login" | "register" | "forgot_password" | "promo_activate";
+export type RateLimitSpec = {
+    limit: number;
+    ttlSec: number;
+};
+export type EndpointContract<TRequest extends z.ZodTypeAny = z.ZodTypeAny, TResponse extends z.ZodTypeAny = z.ZodTypeAny, TParams extends z.ZodTypeAny = z.ZodTypeAny, TQuery extends z.ZodTypeAny = z.ZodTypeAny> = {
+    method: RequestMethod;
+    path: string;
+    request?: TRequest;
+    response?: TResponse;
+    params?: TParams;
+    query?: TQuery;
+    requiresAuth?: boolean;
+    requiresAdmin?: boolean;
+    requiresCaptcha?: CaptchaAction;
+    rateLimit?: RateLimitSpec;
+};
+//# sourceMappingURL=types.d.ts.map

package/build/shared/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/shared/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;AAExE,MAAM,MAAM,aAAa,GACtB,cAAc,GACd,OAAO,GACP,UAAU,GACV,iBAAiB,GACjB,gBAAgB,CAAC;AAEpB,MAAM,MAAM,aAAa,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,MAAM,MAAM,gBAAgB,CAC3B,QAAQ,SAAS,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,EAC5C,SAAS,SAAS,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,EAC7C,OAAO,SAAS,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,EAC3C,MAAM,SAAS,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,IACvC;IACH,MAAM,EAAE,aAAa,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,SAAS,CAAC,EAAE,aAAa,CAAC;CAC1B,CAAC"}

package/build/{types.js → shared/types.js}

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/build/shared/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/shared/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,17 +1,43 @@
 {
-  "name": "@gigapay-dev/contracts",
-  "version": "1.8.6",
-  "main": "./build/index.js",
-  "types": "./build/index.d.ts",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "prepublish": "rm -r ./build && tsc"
-  },
-  "keywords": [],
-  "author": "sergei-js",
-  "license": "ISC",
-  "description": "",
-  "dependencies": {
-    "zod": "^3.25.49"
-  }
+	"name": "@gigapay-dev/contracts",
+	"version": "3.0.0",
+	"description": "API contracts for GigaPay v3 platform — Zod schemas, endpoint definitions, typed client",
+	"main": "./build/index.js",
+	"types": "./build/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./build/index.d.ts",
+			"import": "./build/index.js",
+			"require": "./build/index.js"
+		}
+	},
+	"files": [
+		"build/**"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "tsc",
+		"typecheck": "tsc --noEmit",
+		"prepublishOnly": "npm run build",
+		"version:patch": "npm version patch",
+		"version:minor": "npm version minor",
+		"version:major": "npm version major"
+	},
+	"keywords": [
+		"gigapay",
+		"contracts",
+		"api",
+		"zod",
+		"typescript"
+	],
+	"author": "sergei-js",
+	"license": "ISC",
+	"dependencies": {
+		"zod": "^4.4.3"
+	},
+	"devDependencies": {
+		"typescript": "^5.7.3"
+	}
 }

package/build/commands/api-response.d.ts

@@ -1,18 +0,0 @@
-import z from "zod";
-export declare const ApiResponseSchema: z.ZodObject<{
-    status: z.ZodNumber;
-    error: z.ZodUnion<[z.ZodString, z.ZodLiteral<false>]>;
-    error_code: z.ZodUnion<[z.ZodString, z.ZodLiteral<false>]>;
-    data: z.ZodOptional<z.ZodAny>;
-}, "strip", z.ZodTypeAny, {
-    status: number;
-    error: string | false;
-    error_code: string | false;
-    data?: any;
-}, {
-    status: number;
-    error: string | false;
-    error_code: string | false;
-    data?: any;
-}>;
-export type ApiResponse = z.infer<typeof ApiResponseSchema>;

package/build/commands/api-response.js

@@ -1,13 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiResponseSchema = void 0;
-const zod_1 = __importDefault(require("zod"));
-exports.ApiResponseSchema = zod_1.default.object({
-    status: zod_1.default.coerce.number(),
-    error: zod_1.default.union([zod_1.default.string(), zod_1.default.literal(false)]),
-    error_code: zod_1.default.union([zod_1.default.string(), zod_1.default.literal(false)]),
-    data: zod_1.default.any().optional(),
-});

package/build/commands/auth/confirm.d.ts

@@ -1,11 +0,0 @@
-import z from "zod";
-import { UserLoginResponseSchema } from "./login";
-export declare const ConfirmCodeRequestSchema: z.ZodObject<{
-    code: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    code: string;
-}, {
-    code: string;
-}>;
-export type ConfirmCodeRequest = z.infer<typeof ConfirmCodeRequestSchema>;
-export type ConfirmCodeResponse = z.infer<typeof UserLoginResponseSchema>;

package/build/commands/auth/confirm.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfirmCodeRequestSchema = void 0;
-const zod_1 = __importDefault(require("zod"));
-const consts_1 = require("../consts");
-exports.ConfirmCodeRequestSchema = zod_1.default.object({
-    code: zod_1.default.string().min(consts_1.CONFIRMATION_CODE_LENGTH),
-});

package/build/commands/auth/endpoints.d.ts

@@ -1,114 +0,0 @@
-import z from "zod";
-export declare const AuthEndpoints: {
-    login: {
-        method: "POST";
-        path: string;
-        request: z.ZodObject<{
-            email: z.ZodString;
-            password: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            email: string;
-            password: string;
-        }, {
-            email: string;
-            password: string;
-        }>;
-        response: z.ZodObject<{
-            accessToken: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            accessToken: string;
-        }, {
-            accessToken: string;
-        }>;
-    };
-    register: {
-        method: "POST";
-        path: string;
-        request: z.ZodObject<{
-            email: z.ZodString;
-            password: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            email: string;
-            password: string;
-        }, {
-            email: string;
-            password: string;
-        }>;
-        response: z.ZodObject<{
-            accessToken: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            accessToken: string;
-        }, {
-            accessToken: string;
-        }>;
-    };
-    refresh: {
-        method: "GET";
-        path: string;
-        request: z.ZodVoid;
-        response: z.ZodObject<{
-            accessToken: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            accessToken: string;
-        }, {
-            accessToken: string;
-        }>;
-    };
-    reset: {
-        method: "POST";
-        path: string;
-        request: z.ZodObject<{
-            code: z.ZodString;
-            password: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            password: string;
-            code: string;
-        }, {
-            password: string;
-            code: string;
-        }>;
-        response: z.ZodVoid;
-    };
-    confirm: {
-        method: "GET";
-        path: string;
-        request: z.ZodObject<{
-            code: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            code: string;
-        }, {
-            code: string;
-        }>;
-        response: z.ZodObject<{
-            accessToken: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            accessToken: string;
-        }, {
-            accessToken: string;
-        }>;
-    };
-    profile: {
-        method: "GET";
-        path: string;
-        request: z.ZodVoid;
-        response: z.ZodObject<{
-            id: z.ZodNumber;
-            username: z.ZodString;
-            email: z.ZodString;
-            avatar: z.ZodNullable<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            email: string;
-            id: number;
-            username: string;
-            avatar: string | null;
-        }, {
-            email: string;
-            id: number;
-            username: string;
-            avatar: string | null;
-        }>;
-    };
-};
-export type AuthEndpointKey = keyof typeof AuthEndpoints;
-export type GetAuthRequest<K extends AuthEndpointKey> = z.infer<typeof AuthEndpoints[K]["request"]>;
-export type GetAuthResponse<K extends AuthEndpointKey> = z.infer<typeof AuthEndpoints[K]["response"]>;