@86d-store/multi-currency 0.1.0

package/dist/admin/endpoints/delete-price-override.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const adminDeletePriceOverride: import("better-call").StrictEndpoint<"/admin/currencies/price-overrides/:id/delete", {
+    method: "POST";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+}, {
+    success: boolean;
+}>;
+//# sourceMappingURL=delete-price-override.d.ts.map

package/dist/admin/endpoints/delete-price-override.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-price-override.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/delete-price-override.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,wBAAwB;;;;;;;EAYpC,CAAC"}

package/dist/admin/endpoints/delete-price-override.js

@@ -0,0 +1,11 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const adminDeletePriceOverride = createAdminEndpoint("/admin/currencies/price-overrides/:id/delete", {
+    method: "POST",
+    params: z.object({ id: z.string() }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .multiCurrency;
+    await controller.deletePriceOverride(ctx.params.id);
+    return { success: true };
+});

package/dist/admin/endpoints/get-currency.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const adminGetCurrency: import("better-call").StrictEndpoint<"/admin/currencies/:id", {
+    method: "GET";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    currency?: never;
+} | {
+    currency: import("../..").Currency;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=get-currency.d.ts.map

package/dist/admin/endpoints/get-currency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-currency.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/get-currency.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;EAe5B,CAAC"}

package/dist/admin/endpoints/get-currency.js

@@ -0,0 +1,14 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const adminGetCurrency = createAdminEndpoint("/admin/currencies/:id", {
+    method: "GET",
+    params: z.object({ id: z.string() }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .multiCurrency;
+    const currency = await controller.getById(ctx.params.id);
+    if (!currency) {
+        return { error: "Currency not found", status: 404 };
+    }
+    return { currency };
+});

package/dist/admin/endpoints/list-currencies.d.ts

@@ -0,0 +1,6 @@
+export declare const adminListCurrencies: import("better-call").StrictEndpoint<"/admin/currencies", {
+    method: "GET";
+}, {
+    currencies: import("../..").Currency[];
+}>;
+//# sourceMappingURL=list-currencies.d.ts.map

package/dist/admin/endpoints/list-currencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-currencies.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/list-currencies.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB;;;;EAS/B,CAAC"}

package/dist/admin/endpoints/list-currencies.js

@@ -0,0 +1,7 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+export const adminListCurrencies = createAdminEndpoint("/admin/currencies", { method: "GET" }, async (ctx) => {
+    const controller = ctx.context.controllers
+        .multiCurrency;
+    const currencies = await controller.list();
+    return { currencies };
+});

package/dist/admin/endpoints/list-price-overrides.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const adminListPriceOverrides: import("better-call").StrictEndpoint<"/admin/currencies/price-overrides/:productId", {
+    method: "GET";
+    params: z.ZodObject<{
+        productId: z.ZodString;
+    }, z.core.$strip>;
+}, {
+    overrides: import("../..").PriceOverride[];
+}>;
+//# sourceMappingURL=list-price-overrides.d.ts.map

package/dist/admin/endpoints/list-price-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-price-overrides.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/list-price-overrides.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,uBAAuB;;;;;;;EAYnC,CAAC"}

package/dist/admin/endpoints/list-price-overrides.js

@@ -0,0 +1,11 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const adminListPriceOverrides = createAdminEndpoint("/admin/currencies/price-overrides/:productId", {
+    method: "GET",
+    params: z.object({ productId: z.string() }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .multiCurrency;
+    const overrides = await controller.listPriceOverrides(ctx.params.productId);
+    return { overrides };
+});

package/dist/admin/endpoints/rate-history.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const adminRateHistory: import("better-call").StrictEndpoint<"/admin/currencies/rate-history", {
+    method: "POST";
+    body: z.ZodObject<{
+        currencyCode: z.ZodString;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, {
+    history: import("../..").ExchangeRateHistory[];
+}>;
+//# sourceMappingURL=rate-history.d.ts.map

package/dist/admin/endpoints/rate-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-history.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/rate-history.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,gBAAgB;;;;;;;;EAkB5B,CAAC"}

package/dist/admin/endpoints/rate-history.js

@@ -0,0 +1,17 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const adminRateHistory = createAdminEndpoint("/admin/currencies/rate-history", {
+    method: "POST",
+    body: z.object({
+        currencyCode: z.string().min(3).max(3),
+        limit: z.number().int().positive().max(200).optional(),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .multiCurrency;
+    const history = await controller.getRateHistory({
+        currencyCode: ctx.body.currencyCode,
+        ...(ctx.body.limit ? { limit: ctx.body.limit } : {}),
+    });
+    return { history };
+});

package/dist/admin/endpoints/routes.d.ts

@@ -0,0 +1,180 @@
+export declare const adminEndpoints: {
+    "/admin/currencies": import("better-call").StrictEndpoint<"/admin/currencies", {
+        method: "GET";
+    }, {
+        currencies: import("../..").Currency[];
+    }>;
+    "/admin/currencies/create": import("better-call").StrictEndpoint<"/admin/currencies/create", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+            code: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            name: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            symbol: import("zod").ZodString;
+            decimalPlaces: import("zod").ZodOptional<import("zod").ZodNumber>;
+            exchangeRate: import("zod").ZodOptional<import("zod").ZodNumber>;
+            isBase: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            isActive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            symbolPosition: import("zod").ZodOptional<import("zod").ZodEnum<{
+                before: "before";
+                after: "after";
+            }>>;
+            thousandsSeparator: import("zod").ZodOptional<import("zod").ZodString>;
+            decimalSeparator: import("zod").ZodOptional<import("zod").ZodString>;
+            roundingMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                round: "round";
+                ceil: "ceil";
+                floor: "floor";
+            }>>;
+            sortOrder: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        currency?: never;
+    } | {
+        currency: import("../..").Currency;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/currencies/update-rate": import("better-call").StrictEndpoint<"/admin/currencies/update-rate", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+            currencyCode: import("zod").ZodString;
+            rate: import("zod").ZodNumber;
+            source: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        currency?: never;
+    } | {
+        currency: import("../..").Currency;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/currencies/bulk-update-rates": import("better-call").StrictEndpoint<"/admin/currencies/bulk-update-rates", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+            rates: import("zod").ZodArray<import("zod").ZodObject<{
+                currencyCode: import("zod").ZodString;
+                rate: import("zod").ZodNumber;
+                source: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        updated: number;
+        errors: string[];
+    }>;
+    "/admin/currencies/rate-history": import("better-call").StrictEndpoint<"/admin/currencies/rate-history", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+            currencyCode: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        history: import("../..").ExchangeRateHistory[];
+    }>;
+    "/admin/currencies/price-override": import("better-call").StrictEndpoint<"/admin/currencies/price-override", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+            productId: import("zod").ZodString;
+            currencyCode: import("zod").ZodString;
+            price: import("zod").ZodNumber;
+            compareAtPrice: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        override: import("../..").PriceOverride;
+    }>;
+    "/admin/currencies/price-overrides/:productId": import("better-call").StrictEndpoint<"/admin/currencies/price-overrides/:productId", {
+        method: "GET";
+        params: import("zod").ZodObject<{
+            productId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        overrides: import("../..").PriceOverride[];
+    }>;
+    "/admin/currencies/price-overrides/:id/delete": import("better-call").StrictEndpoint<"/admin/currencies/price-overrides/:id/delete", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        success: boolean;
+    }>;
+    "/admin/currencies/:id": import("better-call").StrictEndpoint<"/admin/currencies/:id", {
+        method: "GET";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        currency?: never;
+    } | {
+        currency: import("../..").Currency;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/currencies/:id/update": import("better-call").StrictEndpoint<"/admin/currencies/:id/update", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        body: import("zod").ZodObject<{
+            name: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>>;
+            symbol: import("zod").ZodOptional<import("zod").ZodString>;
+            decimalPlaces: import("zod").ZodOptional<import("zod").ZodNumber>;
+            exchangeRate: import("zod").ZodOptional<import("zod").ZodNumber>;
+            isActive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            symbolPosition: import("zod").ZodOptional<import("zod").ZodEnum<{
+                before: "before";
+                after: "after";
+            }>>;
+            thousandsSeparator: import("zod").ZodOptional<import("zod").ZodString>;
+            decimalSeparator: import("zod").ZodOptional<import("zod").ZodString>;
+            roundingMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                round: "round";
+                ceil: "ceil";
+                floor: "floor";
+            }>>;
+            sortOrder: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        currency?: never;
+    } | {
+        currency: import("../..").Currency;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/currencies/:id/delete": import("better-call").StrictEndpoint<"/admin/currencies/:id/delete", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        success?: never;
+    } | {
+        success: boolean;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/currencies/:id/set-base": import("better-call").StrictEndpoint<"/admin/currencies/:id/set-base", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        currency?: never;
+    } | {
+        currency: import("../..").Currency;
+        error?: never;
+        status?: never;
+    }>;
+};
+//# sourceMappingURL=routes.d.ts.map

package/dist/admin/endpoints/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/routes.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAa1B,CAAC"}

package/dist/admin/endpoints/routes.js

@@ -0,0 +1,26 @@
+import { adminBulkUpdateRates } from "./bulk-update-rates";
+import { adminCreateCurrency } from "./create-currency";
+import { adminDeleteCurrency } from "./delete-currency";
+import { adminDeletePriceOverride } from "./delete-price-override";
+import { adminGetCurrency } from "./get-currency";
+import { adminListCurrencies } from "./list-currencies";
+import { adminListPriceOverrides } from "./list-price-overrides";
+import { adminRateHistory } from "./rate-history";
+import { adminSetBaseCurrency } from "./set-base-currency";
+import { adminSetPriceOverride } from "./set-price-override";
+import { adminUpdateCurrency } from "./update-currency";
+import { adminUpdateRate } from "./update-rate";
+export const adminEndpoints = {
+    "/admin/currencies": adminListCurrencies,
+    "/admin/currencies/create": adminCreateCurrency,
+    "/admin/currencies/update-rate": adminUpdateRate,
+    "/admin/currencies/bulk-update-rates": adminBulkUpdateRates,
+    "/admin/currencies/rate-history": adminRateHistory,
+    "/admin/currencies/price-override": adminSetPriceOverride,
+    "/admin/currencies/price-overrides/:productId": adminListPriceOverrides,
+    "/admin/currencies/price-overrides/:id/delete": adminDeletePriceOverride,
+    "/admin/currencies/:id": adminGetCurrency,
+    "/admin/currencies/:id/update": adminUpdateCurrency,
+    "/admin/currencies/:id/delete": adminDeleteCurrency,
+    "/admin/currencies/:id/set-base": adminSetBaseCurrency,
+};

package/dist/admin/endpoints/set-base-currency.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const adminSetBaseCurrency: import("better-call").StrictEndpoint<"/admin/currencies/:id/set-base", {
+    method: "POST";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    currency?: never;
+} | {
+    currency: import("../..").Currency;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=set-base-currency.d.ts.map

package/dist/admin/endpoints/set-base-currency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-base-currency.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/set-base-currency.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;EAehC,CAAC"}

package/dist/admin/endpoints/set-base-currency.js

@@ -0,0 +1,14 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const adminSetBaseCurrency = createAdminEndpoint("/admin/currencies/:id/set-base", {
+    method: "POST",
+    params: z.object({ id: z.string() }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .multiCurrency;
+    const currency = await controller.setBaseCurrency(ctx.params.id);
+    if (!currency) {
+        return { error: "Currency not found", status: 404 };
+    }
+    return { currency };
+});

package/dist/admin/endpoints/set-price-override.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const adminSetPriceOverride: import("better-call").StrictEndpoint<"/admin/currencies/price-override", {
+    method: "POST";
+    body: z.ZodObject<{
+        productId: z.ZodString;
+        currencyCode: z.ZodString;
+        price: z.ZodNumber;
+        compareAtPrice: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, {
+    override: import("../..").PriceOverride;
+}>;
+//# sourceMappingURL=set-price-override.d.ts.map

package/dist/admin/endpoints/set-price-override.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-price-override.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/set-price-override.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,qBAAqB;;;;;;;;;;EAiBjC,CAAC"}

package/dist/admin/endpoints/set-price-override.js

@@ -0,0 +1,16 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const adminSetPriceOverride = createAdminEndpoint("/admin/currencies/price-override", {
+    method: "POST",
+    body: z.object({
+        productId: z.string().min(1),
+        currencyCode: z.string().min(3).max(3),
+        price: z.number().int().nonnegative(),
+        compareAtPrice: z.number().int().nonnegative().optional(),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .multiCurrency;
+    const override = await controller.setPriceOverride(ctx.body);
+    return { override };
+});

package/dist/admin/endpoints/update-currency.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export declare const adminUpdateCurrency: import("better-call").StrictEndpoint<"/admin/currencies/:id/update", {
+    method: "POST";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    body: z.ZodObject<{
+        name: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        symbol: z.ZodOptional<z.ZodString>;
+        decimalPlaces: z.ZodOptional<z.ZodNumber>;
+        exchangeRate: z.ZodOptional<z.ZodNumber>;
+        isActive: z.ZodOptional<z.ZodBoolean>;
+        symbolPosition: z.ZodOptional<z.ZodEnum<{
+            before: "before";
+            after: "after";
+        }>>;
+        thousandsSeparator: z.ZodOptional<z.ZodString>;
+        decimalSeparator: z.ZodOptional<z.ZodString>;
+        roundingMode: z.ZodOptional<z.ZodEnum<{
+            round: "round";
+            ceil: "ceil";
+            floor: "floor";
+        }>>;
+        sortOrder: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    currency?: never;
+} | {
+    currency: import("../..").Currency;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=update-currency.d.ts.map

package/dist/admin/endpoints/update-currency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-currency.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/update-currency.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2B/B,CAAC"}

package/dist/admin/endpoints/update-currency.js

@@ -0,0 +1,27 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { sanitizeText } from "@86d-store/core/sanitize";
+import { z } from "zod";
+export const adminUpdateCurrency = createAdminEndpoint("/admin/currencies/:id/update", {
+    method: "POST",
+    params: z.object({ id: z.string() }),
+    body: z.object({
+        name: z.string().min(1).max(100).transform(sanitizeText).optional(),
+        symbol: z.string().min(1).max(10).optional(),
+        decimalPlaces: z.number().int().min(0).max(8).optional(),
+        exchangeRate: z.number().positive().optional(),
+        isActive: z.boolean().optional(),
+        symbolPosition: z.enum(["before", "after"]).optional(),
+        thousandsSeparator: z.string().max(5).optional(),
+        decimalSeparator: z.string().max(5).optional(),
+        roundingMode: z.enum(["round", "ceil", "floor"]).optional(),
+        sortOrder: z.number().int().optional(),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .multiCurrency;
+    const currency = await controller.update(ctx.params.id, ctx.body);
+    if (!currency) {
+        return { error: "Currency not found", status: 404 };
+    }
+    return { currency };
+});

package/dist/admin/endpoints/update-rate.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const adminUpdateRate: import("better-call").StrictEndpoint<"/admin/currencies/update-rate", {
+    method: "POST";
+    body: z.ZodObject<{
+        currencyCode: z.ZodString;
+        rate: z.ZodNumber;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    currency?: never;
+} | {
+    currency: import("../..").Currency;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=update-rate.d.ts.map

package/dist/admin/endpoints/update-rate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-rate.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/update-rate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;EAuB3B,CAAC"}

package/dist/admin/endpoints/update-rate.js

@@ -0,0 +1,22 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const adminUpdateRate = createAdminEndpoint("/admin/currencies/update-rate", {
+    method: "POST",
+    body: z.object({
+        currencyCode: z.string().min(3).max(3),
+        rate: z.number().positive(),
+        source: z.string().max(100).optional(),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .multiCurrency;
+    const currency = await controller.updateRate({
+        currencyCode: ctx.body.currencyCode,
+        rate: ctx.body.rate,
+        ...(ctx.body.source ? { source: ctx.body.source } : {}),
+    });
+    if (!currency) {
+        return { error: "Currency not found", status: 404 };
+    }
+    return { currency };
+});

package/dist/capabilities.d.ts

@@ -0,0 +1,56 @@
+import { productPriceConversionCapability } from "@86d-store/core/commerce-capabilities";
+import type { z } from "zod";
+import type { MultiCurrencyController } from "./service";
+type ProductPriceConversionRequest = z.infer<typeof productPriceConversionCapability.request>;
+export declare function handleProductPriceConversion(controller: MultiCurrencyController, request: ProductPriceConversionRequest): Promise<{
+    ok: true;
+    decision: {
+        amount: number;
+    };
+    failure?: never;
+} | {
+    ok: false;
+    failure: {
+        code: "CURRENCY_UNAVAILABLE";
+        message: string;
+    };
+    decision?: never;
+}>;
+export declare const productPriceConversionProvider: Readonly<{
+    definition: Readonly<{
+        name: "multi-currency.product-price";
+        version: "1.0.0";
+        owner: "multi-currency";
+        request: z.ZodObject<{
+            productId: z.ZodString;
+            basePriceInCents: z.ZodNumber;
+            currencyCode: z.ZodString;
+        }, z.core.$strict>;
+        decision: z.ZodObject<{
+            amount: z.ZodNumber;
+        }, z.core.$strict>;
+        failure: z.ZodObject<{
+            code: z.ZodLiteral<"CURRENCY_UNAVAILABLE">;
+            message: z.ZodString;
+        }, z.core.$strict>;
+    }>;
+    handle: import("@86d-store/core/capabilities").CapabilityHandler<Readonly<{
+        name: "multi-currency.product-price";
+        version: "1.0.0";
+        owner: "multi-currency";
+        request: z.ZodObject<{
+            productId: z.ZodString;
+            basePriceInCents: z.ZodNumber;
+            currencyCode: z.ZodString;
+        }, z.core.$strict>;
+        decision: z.ZodObject<{
+            amount: z.ZodNumber;
+        }, z.core.$strict>;
+        failure: z.ZodObject<{
+            code: z.ZodLiteral<"CURRENCY_UNAVAILABLE">;
+            message: z.ZodString;
+        }, z.core.$strict>;
+    }>>;
+}>;
+export {};
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gCAAgC,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAGzD,KAAK,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,gCAAgC,CAAC,OAAO,CAC/C,CAAC;AAEF,wBAAsB,4BAA4B,CACjD,UAAU,EAAE,uBAAuB,EACnC,OAAO,EAAE,6BAA6B;;;;;;;;;;;;;GAYtC;AAED,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO1C,CAAC"}

package/dist/capabilities.js

@@ -0,0 +1,16 @@
+import { provideCapability } from "@86d-store/core/capabilities";
+import { productPriceConversionCapability } from "@86d-store/core/commerce-capabilities";
+import { createMultiCurrencyController } from "./service-impl";
+export async function handleProductPriceConversion(controller, request) {
+    const result = await controller.getProductPrice(request);
+    return result
+        ? { ok: true, decision: { amount: result.amount } }
+        : {
+            ok: false,
+            failure: {
+                code: "CURRENCY_UNAVAILABLE",
+                message: "Authoritative currency conversion is unavailable.",
+            },
+        };
+}
+export const productPriceConversionProvider = provideCapability(productPriceConversionCapability, async (ctx, request) => handleProductPriceConversion(createMultiCurrencyController(ctx.data, ctx.events), request));

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import type { Module, ModuleConfig } from "@86d-store/core/types/module";
+export type { ConvertedPrice, Currency, ExchangeRateHistory, MultiCurrencyController, PriceOverride, RoundingMode, SymbolPosition, } from "./service";
+export interface MultiCurrencyOptions extends ModuleConfig {
+    /**
+     * Default base currency code (ISO 4217).
+     * @default "USD"
+     */
+    baseCurrency?: string;
+}
+/**
+ * Multi-currency module factory.
+ * Provides currency management, exchange rate tracking, price conversion,
+ * and per-product price overrides for international commerce.
+ */
+export default function multiCurrency(options?: MultiCurrencyOptions): Module;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,MAAM,EACN,YAAY,EAEZ,MAAM,8BAA8B,CAAC;AAOtC,YAAY,EACX,cAAc,EACd,QAAQ,EACR,mBAAmB,EACnB,uBAAuB,EACvB,aAAa,EACb,YAAY,EACZ,cAAc,GACd,MAAM,WAAW,CAAC;AAEnB,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACzD;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,MAAM,CA8D5E"}