@openlup/platform 0.17.0 → 0.19.0

package/dist/pricing/quoteSchemas.js

@@ -0,0 +1,196 @@
+import { z } from "zod";
+import { COMMERCE_CONTRACT_VERSION } from "./contracts/quote.js";
+import { createCommerceQuotePrimitives } from "./quotePrimitives.js";
+import { catalogFactsProvenanceSchema, rejectCatalogFactsFromPublicQuote } from "./catalogFactsSchemas.js";
+import { quoteDiscountSchema } from "./quotePromotionEvidence.js";
+import { quoteCodeRejectionDetailSchema } from "./quoteCodeRejectionDetails.js";
+/** Split gross tax-included money into net/VAT using an explicit tax rate. */
+export function splitIncludedVat(grossMinor, vatRateBps) {
+    const netMinor = Math.round((grossMinor * 10_000) / (10_000 + vatRateBps));
+    const vatMinor = grossMinor - netMinor;
+    return { netMinor, vatMinor };
+}
+/** Backstop: every Money in a quote must use the quote's own currency. */
+export function quoteMoneyCurrenciesMatch(quote) {
+    const monies = [
+        quote.subtotalGross,
+        quote.discountTotalGross,
+        ...(quote.shippingGross ? [quote.shippingGross] : []),
+        ...(quote.shippingDiscountGross ? [quote.shippingDiscountGross] : []),
+        quote.totalGross,
+        quote.netTotal,
+        quote.taxTotal,
+        ...quote.lines.flatMap((line) => [
+            line.unitPriceGross,
+            line.lineSubtotalGross,
+            line.tax.netAmount,
+            line.tax.vatAmount,
+            line.tax.grossAmount,
+        ]),
+    ];
+    return monies.every((money) => money.currency === quote.currency);
+}
+/** Preserve quote validation while hosts bind currency, product identifiers and context. */
+export function createCommerceQuoteSchemas(input) {
+    const { commerceCurrencySchema, commerceMoneySchema, commerceSkuSchema, commerceTaxCategorySchema, commerceTaxCountrySchema, commerceTaxLegalBasisSchema } = createCommerceQuotePrimitives(input.currencySchema);
+    const commerceProductSlugSchema = input.productSlugSchema;
+    const quoteContextSchema = input.contextSchema;
+    const quotePricingComponentSchema = z
+        .object({
+        scope: z.enum(["line", "order"]),
+        componentType: z.enum(["base_unit", "mode_discount", "qty_tier", "promo", "loyalty", "shipping", "bundle"]),
+        amountMinor: z.number().int(),
+        reasonCode: z.string().trim().min(1).max(120),
+        reasonPayload: z.record(z.string(), z.unknown()).default({}),
+    })
+        .strict();
+    const cartLineInputSchema = z.object({
+        sku: commerceSkuSchema,
+        quantity: z.number().int().min(1).max(99),
+        variantId: z.string().trim().min(1).max(120).optional(),
+        modeAtLine: z.enum(["one_time", "subscription"]).optional(),
+        isAddon: z.boolean().optional(),
+    });
+    const commerceTaxBreakdownSchema = z
+        .object({
+        included: z.literal(true),
+        country: commerceTaxCountrySchema,
+        category: commerceTaxCategorySchema,
+        vatRateBps: z.number().int().min(0).max(10_000),
+        legalBasis: commerceTaxLegalBasisSchema,
+        netAmount: commerceMoneySchema,
+        vatAmount: commerceMoneySchema,
+        grossAmount: commerceMoneySchema,
+    })
+        .refine((tax) => tax.netAmount.currency === tax.vatAmount.currency &&
+        tax.netAmount.currency === tax.grossAmount.currency &&
+        tax.netAmount.amountMinor + tax.vatAmount.amountMinor === tax.grossAmount.amountMinor, {
+        message: "tax net and VAT amounts must add up to gross amount",
+        path: ["grossAmount"],
+    });
+    const quoteLineSchema = z
+        .object({
+        sku: commerceSkuSchema,
+        productSlug: commerceProductSlugSchema,
+        quantity: z.number().int().min(1).max(99),
+        unitPriceGross: commerceMoneySchema,
+        lineSubtotalGross: commerceMoneySchema,
+        tax: commerceTaxBreakdownSchema,
+        pricingComponents: z.array(quotePricingComponentSchema).optional(),
+        catalogFacts: catalogFactsProvenanceSchema.optional(),
+    })
+        .refine((line) => line.unitPriceGross.currency === line.lineSubtotalGross.currency &&
+        line.lineSubtotalGross.currency === line.tax.grossAmount.currency &&
+        line.unitPriceGross.amountMinor * line.quantity === line.lineSubtotalGross.amountMinor, {
+        message: "quote line subtotal must match unit price and quantity",
+        path: ["lineSubtotalGross"],
+    });
+    const quoteCodeRejectionSchema = z
+        .object({
+        code: z.string().trim().min(1).max(80),
+        reason: z.enum([
+            "not_recognized",
+            "already_used",
+            "not_eligible",
+            "expired",
+            "better_price_exists",
+            "scope_not_applicable",
+        ]),
+    })
+        .strict();
+    const commerceQuoteSchema = z
+        .object({
+        currency: commerceCurrencySchema,
+        taxIncluded: z.literal(true),
+        lines: z.array(quoteLineSchema).min(1).max(50),
+        discounts: z.array(quoteDiscountSchema).max(20),
+        codeRejections: z.array(quoteCodeRejectionSchema).max(20).optional(),
+        codeRejectionDetails: z.array(quoteCodeRejectionDetailSchema).max(20).optional(),
+        pricingComponents: z.array(quotePricingComponentSchema).optional(),
+        context: quoteContextSchema.optional(),
+        subtotalGross: commerceMoneySchema,
+        discountTotalGross: commerceMoneySchema,
+        // Shipping/discount tax split uses one quote rate; mixed-tax allocation is out of scope.
+        shippingGross: commerceMoneySchema.optional(),
+        shippingDiscountGross: commerceMoneySchema.optional(),
+        totalGross: commerceMoneySchema,
+        netTotal: commerceMoneySchema,
+        taxTotal: commerceMoneySchema,
+    })
+        .refine((quote) => quote.lines.every((line) => line.tax.vatRateBps === quote.lines[0]?.tax.vatRateBps), {
+        message: "mixed VAT rates are not supported by quote discount and shipping tax allocation",
+        path: ["lines"],
+    })
+        .refine((quote) => {
+        const subtotal = sumAmounts(quote.lines.map((line) => line.lineSubtotalGross));
+        const lineNet = sumAmounts(quote.lines.map((line) => line.tax.netAmount));
+        const lineVat = sumAmounts(quote.lines.map((line) => line.tax.vatAmount));
+        const vatRateBps = quote.lines[0]?.tax.vatRateBps ?? 0;
+        const singleTaxRate = quote.lines.every((line) => line.tax.vatRateBps === vatRateBps);
+        const discountTotal = quote.discountTotalGross.amountMinor;
+        const orderDiscountSum = quote.discounts
+            .filter((discount) => discount.appliesTo !== "shipping")
+            .reduce((sum, discount) => sum + discount.amountOffMinor, 0);
+        const shippingDiscountSum = quote.discounts
+            .filter((discount) => discount.appliesTo === "shipping")
+            .reduce((sum, discount) => sum + discount.amountOffMinor, 0);
+        const shippingGross = quote.shippingGross?.amountMinor ?? 0;
+        const shippingDiscount = quote.shippingDiscountGross?.amountMinor ?? 0;
+        const { netMinor: discountNet, vatMinor: discountVat } = splitIncludedVat(discountTotal, vatRateBps);
+        const { netMinor: shipNet, vatMinor: shipVat } = splitIncludedVat(shippingGross, vatRateBps);
+        const { netMinor: shipDiscNet, vatMinor: shipDiscVat } = splitIncludedVat(shippingDiscount, vatRateBps);
+        return (singleTaxRate &&
+            quote.subtotalGross.amountMinor === subtotal &&
+            discountTotal >= 0 &&
+            discountTotal <= subtotal &&
+            orderDiscountSum === discountTotal &&
+            shippingGross >= 0 &&
+            shippingDiscount >= 0 &&
+            shippingDiscount <= shippingGross &&
+            shippingDiscountSum === shippingDiscount &&
+            quote.totalGross.amountMinor === subtotal - discountTotal + shippingGross - shippingDiscount &&
+            quote.netTotal.amountMinor === lineNet - discountNet + shipNet - shipDiscNet &&
+            quote.taxTotal.amountMinor === lineVat - discountVat + shipVat - shipDiscVat &&
+            quote.netTotal.amountMinor + quote.taxTotal.amountMinor === quote.totalGross.amountMinor);
+    }, {
+        message: "quote totals must match quote lines, discounts and shipping",
+        path: ["totalGross"],
+    })
+        // The currency backstop reads the validated money fields.
+        .refine((quote) => quoteMoneyCurrenciesMatch(quote), {
+        message: "all quote money amounts must use the quote currency",
+        path: ["currency"],
+    });
+    const createQuoteRequestSchema = z.object({
+        mode: z.enum(["one_time", "subscription"]).default("one_time"),
+        lines: z.array(cartLineInputSchema).min(1).max(50),
+        cadenceDays: z.number().int().positive().max(120).nullable().optional(),
+        promoCodes: z.array(z.string().trim().min(1).max(80)).max(20).default([]),
+    }).superRefine(validateQuoteRequest);
+    const createQuoteResponseSchema = z.object({
+        contractVersion: z.literal(COMMERCE_CONTRACT_VERSION), quote: commerceQuoteSchema,
+    }).strict();
+    const publicCreateQuoteResponseSchema = createQuoteResponseSchema.extend({
+        promotionAcceptanceToken: z.string().min(1).max(8_300).optional(),
+    }).superRefine(rejectCatalogFactsFromPublicQuote);
+    const createQuoteBatchResponseSchema = z.object({
+        contractVersion: z.literal(COMMERCE_CONTRACT_VERSION), quotes: z.array(commerceQuoteSchema),
+    });
+    const publicCreateQuoteBatchResponseSchema = createQuoteBatchResponseSchema
+        .superRefine((response, ctx) => response.quotes.forEach((quote, index) => rejectCatalogFactsFromPublicQuote({ quote }, ctx, ["quotes", index])));
+    return { createQuoteRequestSchema, quotePricingComponentSchema, cartLineInputSchema, commerceTaxBreakdownSchema, quoteLineSchema,
+        quoteCodeRejectionSchema, commerceQuoteSchema, createQuoteResponseSchema, publicCreateQuoteResponseSchema,
+        createQuoteBatchResponseSchema, publicCreateQuoteBatchResponseSchema };
+}
+function sumAmounts(amounts) {
+    return amounts.reduce((sum, amount) => sum + (amount.amountMinor ?? 0), 0);
+}
+function validateQuoteRequest(request, ctx) {
+    if (request.mode === "subscription" && !request.cadenceDays) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "subscription quote requires cadenceDays",
+            path: ["cadenceDays"],
+        });
+    }
+}

package/dist/pricing/quoteShippingPromotions.d.ts

@@ -0,0 +1,20 @@
+import type { ShippingTerms } from "../shipping/index.js";
+import type { ResolvedAcquisitionTerms } from "./contracts/acquisitionTerms.js";
+import type { CreateQuoteRequest } from "./contracts/quote.js";
+import type { CreateQuoteOptions } from "./quotePorts.js";
+import type { QuotePromotionResult } from "./dbBackedCommerceQuotePort.js";
+export interface QuoteShippingPromotionInput<Request extends CreateQuoteRequest> {
+    request: Request;
+    options?: CreateQuoteOptions;
+    regionCode: string;
+    currency: string;
+    referenceProductMinor: number;
+    subtotalGrossMinor: number;
+    atTime: string;
+}
+export interface QuoteShippingPromotionResult extends QuotePromotionResult {
+    shippingGrossMinor: number;
+    hasShipping: boolean;
+    shippingTerms?: ShippingTerms;
+    acquisitionTerms?: ResolvedAcquisitionTerms;
+}

package/dist/pricing/quoteShippingPromotions.js

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

package/dist/pricing/subscriptionPricePolicy.d.ts

@@ -0,0 +1,52 @@
+import { type SubscriptionPricePolicySemantics, type SubscriptionPricePolicyCanonicalInput, type SubscriptionPricePolicyRevision, type SubscriptionPricePolicyDigestRefusal } from "./contracts/index.js";
+import { z } from "./validation.js";
+export declare const subscriptionPricePolicySemanticsSchema: z.ZodObject<{
+    discountBps: z.ZodNumber;
+    roundingQuantumMinor: z.ZodNumber;
+    roundingRule: z.ZodEnum<{
+        FLOOR_TO_QUANTUM: "FLOOR_TO_QUANTUM";
+    }>;
+}, z.core.$strict>;
+export declare const subscriptionPricePolicyCanonicalInputSchema: z.ZodObject<{
+    discountBps: z.ZodNumber;
+    roundingQuantumMinor: z.ZodNumber;
+    roundingRule: z.ZodEnum<{
+        FLOOR_TO_QUANTUM: "FLOOR_TO_QUANTUM";
+    }>;
+    id: z.ZodGUID;
+    revisionNo: z.ZodNumber;
+    priceListId: z.ZodGUID;
+    regionCode: z.ZodString;
+    currency: z.ZodString;
+    channel: z.ZodString;
+    effectiveFrom: z.ZodString;
+    effectiveTo: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const subscriptionPricePolicyRevisionSchema: z.ZodObject<{
+    discountBps: z.ZodNumber;
+    roundingQuantumMinor: z.ZodNumber;
+    roundingRule: z.ZodEnum<{
+        FLOOR_TO_QUANTUM: "FLOOR_TO_QUANTUM";
+    }>;
+    id: z.ZodGUID;
+    revisionNo: z.ZodNumber;
+    priceListId: z.ZodGUID;
+    regionCode: z.ZodString;
+    currency: z.ZodString;
+    channel: z.ZodString;
+    effectiveFrom: z.ZodString;
+    effectiveTo: z.ZodNullable<z.ZodString>;
+    digest: z.ZodString;
+}, z.core.$strict>;
+export declare class SubscriptionPricePolicyDigestError extends Error {
+    readonly code: SubscriptionPricePolicyDigestRefusal;
+    constructor(code: SubscriptionPricePolicyDigestRefusal);
+}
+/** The exact tuple whose canonical digest is persisted with a policy revision. */
+export declare function canonicalSubscriptionPricePolicyTuple(policy: SubscriptionPricePolicyCanonicalInput | SubscriptionPricePolicyRevision): string;
+/** Hashes application-owned canonical UTF-8 bytes; never a database JSON rendering. */
+export declare function digestSubscriptionPricePolicy(policy: SubscriptionPricePolicyCanonicalInput | SubscriptionPricePolicyRevision): Promise<string>;
+/** Parses a persisted revision and refuses a digest outside its canonical UTF-8 tuple. */
+export declare function assertSubscriptionPricePolicyDigest(value: unknown): Promise<SubscriptionPricePolicyRevision>;
+/** Resolves a subscription unit price from a base unit price and a policy revision. */
+export declare function deriveSubscriptionUnitPrice(baseUnitAmountMinor: number, semantics: SubscriptionPricePolicySemantics | SubscriptionPricePolicyCanonicalInput | SubscriptionPricePolicyRevision): number;

package/dist/pricing/subscriptionPricePolicy.js

@@ -0,0 +1,96 @@
+import { SUBSCRIPTION_PRICE_POLICY_SCHEMA_VERSION } from "./contracts/index.js";
+import { z } from "./validation.js";
+const uuidSchema = z.guid();
+const sha256DigestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+const currencySchema = z.string().regex(/^[A-Z]{3}$/u);
+const channelSchema = z.string().trim().min(1).max(64).regex(/^[A-Za-z0-9._:-]+$/);
+export const subscriptionPricePolicySemanticsSchema = z.object({
+    discountBps: z.number().int().min(0).max(10_000),
+    roundingQuantumMinor: z.number().int().positive().refine(Number.isSafeInteger, "rounding quantum must be a safe integer"),
+    roundingRule: z.enum(["FLOOR_TO_QUANTUM"]),
+}).strict();
+const subscriptionPricePolicyRevisionFields = {
+    id: uuidSchema,
+    revisionNo: z.number().int().positive(),
+    priceListId: uuidSchema,
+    regionCode: z.string().regex(/^[A-Z]{2,3}$/u),
+    currency: currencySchema,
+    channel: channelSchema,
+    effectiveFrom: z.string().datetime({ offset: true }),
+    effectiveTo: z.string().datetime({ offset: true }).nullable(),
+    ...subscriptionPricePolicySemanticsSchema.shape,
+};
+export const subscriptionPricePolicyCanonicalInputSchema = z.object(subscriptionPricePolicyRevisionFields).strict().superRefine((policy, context) => {
+    if (policy.effectiveTo && policy.effectiveTo <= policy.effectiveFrom) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["effectiveTo"], message: "effectiveTo must be later than effectiveFrom" });
+    }
+});
+export const subscriptionPricePolicyRevisionSchema = subscriptionPricePolicyCanonicalInputSchema.extend({
+    digest: sha256DigestSchema,
+}).strict();
+export class SubscriptionPricePolicyDigestError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "SubscriptionPricePolicyDigestError";
+    }
+}
+/** The exact tuple whose canonical digest is persisted with a policy revision. */
+export function canonicalSubscriptionPricePolicyTuple(policy) {
+    const value = parseCanonicalPolicyInput(policy);
+    return JSON.stringify({
+        schemaVersion: SUBSCRIPTION_PRICE_POLICY_SCHEMA_VERSION,
+        id: value.id,
+        revisionNo: value.revisionNo,
+        priceListId: value.priceListId,
+        regionCode: value.regionCode,
+        currency: value.currency,
+        channel: value.channel,
+        effectiveFrom: value.effectiveFrom,
+        effectiveTo: value.effectiveTo,
+        discountBps: value.discountBps,
+        roundingQuantumMinor: value.roundingQuantumMinor,
+        roundingRule: value.roundingRule,
+    });
+}
+/** Hashes application-owned canonical UTF-8 bytes; never a database JSON rendering. */
+export async function digestSubscriptionPricePolicy(policy) {
+    const bytes = new TextEncoder().encode(canonicalSubscriptionPricePolicyTuple(policy));
+    const crypto = globalThis.crypto;
+    if (!crypto?.subtle)
+        throw new Error("Web Crypto SHA-256 is unavailable");
+    const digest = await crypto.subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/** Parses a persisted revision and refuses a digest outside its canonical UTF-8 tuple. */
+export async function assertSubscriptionPricePolicyDigest(value) {
+    const revision = subscriptionPricePolicyRevisionSchema.parse(value);
+    const actual = await digestSubscriptionPricePolicy(revision);
+    if (actual !== revision.digest) {
+        throw new SubscriptionPricePolicyDigestError("subscription_price_policy_digest_mismatch");
+    }
+    return revision;
+}
+/** Resolves a subscription unit price from a base unit price and a policy revision. */
+export function deriveSubscriptionUnitPrice(baseUnitAmountMinor, semantics) {
+    if (!Number.isSafeInteger(baseUnitAmountMinor) || baseUnitAmountMinor < 0) {
+        throw new RangeError("baseUnitAmountMinor must be a non-negative safe integer");
+    }
+    const policy = subscriptionPricePolicySemanticsSchema.parse({
+        discountBps: semantics.discountBps,
+        roundingQuantumMinor: semantics.roundingQuantumMinor,
+        roundingRule: semantics.roundingRule,
+    });
+    const discounted = (BigInt(baseUnitAmountMinor) * BigInt(10_000 - policy.discountBps)) / 10000n;
+    const quantum = BigInt(policy.roundingQuantumMinor);
+    const resolved = (discounted / quantum) * quantum;
+    if (resolved > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new RangeError("resolved subscription price exceeds Number.MAX_SAFE_INTEGER");
+    }
+    return Number(resolved);
+}
+function parseCanonicalPolicyInput(value) {
+    const persisted = subscriptionPricePolicyRevisionSchema.safeParse(value);
+    return persisted.success ? persisted.data : subscriptionPricePolicyCanonicalInputSchema.parse(value);
+}

package/dist/pricing/taxProfileGuard.d.ts

@@ -0,0 +1,2 @@
+import type { CommerceTaxProfile } from "./contracts/money.js";
+export declare function assertSupportedCommerceTaxProfile(taxProfile: CommerceTaxProfile, supportedTaxProfiles: readonly CommerceTaxProfile[]): void;

package/dist/pricing/taxProfileGuard.js

@@ -0,0 +1,24 @@
+import { CommerceQuoteError } from "./quotePorts.js";
+export function assertSupportedCommerceTaxProfile(taxProfile, supportedTaxProfiles) {
+    if (!Number.isInteger(taxProfile.vatRateBps) ||
+        taxProfile.vatRateBps < 0 ||
+        taxProfile.vatRateBps > 10_000) {
+        throw new CommerceQuoteError("UNSUPPORTED_TAX_PROFILE", "Unsupported commerce tax profile", {
+            reason: "vatRateBps must be an integer between 0 and 10000",
+            vatRateBps: taxProfile.vatRateBps,
+        });
+    }
+    const supported = supportedTaxProfiles.some((candidate) => candidate.included === taxProfile.included &&
+        candidate.country === taxProfile.country &&
+        candidate.category === taxProfile.category &&
+        candidate.vatRateBps === taxProfile.vatRateBps &&
+        candidate.legalBasis === taxProfile.legalBasis);
+    if (!supported) {
+        throw new CommerceQuoteError("UNSUPPORTED_TAX_PROFILE", "Unsupported commerce tax profile", {
+            country: taxProfile.country,
+            category: taxProfile.category,
+            vatRateBps: taxProfile.vatRateBps,
+            reason: "taxProfile must be declared in supportedTaxProfiles",
+        });
+    }
+}

package/dist/pricing/validation.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export { z };

package/dist/pricing/validation.js

@@ -0,0 +1,3 @@
+import { z } from "zod";
+z.config({ jitless: true });
+export { z };

package/dist/promotions/adminBindings.d.ts

@@ -0,0 +1,72 @@
+import type { z } from "zod";
+import type { HttpRequest, HttpResponse } from "../http/index.js";
+import type { BffResponder } from "../bff/index.js";
+import type { createPromotionCodePreview } from "./promotionCodePreview.js";
+/** Structural inputs to the existing host admin kit; no kit implementation lives here. */
+export type AdminAuthorization = {
+    ok: true;
+    userId: string;
+    role: "admin" | "distributor";
+    isMachineActor: boolean;
+} | {
+    ok: false;
+    code: "UNAUTHORIZED" | "FORBIDDEN";
+    message: string;
+    identityCode?: string;
+};
+export type AuthorizeAdmin = () => Promise<AdminAuthorization>;
+export interface AgentDomainQuerySpec<T> {
+    readonly key: string;
+    readonly requestSchema: z.ZodType<T, unknown>;
+    readonly gate: "read";
+    readonly allowedActorKinds: readonly ("human" | "machine")[];
+}
+export interface AgentDomainMutationSpec<T> extends Omit<AgentDomainQuerySpec<T>, "gate"> {
+    readonly gate: "mutation";
+    readonly lifecycleMarkers: readonly never[];
+}
+type Handler = (req: HttpRequest, res: HttpResponse) => Promise<void>;
+type ErrorMapper = (res: HttpResponse, error: unknown, failureMessage: string) => void;
+interface ReadOptions<T> {
+    readonly authorizeAdmin: AuthorizeAdmin;
+    readonly toResponse: (value: T) => Record<string, unknown>;
+    readonly responseSchema: {
+        safeParse(value: unknown): {
+            success: boolean;
+            data?: unknown;
+        };
+    };
+    readonly invalidResponseMessage: string;
+    readonly failureMessage: string;
+}
+interface MutationOptions<Request, Result> extends Omit<ReadOptions<Result>, "responseSchema" | "invalidResponseMessage"> {
+    readonly mutation: AgentDomainMutationSpec<Request>;
+    readonly invoke: (actorId: string, request: Request) => Promise<Result>;
+    readonly responseSchema?: ReadOptions<Result>["responseSchema"];
+    readonly invalidResponseMessage?: string;
+    readonly invalidRequestMessage: string;
+    readonly mapError?: ErrorMapper;
+}
+interface QueryOptions<Request, Result> extends ReadOptions<Result> {
+    readonly query: AgentDomainQuerySpec<Request>;
+    readonly load: (actorId: string, request: Request) => Promise<Result>;
+    readonly invalidRequestMessage: string;
+    readonly mapError?: ErrorMapper;
+}
+export interface PromotionAdminBindings extends BffResponder, Pick<ReturnType<typeof createPromotionCodePreview>, "generatePromotionCode" | "normalizePromotionCode" | "previewPromotionCode" | "verifyPromotionPreviewProof"> {
+    createAdminMutationHandler<Request, Result>(options: MutationOptions<Request, Result>): Handler;
+    createAdminReadHandler<Result>(options: ReadOptions<Result> & {
+        load(): Promise<Result>;
+    }): Handler;
+    createAdminParameterizedReadHandler<Request, Result>(options: QueryOptions<Request, Result>): Handler;
+    mapRpcError: ErrorMapper;
+    resolveAdmin(authorize: AuthorizeAdmin, res: HttpResponse): Promise<Omit<Extract<AdminAuthorization, {
+        ok: true;
+    }>, "ok"> | null>;
+    /** The host constructor is passed by identity, preserving instanceof and SQLSTATE mapping. */
+    DomainRpcError: new (sqlstate: string | undefined, pgMessage: string) => Error & {
+        sqlstate: string | undefined;
+        pgMessage: string;
+    };
+}
+export {};

package/dist/promotions/adminBindings.js

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