@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/index.d.ts

@@ -0,0 +1,2984 @@
+import { Context } from 'effect';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { FieldCipher } from '@voltro/database';
+import { InventorySqlService } from '@voltro/plugin-inventory/server';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { PreparedSqlMutation } from '@voltro/database/sql';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { VoltroPlugin } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+declare const acceptedCompletion: unique symbol;
+
+/** SQL-issued capability. A player reference or serialized object cannot authorize provider completion. */
+declare interface AcceptedIapCompletion {
+    readonly [acceptedCompletion]: true;
+    readonly orderId: string;
+}
+
+/** Read-only SQL custody capability, never current provider state or refund authority. */
+declare interface AcceptedIapNotificationTarget {
+    readonly [acceptedNotificationTarget]: true;
+    readonly orderId: string;
+    readonly noticeId: string;
+}
+
+declare const acceptedNotificationTarget: unique symbol;
+
+/** Exact ordinary wallet policy; hard-currency credits may repay existing refund debt. */
+export declare const applyWalletPosting: (balance: EconomyAmountInput, posting: LedgerPosting, definition: CurrencyDefinition) => string;
+
+export declare const assertSpendBudget: (projection: ReturnType<typeof projectSpend>, input: EconomyAmountInput, budget: SpendBudget) => void;
+
+export declare const captureCodeIntent: (input: RedeemCodeInput) => RedeemCodeInput;
+
+export declare const captureCodeService: (input: CodeService) => CodeService;
+
+/** Case-sensitive code intention, never normalization that expands authority. */
+export declare const captureCodeValue: (input: unknown) => string;
+
+export declare const captureEconomyService: (input: EconomySystemService) => EconomySystemService;
+
+export declare const captureLoyaltyService: (input: LoyaltyService) => LoyaltyService;
+
+export declare const capturePiggyBanksService: (input: PiggyBanksService) => PiggyBanksService;
+
+/** The same detached receipt admission serves SQL history and browser recovery. */
+export declare const captureShopOrderReceipt: (input: unknown) => ShopOrderReceipt;
+
+/** Capture required methods without invoking accessors; retain the original receiver, including class instances. */
+export declare const captureShopService: (input: ShopService) => ShopService;
+
+export declare const captureSpendLimitsOptions: (input: SpendLimitsOptions, currencies: readonly CurrencyDefinition[]) => Readonly<{
+    limits: readonly SpendLimit[];
+    source: SpendFactsSource;
+    version: string;
+    policy: SpendLimitPolicy;
+}>;
+
+export declare const captureSubscriptionReceiptIntent: (input: SubscriptionReceiptInput) => SubscriptionReceiptInput;
+
+export declare const captureSubscriptionsService: (input: SubscriptionsService) => SubscriptionsService;
+
+export declare const captureTradeLeg: (input: TradeLegDefinition | TradeLeg, declarations: readonly CurrencyDefinition[]) => TradeLeg;
+
+export declare const captureTradeObservation: (input: unknown) => TradeObservation;
+
+export declare const captureTradeParticipantAuthority: (value: unknown, tenantId: string, expectedOwner: string) => TradeParticipantAuthority;
+
+/** Pure detached wire shape only. New admission must still validate actual
+ * currencies and rules; originals compare before current declarations. */
+export declare const captureTradeProposeIntention: (input: TradeProposeInput) => Readonly<{
+    toId: string | null;
+    offered: TradeLeg;
+    requested: TradeLeg;
+    durationMs: number;
+    requestId: string;
+}>;
+
+export declare const captureTradeReceipt: (input: unknown) => TradeReceipt;
+
+export declare const captureTradesService: (input: TradesService) => TradesService;
+
+/** Browser-safe detached receipt shape, never a substitute for server custody/permission proof. */
+export declare const captureTradeView: (input: unknown) => TradeView;
+
+export declare interface CodeDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly campaign: string;
+    readonly items?: readonly {
+        readonly itemId: string | undefined;
+        readonly qty: number;
+    }[];
+    readonly currencies?: readonly {
+        readonly currency: string | undefined;
+        readonly amount: EconomyAmountInput;
+    }[];
+    readonly from?: number | null;
+    readonly until?: number | null;
+    readonly limits: {
+        readonly global: number;
+        readonly perPlayer: number;
+    };
+}
+
+export declare type CodeEligibility = (input: CodeEligibilityContext) => boolean;
+
+export declare interface CodeEligibilityContext {
+    readonly definition: PromoCode;
+    readonly at: number;
+    readonly claims: number;
+    readonly playerClaims: number;
+}
+
+export declare type CodeObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: CodeReceipt;
+};
+
+export declare interface CodePluginOptions extends Omit<CodeStoreOptions, 'currencies' | 'economy'> {
+    /** Complete replacement owns SQL authority, receipts and subject privacy. */
+    readonly service?: CodeService;
+    readonly querySources?: {
+        readonly receipt: readonly string[];
+    } | undefined;
+}
+
+export declare class CodePort extends CodePort_base {
+}
+
+declare const CodePort_base: Context.ServiceClass<CodePort, "@voltro/CodePort", CodeService>;
+
+export declare interface CodeReceipt {
+    readonly operationId: string;
+    readonly codeId: string;
+    readonly version: string;
+    readonly campaign: string;
+    readonly at: number;
+    readonly transfers: readonly {
+        readonly txId: string;
+        readonly currency: string;
+        readonly amount: string;
+        readonly at: number;
+    }[];
+    readonly grants: readonly {
+        readonly operationId: string;
+        readonly kind: 'grant';
+        readonly changes: readonly {
+            readonly instanceId: string;
+            readonly delta: number;
+        }[];
+        readonly at: number;
+    }[];
+}
+
+export declare interface CodeService {
+    readonly create: (subject: Subject, input: CreateCodeInput) => Effect.Effect<void, EconomyError>;
+    readonly redeem: (subject: Subject, input: RedeemCodeInput) => Effect.Effect<CodeReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: RedeemCodeInput) => Effect.Effect<CodeObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface CodeStoreOptions {
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer'>;
+    readonly inventory?: Pick<InventorySqlService, 'prepareGrant'> | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly eligibility?: CodeEligibility | undefined;
+    readonly version?: string | undefined;
+}
+
+declare interface Container {
+    readonly id: string;
+    readonly version: string;
+    readonly group: string;
+    readonly price: Price;
+    readonly drops: readonly ContainerDrop[];
+    readonly pity: Readonly<{
+        guaranteed: string;
+        after: number;
+        softFrom: number | null;
+        softRampBps: number;
+    }> | null;
+    readonly countries: readonly string[];
+}
+
+declare interface ContainerAccessContext {
+    readonly container: Container;
+    readonly at: number;
+    readonly isMinor: boolean;
+    readonly country: string;
+    readonly eligible: boolean;
+}
+
+declare interface ContainerAccessSource {
+    readonly read: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly container: Container;
+        readonly at: number;
+    }) => Effect.Effect<{
+        readonly isMinor: boolean;
+        readonly country: string;
+        readonly eligible: boolean;
+        readonly adjustments: readonly VirtualPriceAdjustment[];
+    }, EconomyError>;
+}
+
+declare interface ContainerDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly group?: string;
+    readonly price: PriceDefinition;
+    readonly drops: readonly ContainerDropDefinition[];
+    readonly pity?: {
+        readonly guaranteed: string;
+        readonly after: number;
+        readonly softFrom?: number;
+        readonly softRampBps?: number;
+    };
+    readonly countries?: readonly string[];
+}
+
+declare interface ContainerDistribution {
+    readonly entries: readonly ContainerProbabilityWeight[];
+    readonly total: string;
+    readonly guaranteed: boolean;
+}
+
+declare interface ContainerDrop {
+    readonly id: string;
+    readonly rarity: string;
+    readonly weight: string;
+    readonly items: readonly {
+        readonly itemId: string;
+        readonly qty: number;
+    }[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+}
+
+declare interface ContainerDropDefinition {
+    readonly id: string;
+    readonly rarity: string;
+    readonly weight: EconomyAmountInput;
+    readonly items?: readonly {
+        readonly itemId: string | undefined;
+        readonly qty: number;
+    }[];
+    readonly currencies?: readonly {
+        readonly currency: string | undefined;
+        readonly amount: EconomyAmountInput;
+    }[];
+}
+
+declare type ContainerEligibility = (input: ContainerAccessContext) => boolean;
+
+declare type ContainerObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: ContainerReceipt;
+};
+
+declare interface ContainerOpenInput {
+    readonly containerId: string;
+    readonly containerVersion: string;
+    readonly containerDigest: string;
+    readonly disclosureDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+}
+
+declare interface ContainerProbabilityContext {
+    readonly container: Container;
+    readonly misses: number;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+}
+
+declare type ContainerProbabilityResolver = (input: ContainerProbabilityContext) => readonly ContainerProbabilityWeight[];
+
+declare interface ContainerProbabilityWeight {
+    readonly dropId: string;
+    readonly weight: string;
+}
+
+declare interface ContainerRandomService {
+    readonly draw: (exclusiveMaximum: string) => Effect.Effect<string, EconomyError>;
+}
+
+declare interface ContainerReceipt {
+    readonly operationId: string;
+    readonly containerId: string;
+    readonly containerVersion: string;
+    readonly containerDigest: string;
+    readonly dropId: string;
+    readonly rarity: string;
+    readonly previousMisses: number;
+    readonly misses: number;
+    readonly sequence: number;
+    readonly at: number;
+    readonly distribution: ContainerDistribution;
+    readonly pricePaid: ShopOrderReceipt['pricePaid'];
+    readonly transfers: ShopOrderReceipt['transfers'];
+    readonly grants: ShopOrderReceipt['grants'];
+}
+
+declare interface ContainerRollContext {
+    readonly distribution: ContainerDistribution;
+    readonly draw: string;
+}
+
+declare type ContainerRollResolver = (input: ContainerRollContext) => string;
+
+export declare interface ContainersPluginOptions extends Omit<ContainersStoreOptions, 'currencies' | 'economy' | 'accessSource' | 'realMoney'> {
+    readonly accessSource?: ContainersStoreOptions['accessSource'];
+    readonly service?: ContainersService;
+    /** Full replacement requires actual sources; default may add app source tables. */
+    readonly querySources?: {
+        readonly list: readonly string[] | undefined;
+        readonly receipt: readonly string[];
+    };
+}
+
+declare interface ContainersService {
+    readonly list: (subject: Subject) => Effect.Effect<readonly ContainerView[], EconomyError>;
+    readonly open: (subject: Subject, input: ContainerOpenInput) => Effect.Effect<ContainerReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: ContainerOpenInput) => Effect.Effect<ContainerObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface ContainersStoreOptions {
+    readonly containers: readonly (ContainerDefinition | Container)[];
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer'>;
+    readonly inventory?: Pick<InventorySqlService, 'prepareGrant'> | undefined;
+    /** App-owned trusted age/country authority. No adult/allowed fallback. */
+    readonly accessSource: ContainerAccessSource;
+    readonly version: string;
+    readonly probability?: ContainerProbabilityResolver | undefined;
+    readonly roll?: ContainerRollResolver | undefined;
+    readonly random?: ContainerRandomService | undefined;
+    readonly eligibility?: ContainerEligibility | undefined;
+    readonly priceResolver?: PriceResolver | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+declare interface ContainerView {
+    readonly container: Container;
+    readonly containerDigest: string;
+    readonly disclosureDigest: string;
+    readonly misses: number;
+    readonly price: Price;
+    readonly disclosure: ReturnType<typeof discloseContainer>;
+}
+
+export declare interface CreateCodeInput {
+    readonly tenantId: string;
+    readonly code: string;
+    readonly definition: CodeDefinition | PromoCode;
+}
+
+export declare interface CurrencyDefinition {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap?: EconomyAmountInput;
+    readonly premium?: boolean;
+    readonly display?: {
+        readonly nameKey: string;
+    } | null;
+}
+
+/** One default, independently preserved as the hard safety envelope for custom
+ * rules. A custom rule can narrow admission; never raise captured code limits. */
+export declare const defaultCodeEligibility: CodeEligibility;
+
+export declare const defaultLoyaltyPerks: LoyaltyPerksResolver;
+
+export declare const defaultLoyaltyTier: LoyaltyTierResolver;
+
+export declare const defaultPiggyFill: PiggyFillPolicy;
+
+export declare const defaultPiggyReset: PiggyResetPolicy;
+
+/** The one actual default. A real-money reference never constitutes a receipt. */
+export declare const defaultPriceResolver: PriceResolver;
+
+/** Currency-specific virtual limits, not an exchange rate, legal age source,
+ * provider payment limit or consent/withdrawal implementation. */
+export declare const defaultSpendLimitPolicy: SpendLimitPolicy;
+
+/** Pure decision only. claimedDays must come from complete authoritative SQL
+ * grant receipts; a player cannot submit this context to a value-write route. */
+export declare const defaultSubscriptionDailyGrant: SubscriptionDailyGrantPolicy;
+
+/** UTC calendar windows anchored to original purchase, never the previously
+ * clamped renewal date. Thus Jan31 -> Feb28/29 -> Mar31 without monthly drift. */
+export declare const defaultSubscriptionPeriod: SubscriptionPeriodResolver;
+
+export declare const defaultTradeEligibilityPolicy: TradeEligibilityPolicy;
+
+/** Seller deduction, rounded upward; gross = net + tax exactly. No real-money
+ * channel or minted treasury value is part of a tax projection. */
+export declare const defaultTradeTaxPolicy: TradeTaxPolicy;
+
+/** Code values are supplied privately at runtime; declarations contain no code,
+ * provider credential, amount chosen by a player or alternative grant writer. */
+export declare const defineCode: (input: CodeDefinition | PromoCode, declarations: readonly CurrencyDefinition[]) => PromoCode;
+
+/** The framework invents no deployment currencies or prices. */
+export declare const defineCurrency: (definition: CurrencyDefinition) => ResolvedCurrency;
+
+export declare const defineLoyalty: (input: LoyaltyDefinition | Loyalty, declarations: readonly CurrencyDefinition[], realMoney?: boolean) => Loyalty;
+
+export declare const definePiggyBank: (input: PiggyBankDefinition | PiggyBank, declarations: readonly CurrencyDefinition[], realMoney?: boolean) => PiggyBank;
+
+/** Captures declarations and enforces the global real-money switch. */
+export declare const definePrice: (input: PriceDefinition, currencies: readonly CurrencyDefinition[], realMoney?: boolean) => Price;
+
+/** `grantless`: the offer may grant nothing, for a store subscription whose value is its paid
+ * period (an entitlement such as game time). Every other offer grants items or currencies. */
+export declare const defineShopOffer: (input: ShopOfferDefinition | ShopOffer, declarations: readonly CurrencyDefinition[], realMoney?: boolean, options?: {
+    readonly grantless?: boolean;
+}) => ShopOffer;
+
+export declare const defineSpendLimits: (input: readonly (SpendLimitDefinition | SpendLimit)[], declarations: readonly CurrencyDefinition[]) => readonly SpendLimit[];
+
+/** Content only. No entitlement, charge, automatic renewal or consent follows
+ * from declaring a price. Required UI copy/path must be rendered by a consumer. */
+export declare const defineSubscription: (input: SubscriptionDefinition | Subscription, declarations: readonly CurrencyDefinition[], realMoney?: boolean) => Subscription;
+
+export declare const defineTradeRules: (input: TradeRulesDefinition | TradeRules) => TradeRules;
+
+/** Public disclosure uses the exact same captured distribution as the draw. */
+declare const discloseContainer: (input: ContainerProbabilityContext, slot?: ContainerProbabilityResolver) => Readonly<{
+    guaranteed: boolean;
+    probabilities: readonly Readonly<{
+        dropId: string;
+        numerator: string;
+        denominator: string;
+    }>[];
+}>;
+
+export declare type EconomyAccount = {
+    readonly kind: 'wallet';
+    readonly ownerId: string;
+    readonly ownerKind: WalletOwnerKind;
+} | {
+    readonly kind: 'system';
+    readonly id: string;
+};
+
+export declare const economyAccountKey: (account: EconomyAccount) => string;
+
+/** Exact signed SQL BIGINT; wire values are canonical decimal strings. */
+export declare const economyAmount: (input: EconomyAmountInput) => bigint;
+
+export declare type EconomyAmountInput = string | number | bigint;
+
+export declare const economyAmountString: (input: EconomyAmountInput) => string;
+
+export declare type EconomyChannel = 'web' | 'ios' | 'android' | 'steam';
+
+/** System21 manifest of the optional redemption-code subsystem (`codes` option). */
+export declare const economyCodesSystemContract: Readonly<{
+    slots: {
+        codeEligibility: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        codes: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+declare interface EconomyConsistencyInput {
+    readonly tenantId: string;
+    readonly maxLedgerRows?: number | undefined;
+    readonly maxWallets?: number;
+}
+
+declare interface EconomyConsistencyResult {
+    readonly checked: number;
+    readonly mismatches: number;
+    readonly matches: boolean;
+    readonly ledgerRows: number;
+}
+
+declare interface EconomyConsistencyRunner {
+    readonly checkConsistency: (subject: Subject, input: EconomyConsistencyInput) => Effect.Effect<EconomyConsistencyResult, EconomyError>;
+}
+
+export declare const economyContainersSystemContract: Readonly<{
+    slots: {
+        containerProbability: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        containerRoll: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        containerEligibility: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        containers: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        containerRandom: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+/** Redacted codes; never carries owners, amounts or provider payloads. */
+export declare class EconomyError extends EconomyError_base {
+}
+
+declare const EconomyError_base: Schema.Class<EconomyError, Schema.TaggedStruct<"EconomyError", {
+    readonly code: Schema.Literals<readonly ["invalid_currency", "invalid_amount", "overflow", "invalid_price", "real_money_disabled", "invalid_input", "invalid_record", "currency_cap_reached", "insufficient_funds", "conflict", "forbidden", "unavailable", "not_found", "erased", "limit_exceeded", "already_redeemed"]>;
+}>, YieldableError>;
+
+export declare const economyIapSystemContract: Readonly<{
+    slots: {
+        iapEntitlementPolicy: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        iap: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        iapSystem: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        iapNotification: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        iapCurrentState: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        iapNotificationCustody: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        iapRefund: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        iapNotificationProcessor: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        iapNotificationsSystem: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        iapRefundEvents: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        iapEntitlements: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+export declare const economyLoyaltySystemContract: Readonly<{
+    slots: {
+        loyaltyTier: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        loyaltyPerks: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        loyalty: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+export declare const economyPiggyBanksSystemContract: Readonly<{
+    slots: {
+        piggyFill: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        piggyReset: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        piggyBanks: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+export declare interface EconomyPlugin extends VoltroPlugin {
+    readonly economy: {
+        readonly service: () => EconomyService;
+        readonly prepareEscrowReserve: EconomySqlService['prepareEscrowReserve'];
+        readonly prepareEscrowRelease: EconomySqlService['prepareEscrowRelease'];
+        readonly prepareEscrowSettle: EconomySqlService['prepareEscrowSettle'];
+        readonly prepareEscrowTaxSettle: EconomySqlService['prepareEscrowTaxSettle'];
+        readonly prepareEscrowReserveTaxSettle: EconomySqlService['prepareEscrowReserveTaxSettle'];
+        readonly escrow: EconomySqlService['escrow'];
+        readonly prepareTransfer: EconomySqlService['prepareTransfer'];
+        readonly checkConsistency: EconomyConsistencyRunner['checkConsistency'];
+        readonly iap: () => IapSystemService;
+        readonly iapEntitlements: () => IapEntitlementsService;
+        readonly iapNotifications: () => IapNotificationsSystemService;
+        readonly iapRefundEvents: () => IapRefundEventsService;
+        readonly shop: () => ShopService;
+        readonly codes: () => CodeService;
+        readonly containers: () => ContainersService;
+        readonly subscriptions: () => SubscriptionsService;
+        readonly loyalty: () => LoyaltyService;
+        readonly trades: () => TradesService;
+        readonly expireTrade: TradesSqlService['expire'];
+        readonly expireDueTrades: TradesSqlService['expireDue'];
+        readonly piggyBanks: () => PiggyBanksService;
+        /** Trusted reference-price projection; never grants value. */
+        readonly price: (subject: Subject, offerId: string, adjustments?: readonly VirtualPriceAdjustment[]) => Effect.Effect<Price, EconomyError>;
+    };
+}
+
+export declare const economyPlugin: (input: EconomyPluginOptions) => EconomyPlugin;
+
+export declare interface EconomyPluginOptions extends EconomyStoreOptions {
+    /** Full wallet replacement owns conservation, SQL authority, receipts and privacy. */
+    readonly service?: EconomySystemService;
+    /** Actual app-owned wallet query invalidation tables, required only for a replacement. */
+    readonly querySources?: readonly string[] | undefined;
+    /** Explicit non-default identity is required for a complete replacement. */
+    readonly version?: string | undefined;
+    readonly realMoney?: boolean;
+    /** Captured price declarations only; no shop or payment fulfillment is implied. */
+    readonly offers?: readonly {
+        readonly id: string;
+        readonly price: PriceDefinition;
+    }[];
+    readonly priceResolver?: PriceResolver | undefined;
+    readonly iap?: IapPluginOptions;
+    readonly shop?: ShopPluginOptions;
+    readonly codes?: CodePluginOptions;
+    readonly containers?: ContainersPluginOptions;
+    readonly subscriptions?: SubscriptionsPluginOptions;
+    readonly loyalty?: LoyaltyPluginOptions;
+    readonly trades?: TradesPluginOptions;
+    readonly piggyBanks?: PiggyPluginOptions;
+}
+
+export declare class EconomyPort extends EconomyPort_base {
+}
+
+declare const EconomyPort_base: Context.ServiceClass<EconomyPort, "@voltro/EconomyPort", EconomyService>;
+
+export declare interface EconomyReceipt {
+    readonly txId: string;
+    readonly currency: string;
+    readonly amount: string;
+    readonly at: number;
+}
+
+export declare interface EconomyReference {
+    readonly kind: string;
+    readonly id: string;
+}
+
+export declare interface EconomyService {
+    /** Trusted server transfer, never a player-authored value mutation. */
+    readonly transfer: (subject: Subject, input: LedgerTransferInput) => Effect.Effect<EconomyReceipt, EconomyError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly EconomyWallet[], EconomyError>;
+    readonly auditWallet: (subject: Subject, tenantId: string, account: EconomyAccount, currency: string) => Effect.Effect<EconomyWalletAudit, EconomyError>;
+    readonly rebuildWallet: (subject: Subject, tenantId: string, account: EconomyAccount, currency: string) => Effect.Effect<EconomyWalletAudit, EconomyError>;
+}
+
+export declare const economyShopSystemContract: Readonly<{
+    slots: {
+        experimentBucket: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        personalizedOfferSelector: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        flashTrigger: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        shop: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+export declare const economySpendLimitsSystemContract: Readonly<{
+    slots: {
+        spendLimitPolicy: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        economy: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+declare interface EconomySqlService extends EconomySystemService, WalletEscrowParticipant {
+    /** Trusted original purchase evidence required; no player price, owner or state authority. */
+    readonly prepareIapRefund: (subject: Subject, proof: VerifiedIapCurrentState, input: IapWalletRefundInput) => Effect.Effect<PreparedSqlMutation<EconomyReceipt>, EconomyError>;
+    readonly prepareTransfer: (subject: Subject, input: LedgerTransferInput) => Effect.Effect<PreparedSqlMutation<EconomyReceipt>, EconomyError>;
+}
+
+declare interface EconomyStoreOptions {
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly allowedServices?: readonly string[] | undefined;
+    /** Whole-work bounds; excess refuses rather than returning a prefix. */
+    readonly maxLedgerRows?: number | undefined;
+    readonly maxExportRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly spendLimits?: SpendLimitsOptions | undefined;
+}
+
+export declare const economySubscriptionsSystemContract: Readonly<{
+    slots: {
+        subscriptionPeriod: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        subscriptionDaily: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        subscriptions: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+/** System21 manifest of the installed core wallet system. Optional subsystems (shop, codes, containers,
+ * subscriptions, loyalty, piggy banks, trades, IAP) contribute their own slots, ports and tables. */
+export declare const economySystemContract: Readonly<{
+    slots: {
+        priceResolver: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        economy: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+/** Full installed replacement adds both privacy hooks; the dependent port stays four methods. */
+export declare interface EconomySystemService extends EconomyService {
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+export declare const economyTradesSystemContract: Readonly<{
+    slots: {
+        tradeTax: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        tradeEligibility: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        trades: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+export declare interface EconomyWallet {
+    readonly currency: string;
+    readonly balance: string;
+    readonly updatedAt: number | null;
+}
+
+export declare interface EconomyWalletAudit {
+    readonly currency: string;
+    readonly balance: string;
+    readonly ledgerBalance: string;
+    readonly ledgerRows: number;
+    readonly matches: boolean;
+}
+
+declare type EscrowWallet = Extract<EconomyAccount, {
+    readonly kind: 'wallet';
+}>;
+
+declare interface IapAccountBindingService {
+    /** Observe existing SQL binding only; no mint, seed, fence update or ownership write. */
+    readonly observe: (scope: IapScope, channel: EconomyChannel, environment: IapEnvironment) => Effect.Effect<string, EconomyError>;
+    readonly read: (scope: IapScope, channel: EconomyChannel, environment: IapEnvironment) => Effect.Effect<string, EconomyError>;
+    readonly prepareBinding: (scope: IapScope, channel: EconomyChannel, environment: IapEnvironment, token: string) => Effect.Effect<PreparedSqlMutation<unknown>, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+/** A web checkout about to start: nothing is paid or verified yet. */
+declare interface IapCheckoutAdmission {
+    readonly scope: IapScope;
+    readonly product: IapProduct;
+    readonly at: number;
+}
+
+/** One purchase a provider is asked to start: the owner, the selected offer and where the
+ * player returns afterwards. The account token binds the later receipt to this owner. */
+declare interface IapCheckoutContext {
+    readonly scope: IapScope;
+    readonly product: IapProduct;
+    readonly requestId: string;
+    readonly accountToken: string;
+    readonly returnUrl: string;
+    readonly at: number;
+}
+
+/** Provider-owned web checkout (Stripe, Paddle, an app's own PSP, ...). Construction does no
+ * I/O; `initialize` checks credentials. Verification of the paid checkout stays with the same
+ * provider's `IapVerificationAuthority`, which must check the bound account token. */
+declare interface IapCheckoutService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly start: (context: IapCheckoutContext) => Effect.Effect<IapCheckoutSession, EconomyError>;
+}
+
+/** A started provider checkout. `checkoutId` is the receipt the player redeems afterwards. */
+declare interface IapCheckoutSession {
+    readonly checkoutId: string;
+    readonly redirectUrl: string;
+    readonly expiresAt: number;
+}
+
+declare interface IapCompletionReceipt {
+    readonly orderId: string;
+    readonly channel: EconomyChannel;
+    readonly operation: 'acknowledge' | 'consume' | 'finalize' | 'finish';
+    readonly observedAt: number;
+}
+
+declare interface IapCompletionService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly complete: (evidence: AcceptedIapCompletion) => Effect.Effect<IapCompletionReceipt, EconomyError>;
+}
+
+declare interface IapCurrentPurchaseState {
+    readonly orderId: string;
+    readonly channel: IapRefundChannel;
+    readonly state: 'active' | 'partially-refunded' | 'revoked';
+    /** Exact cumulative provider refund share; never floating point or money sent by a player. */
+    readonly refundNumerator: number;
+    readonly refundDenominator: number;
+    readonly observedAt: number;
+    readonly revokedAt: number | null;
+}
+
+declare interface IapCurrentStateService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly read: (target: AcceptedIapNotificationTarget) => Effect.Effect<VerifiedIapCurrentState, EconomyError>;
+}
+
+declare type IapDebtPolicy = 'allowNegative' | 'blockSpend';
+
+/** A purchase or subscription renewal the provider reports on its own (a webhook), for the
+ * owner it once received as account token at checkout. Redeemed through the same pipeline as a
+ * player's redeem: the same `requestId` + `receipt` converge on one order. */
+declare interface IapDelivery {
+    readonly accountToken: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly requestId: string;
+    readonly receipt: string;
+}
+
+/** Provider-owned delivery reader on the channel's notification route. `read` authenticates the
+ * request and returns `null` when it carries nothing to deliver; the request then continues to
+ * the notification pipeline (refunds, disputes). */
+declare interface IapDeliveryService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly read: (input: IapNotificationInput) => Effect.Effect<IapDelivery | null, EconomyError>;
+}
+
+declare interface IapEntitlementObservation {
+    readonly offerId: string;
+    readonly entitled: boolean;
+    readonly expiresAt: number | null;
+    readonly observedAt: number;
+}
+
+declare type IapEntitlementPolicy = (context: IapEntitlementPolicyContext) => boolean;
+
+declare interface IapEntitlementPolicyContext {
+    readonly period: IapSubscriptionPeriod;
+    readonly at: number;
+}
+
+declare interface IapEntitlementsPluginOptions {
+    readonly version: string;
+    readonly policy?: IapEntitlementPolicy;
+    readonly service?: IapEntitlementsService;
+    readonly querySources?: readonly string[] | undefined;
+}
+
+declare interface IapEntitlementsService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly entitled: (subject: Subject, offerId: string) => Effect.Effect<IapEntitlementObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare type IapEnvironment = 'sandbox' | 'production';
+
+/** Where an owner manages what they pay for (cancel a subscription, change the card). */
+declare interface IapManagementContext {
+    readonly accountToken: string;
+    /** The provider's original transaction IDs (subscriptions) of the owner's accepted orders on
+     * this channel, newest first; empty when the owner holds none. */
+    readonly originals: readonly string[];
+    readonly returnUrl: string;
+    readonly at: number;
+}
+
+declare interface IapManagementService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    /** A provider page for this owner; `not_found` when the owner has nothing to manage there. */
+    readonly open: (context: IapManagementContext) => Effect.Effect<{
+        readonly url: string;
+    }, EconomyError>;
+}
+
+declare interface IapNotificationCipherSource {
+    /** Default is the registered framework FieldCipher. Explicit sources use that same codec/row binding contract. */
+    readonly read: () => FieldCipher | undefined;
+}
+
+declare interface IapNotificationCustodyReceipt {
+    readonly id: string;
+    readonly orderId: string;
+    readonly state: 'pending' | 'processed' | 'expired' | 'erased';
+}
+
+declare interface IapNotificationInput {
+    readonly body: string;
+    /** Actual HTTP Authorization header for authenticated Pub/Sub push; never query/body authority. */
+    readonly authorization?: string;
+    /** The request's other headers, lowercased and bounded, for providers that sign in a header
+     * (Stripe: `stripe-signature`). Never authority by themselves. */
+    readonly headers?: Readonly<Record<string, string>>;
+}
+
+declare interface IapNotificationProcessorService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    /** `null`: an authenticated test notice (a store's TEST message, a provider event with no
+     * purchase in it) is acknowledged and not retained; no retry could ever process it. */
+    readonly ingest: (input: IapNotificationInput) => Effect.Effect<IapNotificationCustodyReceipt | null, EconomyError>;
+    readonly process: (id: string) => Effect.Effect<IapNotificationCustodyReceipt, EconomyError>;
+    readonly pending: () => Effect.Effect<readonly IapNotificationCustodyReceipt[], EconomyError>;
+    readonly prune: () => Effect.Effect<number, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface IapNotificationService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly verify: (input: IapNotificationInput) => Effect.Effect<VerifiedIapNotification, EconomyError>;
+}
+
+declare interface IapNotificationsPluginOptions {
+    readonly version: string;
+    readonly pathPrefix?: string;
+    readonly maxBodyBytes?: number;
+    readonly bodyRetentionMs?: number | undefined;
+    readonly debtPolicy?: IapDebtPolicy | undefined;
+    readonly assets?: IapRefundAssetParticipant | undefined;
+    readonly assetsVersion?: string | undefined;
+    readonly maxNoticeRows?: number;
+    readonly maxRefundRows?: number;
+    readonly cipher?: IapNotificationCipherSource | undefined;
+    /** Complete replacement owns authentication/current state/financial authority, queue and privacy. */
+    readonly service?: IapNotificationsSystemService;
+    /** Complete notification replacements may expose their own three-method event queue. */
+    readonly refundEvents?: IapRefundEventsService;
+    /** Custom borrowed-transaction SQL read. Omit when the custom system exposes no own order disposition. */
+    readonly refundDisposition?: IapRefundDispositionSource | undefined;
+    /** Runs after a notice changed a purchase (a refund, a revocation), e.g. to end game time at once:
+     * `rooms.moderation.recheckAccess({ tenantId, subjectId: ownerId })`. Best effort: a failure is
+     * ignored and the notice stays processed. Not with a complete replacement `service`. */
+    readonly onChange?: ((change: IapPurchaseChange) => Effect.Effect<void, unknown>) | undefined;
+}
+
+declare interface IapNotificationsSystemService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly processor: (channel: EconomyChannel) => Effect.Effect<IapNotificationProcessorService, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare type IapOrderObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: IapOrderReceipt;
+    readonly refund?: IapRefundDisposition;
+} | {
+    readonly requestId: string;
+    readonly state: 'partially-refunded' | 'refunded';
+    readonly receipt: IapOrderReceipt;
+    readonly refund: IapRefundDisposition;
+};
+
+declare interface IapOrderReceipt {
+    readonly orderId: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly quantity: number;
+    readonly at: number;
+    readonly pricePaid: IapPaidAmount | null;
+    readonly transfers: readonly {
+        readonly txId: string;
+        readonly currency: string;
+        readonly amount: string;
+        readonly at: number;
+    }[];
+    readonly grants: readonly {
+        readonly operationId: string;
+        readonly kind: 'grant';
+        readonly changes: readonly {
+            readonly instanceId: string;
+            readonly delta: number;
+        }[];
+        readonly at: number;
+    }[];
+}
+
+/** Provider units retain their own decimal scale. Reference prices are never substituted. */
+declare interface IapPaidAmount {
+    readonly currency: string;
+    readonly units: string;
+    readonly scale: number;
+}
+
+declare interface IapPluginOptions {
+    readonly version: string;
+    readonly products: readonly IapProductDefinition[];
+    readonly providers?: readonly IapProviderDefinition[];
+    readonly namespace?: string;
+    readonly admission?: IapStoreOptions['admission'] | undefined;
+    readonly inventory?: IapStoreOptions['inventory'] | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly notifications?: IapNotificationsPluginOptions | undefined;
+    readonly entitlements?: IapEntitlementsPluginOptions;
+    readonly service?: IapSystemService;
+    readonly querySources?: {
+        readonly receipt: readonly string[];
+    } | undefined;
+}
+
+declare interface IapProduct {
+    readonly offer: ShopOffer;
+    readonly channel: EconomyChannel;
+    readonly kind: IapProductKind;
+    readonly storeProductId: string;
+}
+
+declare interface IapProductDefinition {
+    readonly offer: ShopOfferDefinition | ShopOffer;
+    readonly channel: EconomyChannel;
+    readonly kind: IapProductKind;
+}
+
+declare type IapProductKind = 'consumable' | 'non-consumable' | 'subscription';
+
+declare interface IapProviderContext {
+    readonly realMoney: true;
+    readonly channel: EconomyChannel;
+    readonly environment: IapEnvironment;
+    readonly applicationId: string;
+    readonly products: readonly IapProductDefinition[];
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly accounts: IapAccountBindingService;
+    readonly now: () => number;
+}
+
+declare interface IapProviderDefinition {
+    readonly channel: EconomyChannel;
+    readonly environment: IapEnvironment;
+    readonly applicationId: string;
+    /** Server-owned verifier factory. Construction does no I/O; initialize is awaited at activation. */
+    readonly create: (context: IapProviderContext) => IapVerificationService;
+    /** Optional authenticated notification authority, initialized only when configured. */
+    readonly createNotifications?: ((context: IapProviderContext) => IapNotificationService) | undefined;
+    readonly createCurrentState?: ((context: IapProviderContext) => IapCurrentStateService) | undefined;
+    /** Optional server completion authority, initialized before this IAP system activates. */
+    readonly createCompletion?: ((context: IapProviderContext) => IapCompletionService) | undefined;
+    /** Optional web checkout (`economy.iap.checkout`): the provider starts a hosted payment and
+     * the player redeems its `checkoutId` as the receipt. Any payment provider fits. */
+    readonly createCheckout?: ((context: IapProviderContext) => IapCheckoutService) | undefined;
+    /** Origins a checkout may return to (`https://game.example`); required with `createCheckout`. */
+    readonly checkoutReturnOrigins?: readonly string[] | undefined;
+    /** Optional provider-delivered purchases and subscription renewals, read on the channel's
+     * notification route (needs `notifications`). Each is redeemed for the owner of its account token. */
+    readonly createDeliveries?: ((context: IapProviderContext) => IapDeliveryService) | undefined;
+    /** Optional provider page where the owner manages subscriptions (`economy.iap.manage`). */
+    readonly createManagement?: ((context: IapProviderContext) => IapManagementService) | undefined;
+}
+
+declare interface IapPurchaseAdmission {
+    readonly scope: IapScope;
+    readonly product: IapProduct;
+    readonly facts: IapTransactionFacts;
+    readonly at: number;
+}
+
+/** Required real SQL age/consent/spend eligibility authority. No permissive default. */
+declare interface IapPurchaseAdmissionSource {
+    readonly prepare: (input: IapPurchaseAdmission) => Effect.Effect<PreparedSqlMutation<unknown>, EconomyError>;
+    /** Optional check before a web checkout starts. Refuse what `prepare` would certainly
+     * refuse, so the player is never charged for a purchase that cannot be redeemed;
+     * `prepare` stays the authority. */
+    readonly checkout?: (input: IapCheckoutAdmission) => Effect.Effect<void, EconomyError>;
+}
+
+/** A store or provider notice changed a purchase: a refund, a revocation. `ownerId` is the player. */
+declare interface IapPurchaseChange {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly orderId: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly state: IapRefundReceipt['state'];
+}
+
+declare interface IapReceiptIntent {
+    readonly channel: EconomyChannel;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly requestId: string;
+    /** Opaque store evidence. Never log or persist this in player receipts. */
+    readonly receipt: string;
+}
+
+/** Read-only original-intention reference. Never send raw receipts in query parameters. */
+declare interface IapReceiptReference {
+    readonly channel: EconomyChannel;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly requestId: string;
+    readonly receiptDigest: string;
+}
+
+declare interface IapRefundAssetContext {
+    readonly original: IapSqlOriginalPurchase;
+    readonly state: IapCurrentPurchaseState;
+    readonly previous: IapRefundReceipt | null;
+    readonly sequence: number;
+}
+
+/** Mandatory for orders with item grants. It must use the same real store and original grant custody. */
+declare interface IapRefundAssetParticipant {
+    readonly prepare: (input: IapRefundAssetContext) => Effect.Effect<PreparedSqlMutation<unknown>, EconomyError>;
+    readonly validate: (input: IapRefundAssetContext, receipt: unknown) => unknown;
+    /** SQL-only audit of accepted movement receipts; no provider/application callbacks. */
+    readonly audit: (tx: DataStore, input: IapRefundAssetContext, receipt: unknown) => Promise<void>;
+}
+
+/** Channels whose providers report refunds and revocations to the economy. */
+declare type IapRefundChannel = 'ios' | 'android' | 'web';
+
+declare interface IapRefundCurrency {
+    readonly currency: string;
+    readonly original: string;
+    readonly refunded: string;
+}
+
+/** Accepted SQL refund history only. This projection never authorizes a grant or completion. */
+declare interface IapRefundDisposition {
+    readonly sequence: number;
+    readonly state: 'active' | 'partially-refunded' | 'revoked';
+    readonly refundNumerator: number;
+    readonly refundDenominator: number;
+    readonly observedAt: number;
+}
+
+/** Borrowed transaction read only: no provider, nested transaction, seed, clock or mutation. */
+declare interface IapRefundDispositionSource {
+    readonly read: (tx: DataStore, original: IapSqlOriginalPurchase) => Promise<IapRefundDisposition | null>;
+}
+
+declare interface IapRefundEventContext {
+    readonly namespace: string;
+    readonly tenantId: string;
+    readonly subjectId: string;
+    readonly payload: IapRefundEventPayload;
+    /** Complete bounded accepted history; these are observations, never a fraud verdict. */
+    readonly refundedOrders: number;
+    readonly observedOrders: number;
+    readonly refundAdjustments: number;
+}
+
+declare type IapRefundEventPayload = typeof IapRefundEventPayloadSchema.Type;
+
+declare const IapRefundEventPayloadSchema: Schema.Struct<{
+    readonly eventId: Schema.String;
+    readonly orderId: Schema.String;
+    readonly sequence: Schema.Number;
+    readonly state: Schema.Literals<readonly ["active", "partially-refunded", "revoked"]>;
+    readonly refundNumerator: Schema.Number;
+    readonly refundDenominator: Schema.Number;
+    readonly observedAt: Schema.Number;
+}>;
+
+declare interface IapRefundEventsService {
+    readonly pending: (subject: Subject) => Effect.Effect<readonly PendingIapRefundEvent[], EconomyError>;
+    readonly read: (subject: Subject, event: PendingIapRefundEvent) => Effect.Effect<IapRefundEventContext, EconomyError>;
+    readonly acknowledge: (subject: Subject, event: PendingIapRefundEvent, deliveryVersion: string) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface IapRefundReceipt {
+    readonly orderId: string;
+    readonly sequence: number;
+    readonly state: IapCurrentPurchaseState['state'];
+    readonly refundNumerator: number;
+    readonly refundDenominator: number;
+    readonly observedAt: number;
+    readonly noticeId: string;
+    readonly fingerprint: string;
+    readonly debtPolicy: IapDebtPolicy;
+    readonly currencies: readonly IapRefundCurrency[];
+    readonly transfers: readonly EconomyReceipt[];
+    /** Opaque actual asset participant receipt, validated by its captured participant. */
+    readonly assets: unknown;
+}
+
+declare interface IapScope {
+    readonly tenantId: string;
+    readonly ownerId: string;
+}
+
+declare interface IapService {
+    readonly redeem: (subject: Subject, input: IapReceiptIntent) => Effect.Effect<IapOrderReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: IapReceiptReference) => Effect.Effect<IapOrderObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+/** SQL original after the owning adapter has validated its immutable custody and receipt. */
+declare interface IapSqlOriginalPurchase {
+    readonly orderId: string;
+    readonly scope: IapScope;
+    readonly receipt: IapOrderReceipt;
+    readonly product: IapProduct;
+    readonly facts: IapTransactionFacts;
+    readonly currencies: readonly CurrencyDefinition[];
+}
+
+declare interface IapStoreOptions {
+    readonly realMoney: boolean;
+    /** Operator-owned immutable work/privacy namespace, never an RPC input. */
+    readonly namespace: string;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly verification: Pick<IapVerificationService, 'verify'>;
+    readonly admission: IapPurchaseAdmissionSource;
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer'>;
+    readonly inventory?: Pick<InventorySqlService, 'prepareGrant'> | undefined;
+    readonly refundDisposition?: IapRefundDispositionSource | undefined;
+    readonly systemAccount: string;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+/** An accepted store period, not a fresh provider observation or financial capability. */
+declare interface IapSubscriptionPeriod {
+    readonly orderId: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly channel: EconomyChannel;
+    readonly startsAt: number;
+    readonly expiresAt: number;
+    readonly refund: IapRefundDisposition | null;
+}
+
+/** Complete system replacement owns provider readiness, accounts, financial authority and privacy. */
+declare interface IapSystemService extends IapService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly account: (subject: Subject, channel: EconomyChannel) => Effect.Effect<string, EconomyError>;
+    /** Explicit retry of the same accepted original intent. Never redeems or grants. */
+    readonly complete: (subject: Subject, intent: Parameters<IapService['redeem']>[1]) => Effect.Effect<IapCompletionReceipt, EconomyError>;
+}
+
+declare interface IapTransactionFacts {
+    readonly channel: EconomyChannel;
+    readonly environment: IapEnvironment;
+    readonly applicationId: string;
+    readonly transactionId: string;
+    readonly originalTransactionId: string | null;
+    readonly storeProductId: string;
+    readonly kind: IapProductKind;
+    readonly quantity: number;
+    readonly purchasedAt: number;
+    readonly expiresAt: number | null;
+    readonly paid: IapPaidAmount | null;
+    readonly acknowledgement: 'none' | 'pending' | 'acknowledged';
+    readonly consumption: 'none' | 'available' | 'consumed';
+}
+
+declare interface IapVerificationService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly verify: (scope: IapScope, input: IapReceiptIntent) => Effect.Effect<VerifiedIapPurchase, EconomyError>;
+}
+
+declare interface IapWalletRefundInput {
+    readonly requestId: string;
+    readonly currency: string;
+    readonly amount: string;
+    readonly debtPolicy: IapDebtPolicy;
+}
+
+export declare interface LedgerPosting {
+    readonly account: EconomyAccount;
+    readonly debit: string;
+    readonly credit: string;
+}
+
+export declare interface LedgerTransfer {
+    readonly tenantId: string;
+    readonly requestId: string;
+    readonly currency: string;
+    readonly amount: string;
+    readonly reason: string;
+    readonly ref: EconomyReference;
+    readonly postings: readonly [LedgerPosting, LedgerPosting];
+}
+
+export declare interface LedgerTransferInput {
+    readonly tenantId: string;
+    readonly requestId: string;
+    readonly currency: string;
+    readonly from: EconomyAccount;
+    readonly to: EconomyAccount;
+    readonly amount: EconomyAmountInput;
+    readonly reason: string;
+    readonly ref: EconomyReference;
+}
+
+export declare interface Loyalty {
+    readonly id: string;
+    readonly version: string;
+    readonly titleKey: string;
+    readonly pointsFrom: readonly {
+        readonly id: string;
+        readonly kind: 'purchase.real' | 'purchase.virtual';
+        readonly currency: string;
+        readonly numerator: string;
+        readonly denominator: string;
+    }[];
+    readonly tiers: readonly {
+        readonly id: string;
+        readonly at: string;
+        readonly perks: readonly LoyaltyPerk[];
+    }[];
+    readonly decay: 'none' | 'seasonal';
+}
+
+/** Only trusted server callers name receipts. Amounts, weights, points, tiers
+ * and seasons are never request fields. No player credit/reverse action. */
+export declare interface LoyaltyCreditInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly loyaltyId: string;
+    readonly sourceId: string;
+    readonly purchaseId: string;
+    readonly requestId: string;
+}
+
+export declare const loyaltyCreditIntent: (input: LoyaltyCreditInput) => LoyaltyCreditInput;
+
+export declare interface LoyaltyDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly titleKey: string;
+    readonly pointsFrom: readonly {
+        readonly id: string;
+        readonly kind: 'purchase.real' | 'purchase.virtual';
+        readonly currency: string;
+        readonly numerator: EconomyAmountInput;
+        readonly denominator: EconomyAmountInput;
+    }[];
+    readonly tiers: readonly {
+        readonly id: string;
+        readonly at: EconomyAmountInput;
+        readonly perks: readonly LoyaltyPerkDefinition[];
+    }[];
+    readonly decay?: 'none' | 'seasonal';
+}
+
+export declare interface LoyaltyMineInput {
+    readonly loyaltyId: string;
+}
+
+export declare const loyaltyMineIntent: (input: LoyaltyMineInput) => LoyaltyMineInput;
+
+export declare type LoyaltyObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: LoyaltyReceipt;
+};
+
+export declare type LoyaltyPerk = Exclude<LoyaltyPerkDefinition, {
+    readonly kind: 'inboxGift';
+}> | {
+    readonly id: string;
+    readonly kind: 'inboxGift';
+    readonly items: readonly ShopItemGrant[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+};
+
+export declare type LoyaltyPerkDefinition = {
+    readonly id: string;
+    readonly kind: 'xpMultiplier';
+    readonly bps: number;
+} | {
+    readonly id: string;
+    readonly kind: 'discount';
+    readonly bps: number;
+} | {
+    readonly id: string;
+    readonly kind: 'chatBadge';
+    readonly badgeId: string;
+} | {
+    readonly id: string;
+    readonly kind: 'inboxGift';
+    readonly items?: readonly ShopItemGrant[] | undefined;
+    readonly currencies?: readonly ShopCurrencyGrant[] | undefined;
+};
+
+export declare interface LoyaltyPerksContext extends LoyaltyTierContext {
+    readonly tierId: string;
+}
+
+export declare type LoyaltyPerksResolver = (input: LoyaltyPerksContext) => readonly LoyaltyPerk[];
+
+declare interface LoyaltyPluginOptions extends Omit<LoyaltyStoreOptions, 'currencies' | 'realMoney' | 'receiptSource'> {
+    readonly receiptSource?: LoyaltyStoreOptions['receiptSource'];
+    readonly service?: LoyaltyService;
+    readonly querySources?: {
+        readonly list: readonly string[] | undefined;
+        readonly mine: readonly string[];
+        readonly receipt: readonly string[];
+    };
+}
+
+export declare type LoyaltyPointEntry = {
+    readonly id: string;
+    readonly sequence: number;
+    readonly kind: 'credit';
+    readonly at: number;
+    readonly sourceId: string;
+    readonly purchaseId: string;
+    readonly seasonId: string | null;
+    readonly purchaseAmount: string;
+    readonly numerator: string;
+    readonly denominator: string;
+    readonly delta: string;
+} | {
+    readonly id: string;
+    readonly sequence: number;
+    readonly kind: 'reverse';
+    readonly at: number;
+    readonly originalId: string;
+    readonly refundId: string;
+    readonly seasonId: string | null;
+    readonly totalRefunded: string;
+    readonly delta: string;
+};
+
+export declare interface LoyaltyPointProjection {
+    readonly entries: readonly LoyaltyPointEntry[];
+    readonly balances: readonly {
+        readonly seasonId: string | null;
+        readonly points: string;
+    }[];
+    readonly credits: readonly {
+        readonly id: string;
+        readonly refundedAmount: string;
+        readonly remainingPoints: string;
+    }[];
+}
+
+/** Trusted verified settlement projection only, not a player input/receipt
+ * validator. Exact floor rounding is defined once per accepted purchase; a full
+ * reversal must reverse its recorded credit, never independently reround it. */
+export declare const loyaltyPointsForPurchase: (input: LoyaltyDefinition | Loyalty, sourceId: string, amount: EconomyAmountInput, currencies: readonly CurrencyDefinition[], realMoney?: boolean) => string;
+
+export declare class LoyaltyPort extends LoyaltyPort_base {
+}
+
+declare const LoyaltyPort_base: Context.ServiceClass<LoyaltyPort, "@voltro/LoyaltyPort", LoyaltyService>;
+
+/** Receipt authority must use immutable accepted SQL/provider evidence, verify
+ * ownership and canonical purchase identity independently of source aliases,
+ * and refuse revoked/unsettled/already-refunded purchases. No player evidence. */
+declare interface LoyaltyPurchaseEvidence {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly authorityId: string;
+    readonly purchaseId: string;
+    readonly kind: 'purchase.real' | 'purchase.virtual';
+    readonly currency: string;
+    readonly amount: string;
+    readonly settledAt: number;
+    readonly refundedAmount: '0';
+}
+
+export declare interface LoyaltyRebuildInput extends LoyaltyMineInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+}
+
+export declare const loyaltyRebuildIntent: (input: LoyaltyRebuildInput) => LoyaltyRebuildInput;
+
+export declare interface LoyaltyReceipt {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly loyaltyId: string;
+    readonly entry: LoyaltyPointEntry;
+    readonly points: string;
+}
+
+export declare interface LoyaltyReceiptInput {
+    readonly requestId: string;
+}
+
+export declare const loyaltyReceiptIntent: (input: LoyaltyReceiptInput) => LoyaltyReceiptInput;
+
+declare interface LoyaltyReceiptSource {
+    readonly purchase: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly source: Loyalty['pointsFrom'][number];
+        readonly purchaseId: string;
+    }) => Effect.Effect<LoyaltyPurchaseEvidence, EconomyError>;
+    readonly refund: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly purchase: LoyaltyPurchaseEvidence;
+        readonly refundId: string;
+    }) => Effect.Effect<LoyaltyRefundEvidence, EconomyError>;
+}
+
+declare interface LoyaltyRefundEvidence {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly authorityId: string;
+    readonly purchaseId: string;
+    readonly refundId: string;
+    readonly totalRefunded: string;
+    readonly refundedAt: number;
+}
+
+export declare interface LoyaltyReverseInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly loyaltyId: string;
+    readonly originalId: string;
+    readonly refundId: string;
+    readonly requestId: string;
+}
+
+export declare const loyaltyReverseIntent: (input: LoyaltyReverseInput) => LoyaltyReverseInput;
+
+declare interface LoyaltySeason {
+    readonly id: string;
+    readonly startsAt: number;
+    readonly endsAt: number;
+}
+
+declare interface LoyaltySeasonSource {
+    readonly read: (input: {
+        readonly tenantId: string;
+        readonly loyaltyId: string;
+        readonly at: number;
+    }) => Effect.Effect<LoyaltySeason, EconomyError>;
+}
+
+export declare interface LoyaltyService {
+    readonly list: (subject: Subject) => Effect.Effect<readonly Loyalty[], EconomyError>;
+    readonly mine: (subject: Subject, input: LoyaltyMineInput) => Effect.Effect<LoyaltyState, EconomyError>;
+    readonly credit: (subject: Subject, input: LoyaltyCreditInput) => Effect.Effect<LoyaltyReceipt, EconomyError>;
+    readonly reverse: (subject: Subject, input: LoyaltyReverseInput) => Effect.Effect<LoyaltyReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: LoyaltyReceiptInput) => Effect.Effect<LoyaltyObservation, EconomyError>;
+    readonly rebuild: (subject: Subject, input: LoyaltyRebuildInput) => Effect.Effect<LoyaltyPointProjection, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+export declare interface LoyaltyState {
+    readonly loyalty: Loyalty;
+    readonly rulesVersion: string;
+    readonly seasonId: string | null;
+    readonly points: string;
+    readonly tierId: string;
+    readonly perks: readonly LoyaltyPerk[];
+}
+
+declare interface LoyaltyStoreOptions {
+    readonly loyalty: readonly (LoyaltyDefinition | Loyalty)[];
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly receiptSource: LoyaltyReceiptSource;
+    readonly seasonSource?: LoyaltySeasonSource | undefined;
+    readonly version: string;
+    readonly tier?: LoyaltyTierResolver | undefined;
+    readonly perks?: LoyaltyPerksResolver | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly maxDefinitionRows?: number | undefined;
+    readonly maxSeasonRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+export declare interface LoyaltyTierContext {
+    readonly loyalty: Loyalty;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly points: EconomyAmountInput;
+    readonly rulesVersion?: string;
+}
+
+export declare type LoyaltyTierResolver = (context: LoyaltyTierContext) => string;
+
+/** Actual pending SQL event authority. Copies and serialized payloads cannot authorize delivery acknowledgement. */
+declare interface PendingIapRefundEvent {
+    readonly [refundEvent]: true;
+    readonly eventId: string;
+}
+
+export declare interface PiggyBank {
+    readonly id: string;
+    readonly version: string;
+    readonly titleKey: string;
+    readonly currency: string;
+    readonly cap: string;
+    readonly unlock: Price;
+    readonly fillFrom: readonly string[];
+    readonly reset: 'onUnlock';
+}
+
+export declare interface PiggyBankDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly titleKey: string;
+    readonly currency: string;
+    readonly cap: EconomyAmountInput;
+    readonly unlock: PriceDefinition;
+    readonly fillFrom: readonly string[];
+    readonly reset?: 'onUnlock' | undefined;
+}
+
+export declare class PiggyBanksPort extends PiggyBanksPort_base {
+}
+
+declare const PiggyBanksPort_base: Context.ServiceClass<PiggyBanksPort, "@voltro/PiggyBanksPort", PiggyBanksService>;
+
+export declare interface PiggyBanksService {
+    readonly list: (subject: Subject) => Effect.Effect<readonly PiggyView[], EconomyError>;
+    readonly fill: (subject: Subject, input: PiggyFillInput) => Effect.Effect<PiggyReceipt, EconomyError>;
+    readonly unlock: (subject: Subject, input: PiggyUnlockInput) => Effect.Effect<PiggyReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: {
+        readonly requestId: string;
+    }) => Effect.Effect<PiggyObservation, EconomyError>;
+    readonly rebuild: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly bankId: string;
+    }) => Effect.Effect<PiggyProjection, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+export declare type PiggyEvent = {
+    readonly id: string;
+    readonly sequence: number;
+    readonly kind: 'fill';
+    readonly at: number;
+    readonly authorityId: string;
+    readonly eventId: string;
+    readonly sourceId: string;
+    readonly acceptedAmount: string;
+    readonly delta: string;
+} | {
+    readonly id: string;
+    readonly sequence: number;
+    readonly kind: 'unlock';
+    readonly at: number;
+    readonly amount: string;
+    readonly remaining: string;
+};
+
+export declare interface PiggyFillContext extends PiggyRuleContext {
+    readonly acceptedAmount: EconomyAmountInput;
+}
+
+declare interface PiggyFillEvidence {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly authorityId: string;
+    readonly eventId: string;
+    readonly sourceId: string;
+    readonly amount: string;
+    readonly acceptedAt: number;
+}
+
+export declare interface PiggyFillInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly bankId: string;
+    readonly sourceId: string;
+    readonly eventId: string;
+    readonly requestId: string;
+}
+
+export declare const piggyFillIntent: (input: PiggyFillInput) => PiggyFillInput;
+
+export declare type PiggyFillPolicy = (context: PiggyFillContext) => EconomyAmountInput;
+
+/** Actual accepted server events only. Canonical authority/event identity must
+ * stay independent of aliases and be scoped/verified by the application's
+ * authoritative event source. No player match result or amount is accepted. */
+declare interface PiggyFillSource {
+    readonly read: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly bank: PiggyBank;
+        readonly sourceId: string;
+        readonly eventId: string;
+    }) => Effect.Effect<PiggyFillEvidence, EconomyError>;
+}
+
+export declare type PiggyObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: PiggyReceipt;
+};
+
+declare interface PiggyPluginOptions extends Omit<PiggyStoreOptions, 'currencies' | 'economy' | 'realMoney' | 'fillSource' | 'unlockSource'> {
+    readonly fillSource?: PiggyStoreOptions['fillSource'];
+    readonly unlockSource?: PiggyStoreOptions['unlockSource'];
+    readonly service?: PiggyBanksService;
+    readonly querySources?: {
+        readonly list: readonly string[] | undefined;
+        readonly receipt: readonly string[];
+    };
+}
+
+export declare interface PiggyProjection {
+    readonly events: readonly PiggyEvent[];
+    readonly available: string;
+    readonly cycles: number;
+}
+
+export declare type PiggyReceipt = {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly bankId: string;
+    readonly event: Extract<PiggyEvent, {
+        kind: 'fill';
+    }>;
+    readonly available: string;
+} | {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly bankId: string;
+    readonly event: Extract<PiggyEvent, {
+        kind: 'unlock';
+    }>;
+    readonly available: string;
+    readonly value: ShopOrderReceipt;
+};
+
+export declare type PiggyResetPolicy = (context: PiggyRuleContext) => EconomyAmountInput;
+
+export declare interface PiggyRuleContext {
+    readonly bank: PiggyBank;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly available: EconomyAmountInput;
+    readonly rulesVersion?: string;
+}
+
+declare interface PiggyStoreOptions {
+    readonly banks: readonly (PiggyBankDefinition | PiggyBank)[];
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer'>;
+    readonly fillSource: PiggyFillSource;
+    readonly unlockSource: PiggyUnlockSource;
+    readonly version: string;
+    readonly fill?: PiggyFillPolicy | undefined;
+    readonly reset?: PiggyResetPolicy | undefined;
+    readonly priceResolver?: PriceResolver | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+export declare interface PiggyUnlockInput {
+    readonly bankId: string;
+    readonly bankVersion: string;
+    readonly bankDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+}
+
+export declare const piggyUnlockIntent: (input: PiggyUnlockInput) => Readonly<{
+    bankId: string;
+    bankVersion: string;
+    bankDigest: string;
+    requestId: string;
+    currency: string | null;
+}>;
+
+declare interface PiggyUnlockSource {
+    readonly read: (input: {
+        readonly subject: Subject;
+        readonly bank: PiggyBank;
+        readonly at: number;
+    }) => Effect.Effect<{
+        readonly eligible: boolean;
+        readonly adjustments: readonly VirtualPriceAdjustment[];
+    }, EconomyError>;
+}
+
+export declare interface PiggyView {
+    readonly bank: PiggyBank;
+    readonly bankDigest: string;
+    readonly available: string;
+    readonly cycles: number;
+}
+
+export declare const planLedgerTransfer: (input: LedgerTransferInput) => LedgerTransfer;
+
+export declare type Price = {
+    readonly kind: 'virtual';
+    readonly options: readonly ResolvedVirtualPriceOption[];
+} | ({
+    readonly kind: 'real';
+} & RealPriceDefinition) | {
+    readonly kind: 'mixed';
+    readonly real: RealPriceDefinition;
+    readonly virtual: readonly ResolvedVirtualPriceOption[];
+} | {
+    readonly kind: 'free';
+};
+
+export declare type PriceDefinition = {
+    readonly kind: 'virtual';
+    readonly options: readonly VirtualPriceOption[];
+} | ({
+    readonly kind: 'real';
+} & RealPriceDefinition) | {
+    readonly kind: 'mixed';
+    readonly real: RealPriceDefinition;
+    readonly virtual: readonly VirtualPriceOption[];
+} | {
+    readonly kind: 'free';
+};
+
+export declare type PriceResolver = (context: PriceResolverContext) => Price;
+
+export declare interface PriceResolverContext {
+    readonly price: Price;
+    readonly currencies: readonly ResolvedCurrency[];
+    readonly realMoney: boolean;
+    readonly adjustments: readonly Readonly<{
+        currency: string;
+        discountBps: number;
+        minimum: string;
+    }>[];
+}
+
+export declare const priceResolverContext: (price: PriceDefinition, currencies: readonly CurrencyDefinition[], realMoney?: boolean, adjustments?: readonly VirtualPriceAdjustment[]) => PriceResolverContext;
+
+/** Whole accepted-history projection shared by the future SQL writer/rebuild.
+ * No purchase/refund authenticity is inferred here. The owner must provide all
+ * rows from one tenant/subject, and archive original source weights as evidence.
+ * Cumulative partial refunds cannot exploit independent floor rounding. */
+export declare const projectLoyaltyPoints: (input: readonly LoyaltyPointEntry[], decay?: Loyalty["decay"]) => LoyaltyPointProjection;
+
+/** One complete accepted history owner for writer/rebuild. SQL/source layers
+ * separately establish receipt authenticity, ownership and complete tail. */
+export declare const projectPiggyBank: (bank: Pick<PiggyBank, "cap" | "fillFrom">, input: readonly PiggyEvent[]) => PiggyProjection;
+
+/** Complete owner/currency history is supplied and validated by SQL custody.
+ * Credits/refunds never silently replenish an already consumed spend allowance. */
+export declare const projectSpend: (input: readonly SpendPosting[], at: number) => Readonly<{
+    windows: Readonly<{
+        day: Readonly<{
+            from: number;
+            until: number;
+        }>;
+        month: Readonly<{
+            from: number;
+            until: number;
+        }>;
+    }>;
+    daily: string;
+    monthly: string;
+    balance: string;
+}>;
+
+export declare interface PromoCode {
+    readonly id: string;
+    readonly version: string;
+    readonly campaign: string;
+    readonly items: readonly {
+        readonly itemId: string;
+        readonly qty: number;
+    }[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+    readonly from: number | null;
+    readonly until: number | null;
+    readonly limits: {
+        readonly global: number;
+        readonly perPlayer: number;
+    };
+}
+
+export declare interface RealPriceDefinition {
+    /** Integer minor-unit references; verified store receipts remain authoritative. */
+    readonly prices: Readonly<Record<string, number>>;
+    readonly storeProductIds: Partial<Readonly<Record<EconomyChannel, string>>>;
+}
+
+export declare interface RedeemCodeInput {
+    readonly code: string;
+    readonly requestId: string;
+}
+
+declare const refundEvent: unique symbol;
+
+export declare const resolveCodeEligibility: (input: CodeEligibilityContext, declarations: readonly CurrencyDefinition[], slot?: CodeEligibility) => boolean;
+
+export declare interface ResolvedCurrency {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap: string;
+    readonly premium: boolean;
+    readonly display: {
+        readonly nameKey: string;
+    } | null;
+}
+
+export declare interface ResolvedVirtualPriceOption {
+    readonly currency: string;
+    readonly amount: string;
+}
+
+/** A named override chooses a subset of declared qualifying-tier perks. App
+ * authors change the declaration to change rewards, never return hidden grants. */
+export declare const resolveLoyaltyPerks: (input: LoyaltyPerksContext, slot?: LoyaltyPerksResolver) => readonly LoyaltyPerk[];
+
+export declare const resolveLoyaltyTier: (input: LoyaltyTierContext, slot?: LoyaltyTierResolver) => {
+    readonly id: string;
+    readonly at: string;
+    readonly perks: readonly LoyaltyPerk[];
+};
+
+/** Custom fill narrows the accepted source amount and remaining cap. No player
+ * event, source validation, SQL grant or wallet mint is implied by this rule. */
+export declare const resolvePiggyFill: (input: PiggyFillContext, slot?: PiggyFillPolicy) => string;
+
+/** Custom reset retains a remainder; only available-minus-remainder is granted,
+ * so retaining points cannot recreate already paid currency. */
+export declare const resolvePiggyReset: (input: PiggyRuleContext, slot?: PiggyResetPolicy) => Readonly<{
+    remaining: string;
+    amount: string;
+}>;
+
+/** Detaches custom output and preserves alternatives, floors and real references. */
+export declare const resolvePrice: (context: PriceResolverContext, resolver?: PriceResolver) => Price;
+
+export declare const resolveSpendBudget: (input: SpendLimitContext, policy?: SpendLimitPolicy) => SpendBudget;
+
+export declare const resolveSubscriptionDailyGrant: (input: SubscriptionDailyContext, slot?: SubscriptionDailyGrantPolicy) => Readonly<{
+    eligible: boolean;
+    day: number;
+}>;
+
+/** A custom window may narrow the canonical period, never overlap/extend it.
+ * Actual accepted entitlement/renewal identity remains the SQL owner's duty. */
+export declare const resolveSubscriptionPeriod: (input: SubscriptionPeriodContext, slot?: SubscriptionPeriodResolver) => SubscriptionWindow;
+
+export declare const resolveTradeEligibility: (input: TradeEligibilityContext, policy?: TradeEligibilityPolicy) => boolean;
+
+export declare const resolveTradeTax: (input: TradeTaxContext, policy?: TradeTaxPolicy) => Readonly<{
+    currency: string;
+    gross: string;
+    net: string;
+    tax: string;
+}>;
+
+export declare interface ShopBuyInput {
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly offerDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+    readonly qty?: number | undefined;
+}
+
+export declare const shopBuyIntent: (input: ShopBuyInput) => Readonly<{
+    offerId: string;
+    offerVersion: string;
+    offerDigest: string;
+    requestId: string;
+    currency: string | null;
+    qty: number;
+}>;
+
+export declare interface ShopContextInput {
+    readonly subject: Subject;
+    readonly offer: ShopOffer;
+    readonly at: number;
+}
+
+export declare interface ShopContextSnapshot {
+    readonly eligible: boolean;
+    readonly adjustments: readonly VirtualPriceAdjustment[];
+}
+
+/** Trusted external profile/segment/flag facts; never inside a replayable SQL callback. */
+export declare interface ShopContextSource {
+    readonly read: (input: ShopContextInput) => Effect.Effect<ShopContextSnapshot, EconomyError>;
+}
+
+export declare interface ShopCurrencyGrant {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+export declare const shopInteger: (input: unknown, minimum: number, maximum: number) => number;
+
+export declare interface ShopItemGrant {
+    readonly itemId: string;
+    readonly qty: number;
+}
+
+export declare interface ShopOffer {
+    readonly id: string;
+    readonly version: string;
+    readonly titleKey: string;
+    readonly price: Price;
+    readonly items: readonly ShopItemGrant[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+    readonly from: number | null;
+    readonly until: number | null;
+    readonly segment: string | null;
+    readonly flag: string | null;
+    readonly countries: readonly string[];
+    readonly limits: {
+        readonly perPlayer: number | null;
+        readonly perDay: number | null;
+        readonly global: number | null;
+    };
+    readonly oneTime: boolean;
+    readonly maxQuantity: number;
+}
+
+export declare interface ShopOfferDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly titleKey: string;
+    readonly price: PriceDefinition;
+    readonly items?: readonly ShopItemGrant[] | undefined;
+    readonly currencies?: readonly ShopCurrencyGrant[] | undefined;
+    readonly from?: number | null | undefined;
+    readonly until?: number | null | undefined;
+    readonly segment?: string | null | undefined;
+    readonly flag?: string | null | undefined;
+    readonly countries?: readonly string[] | undefined;
+    readonly limits?: {
+        readonly perPlayer?: number | null | undefined;
+        readonly perDay?: number | null | undefined;
+        readonly global?: number | null | undefined;
+    } | undefined;
+    readonly oneTime?: boolean | undefined;
+    readonly maxQuantity?: number | undefined;
+}
+
+export declare interface ShopOfferView {
+    readonly offerDigest: string;
+    readonly offer: ShopOffer;
+    readonly price: Price;
+}
+
+export declare interface ShopOrderReceipt {
+    readonly orderId: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly offerDigest: string;
+    readonly quantity: number;
+    readonly at: number;
+    readonly pricePaid: {
+        readonly kind: 'free';
+    } | {
+        readonly kind: 'virtual';
+        readonly currency: string;
+        readonly amount: string;
+    };
+    readonly transfers: readonly {
+        readonly txId: string;
+        readonly currency: string;
+        readonly amount: string;
+        readonly at: number;
+    }[];
+    readonly grants: readonly {
+        readonly operationId: string;
+        readonly kind: 'grant';
+        readonly changes: readonly {
+            readonly instanceId: string;
+            readonly delta: number;
+        }[];
+        readonly at: number;
+    }[];
+}
+
+export declare const shopPayment: (price: Price, currency: string | null, quantity: number) => ShopOrderReceipt["pricePaid"];
+
+export declare interface ShopPluginOptions extends ShopRules {
+    readonly inventory?: ShopStoreOptions['inventory'] | undefined;
+    /** Full port replacement owns authority/receipts/privacy; no default SQL roles or fallback. */
+    readonly service?: ShopService;
+    readonly querySources?: {
+        readonly offers: readonly string[] | undefined;
+        readonly receipt: readonly string[];
+    };
+}
+
+export declare class ShopPort extends ShopPort_base {
+}
+
+declare const ShopPort_base: Context.ServiceClass<ShopPort, "@voltro/ShopPort", ShopService>;
+
+/** Nonterminal observations never authorize a new request identity or prove that no purchase can commit. */
+export declare type ShopPurchaseObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: ShopOrderReceipt;
+};
+
+export declare interface ShopRules {
+    readonly offers: readonly (ShopOfferDefinition | ShopOffer)[];
+    readonly priceResolver?: PriceResolver | undefined;
+    readonly contextSource?: ShopContextSource | undefined;
+    readonly version?: string | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly maxOrders?: number | undefined;
+    readonly maxAuditRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+export declare interface ShopService {
+    readonly offers: (subject: Subject) => Effect.Effect<readonly ShopOfferView[], EconomyError>;
+    readonly buy: (subject: Subject, input: ShopBuyInput) => Effect.Effect<ShopOrderReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: ShopBuyInput) => Effect.Effect<ShopPurchaseObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface ShopStoreOptions extends ShopRules {
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer'>;
+    readonly inventory?: Pick<InventorySqlService, 'prepareGrant'> | undefined;
+}
+
+export declare interface SpendBudget {
+    readonly daily: string | null;
+    readonly monthly: string | null;
+    readonly allowed: boolean;
+}
+
+export declare interface SpendFacts extends SpendFactsInput {
+    readonly allowed: boolean;
+    readonly minor: boolean;
+    readonly observedAt: number;
+    readonly daily?: EconomyAmountInput | null | undefined;
+    readonly monthly?: EconomyAmountInput | null;
+    readonly blockedUntil?: number | null;
+}
+
+export declare interface SpendFactsInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly ownerKind: 'player' | 'guild';
+    readonly currency: string;
+    readonly at: number;
+}
+
+export declare interface SpendFactsSource {
+    readonly read: (input: SpendFactsInput) => Effect.Effect<SpendFacts, EconomyError>;
+}
+
+export declare interface SpendLimit {
+    readonly currency: string;
+    readonly daily: string | null;
+    readonly monthly: string | null;
+    readonly minors: {
+        readonly daily: string | null;
+        readonly monthly: string | null;
+    } | null;
+}
+
+export declare interface SpendLimitContext {
+    readonly limit: SpendLimit;
+    readonly facts: SpendFacts;
+    readonly version: string;
+}
+
+export declare interface SpendLimitDefinition {
+    readonly currency: string;
+    readonly daily?: EconomyAmountInput | null | undefined;
+    readonly monthly?: EconomyAmountInput | null;
+    readonly minors?: {
+        readonly daily?: EconomyAmountInput | null | undefined;
+        readonly monthly?: EconomyAmountInput | null;
+    };
+}
+
+export declare type SpendLimitPolicy = (input: SpendLimitContext) => SpendBudget;
+
+export declare interface SpendLimitsOptions {
+    readonly limits: readonly (SpendLimitDefinition | SpendLimit)[];
+    readonly source: SpendFactsSource;
+    readonly version: string;
+    readonly policy?: SpendLimitPolicy;
+}
+
+export declare interface SpendPosting {
+    readonly id: string;
+    readonly debit: string;
+    readonly credit: string;
+    readonly at: number;
+}
+
+export declare interface Subscription {
+    readonly id: string;
+    readonly version: string;
+    readonly titleKey: string;
+    readonly price: Price;
+    readonly period: Readonly<{
+        unit: 'day' | 'week' | 'month';
+        count: number;
+    }>;
+    readonly grants: Readonly<{
+        onPurchase: SubscriptionGift;
+        daily: SubscriptionGift;
+    }>;
+    readonly graceDays: number;
+    readonly coolingOff: Readonly<{
+        days: number;
+        overrideReason: string | null;
+    }>;
+    readonly disclosure: Readonly<{
+        durationKey: string;
+        renewalKey: string;
+        cancellationPath: string;
+    }>;
+}
+
+/** Consent and eligibility are application authority, never inferred from a
+ * price declaration or a player boolean. No automatic provider acquisition. */
+declare interface SubscriptionAccessSource {
+    readonly read: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly subscription: Subscription;
+        readonly at: number;
+        readonly kind: 'start' | 'renew';
+    }) => Effect.Effect<{
+        readonly eligible: boolean;
+        readonly renewalConsent: boolean;
+        readonly adjustments: readonly VirtualPriceAdjustment[];
+    }, EconomyError>;
+}
+
+export declare interface SubscriptionActiveView {
+    readonly entitlementId: string;
+    readonly subscription: Subscription;
+    readonly subscriptionDigest: string;
+    readonly originAt: number;
+    readonly periodIndex: number;
+    readonly window: SubscriptionEntitlement;
+    readonly currency: string | null;
+    readonly renews: boolean;
+    readonly cancelledAt: number | null;
+}
+
+export declare interface SubscriptionCancelInput {
+    readonly entitlementId: string;
+    readonly requestId: string;
+}
+
+export declare interface SubscriptionCancellationReceipt {
+    readonly operationId: string;
+    readonly entitlementId: string;
+    readonly at: number;
+    readonly renews: false;
+}
+
+export declare interface SubscriptionDailyContext {
+    readonly entitlement: SubscriptionEntitlement;
+    readonly at: number;
+    readonly claimedDays: readonly number[];
+    readonly rulesVersion?: string;
+}
+
+export declare type SubscriptionDailyGrantPolicy = (input: SubscriptionDailyContext) => boolean;
+
+export declare interface SubscriptionDailyInput {
+    readonly entitlementId: string;
+    readonly requestId: string;
+}
+
+export declare interface SubscriptionDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly titleKey: string;
+    readonly price: PriceDefinition;
+    readonly period: {
+        readonly unit: 'day' | 'week' | 'month';
+        readonly count: number;
+    };
+    readonly grants: {
+        readonly onPurchase?: SubscriptionGiftDefinition;
+        readonly daily?: SubscriptionGiftDefinition | undefined;
+    };
+    readonly graceDays?: number;
+    readonly coolingOff?: {
+        readonly days: number;
+        readonly overrideReason?: string | null;
+    };
+    readonly disclosure: {
+        readonly durationKey: string;
+        readonly renewalKey: string;
+        readonly cancellationPath: string;
+    };
+}
+
+export declare interface SubscriptionEntitlement {
+    readonly startsAt: number;
+    readonly expiresAt: number;
+    readonly graceUntil: number;
+    readonly state: 'active' | 'grace' | 'expired';
+}
+
+export declare const subscriptionEntitlementIntent: (input: SubscriptionDailyInput | SubscriptionCancelInput) => Readonly<{
+    entitlementId: string;
+    requestId: string;
+}>;
+
+export declare interface SubscriptionGift {
+    readonly items: ShopOffer['items'];
+    readonly currencies: ShopOffer['currencies'];
+}
+
+export declare interface SubscriptionGiftDefinition {
+    readonly items?: ShopOfferDefinition['items'] | undefined;
+    readonly currencies?: ShopOfferDefinition['currencies'] | undefined;
+}
+
+export declare type SubscriptionObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: SubscriptionValueReceipt | SubscriptionCancellationReceipt;
+};
+
+export declare interface SubscriptionPeriodContext {
+    readonly subscription: Subscription;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly originAt: number;
+    readonly index: number;
+    readonly rulesVersion?: string;
+}
+
+export declare type SubscriptionPeriodResolver = (input: SubscriptionPeriodContext) => SubscriptionWindow;
+
+export declare type SubscriptionReceiptInput = {
+    readonly kind: 'start';
+    readonly intent: SubscriptionStartInput;
+} | {
+    readonly kind: 'renew' | 'daily' | 'cancel';
+    readonly intent: SubscriptionDailyInput;
+};
+
+export declare interface SubscriptionRenewInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly entitlementId: string;
+    readonly requestId: string;
+}
+
+export declare const subscriptionRenewIntent: (input: SubscriptionRenewInput) => Readonly<{
+    tenantId: string;
+    ownerId: string;
+    entitlementId: string;
+    requestId: string;
+}>;
+
+export declare interface SubscriptionsPluginOptions extends Omit<SubscriptionsStoreOptions, 'currencies' | 'economy' | 'realMoney' | 'accessSource'> {
+    readonly accessSource?: SubscriptionsStoreOptions['accessSource'];
+    readonly service?: SubscriptionsService;
+    readonly querySources?: {
+        readonly list: readonly string[] | undefined;
+        readonly active: readonly string[];
+        readonly receipt: readonly string[];
+    };
+}
+
+export declare class SubscriptionsPort extends SubscriptionsPort_base {
+}
+
+declare const SubscriptionsPort_base: Context.ServiceClass<SubscriptionsPort, "@voltro/SubscriptionsPort", SubscriptionsService>;
+
+/** Renew is a trusted server intention. Implementations must deny players and
+ * enforce one accepted renewal per entitlement/period independently of nonce.
+ * Calendar/daily strategies alone cannot establish durable idempotency. */
+export declare interface SubscriptionsService {
+    readonly list: (subject: Subject) => Effect.Effect<readonly SubscriptionView[], EconomyError>;
+    readonly active: (subject: Subject) => Effect.Effect<readonly SubscriptionActiveView[], EconomyError>;
+    readonly start: (subject: Subject, input: SubscriptionStartInput) => Effect.Effect<SubscriptionValueReceipt, EconomyError>;
+    readonly renew: (subject: Subject, input: SubscriptionRenewInput) => Effect.Effect<SubscriptionValueReceipt, EconomyError>;
+    readonly claimDaily: (subject: Subject, input: SubscriptionDailyInput) => Effect.Effect<SubscriptionValueReceipt, EconomyError>;
+    readonly cancel: (subject: Subject, input: SubscriptionCancelInput) => Effect.Effect<SubscriptionCancellationReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: SubscriptionReceiptInput) => Effect.Effect<SubscriptionObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface SubscriptionsStoreOptions {
+    readonly subscriptions: readonly (SubscriptionDefinition | Subscription)[];
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer'>;
+    readonly inventory?: Pick<InventorySqlService, 'prepareGrant'> | undefined;
+    readonly accessSource: SubscriptionAccessSource;
+    readonly version: string;
+    readonly period?: SubscriptionPeriodResolver | undefined;
+    readonly daily?: SubscriptionDailyGrantPolicy | undefined;
+    readonly priceResolver?: PriceResolver | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+/** Player intentions contain observed identities, never charge amounts, dates,
+ * provider receipts, claimed days, entitlement state or renewal authority. */
+export declare interface SubscriptionStartInput {
+    readonly subscriptionId: string;
+    readonly subscriptionVersion: string;
+    readonly subscriptionDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+}
+
+export declare const subscriptionStartIntent: (input: SubscriptionStartInput) => Readonly<{
+    subscriptionId: string;
+    subscriptionVersion: string;
+    subscriptionDigest: string;
+    requestId: string;
+    currency: string | null;
+}>;
+
+export declare interface SubscriptionValueReceipt {
+    readonly operationId: string;
+    readonly entitlementId: string;
+    readonly kind: 'start' | 'renew' | 'daily';
+    readonly at: number;
+    readonly periodIndex: number;
+    readonly day: number | null;
+    readonly window: SubscriptionEntitlement;
+    readonly value: ShopOrderReceipt;
+}
+
+export declare interface SubscriptionView {
+    readonly subscription: Subscription;
+    readonly subscriptionDigest: string;
+}
+
+export declare interface SubscriptionWindow {
+    readonly startsAt: number;
+    readonly expiresAt: number;
+}
+
+export declare interface TradeAcceptInput {
+    readonly tradeId: string;
+    readonly tradeDigest: string;
+    readonly requestId: string;
+}
+
+export declare const tradeAcceptIntent: (input: TradeAcceptInput) => TradeAcceptInput;
+
+declare interface TradeAuthorityAdmission {
+    readonly tenantId: string;
+    readonly tradeId: string;
+    readonly phase: 'propose' | 'accept';
+    readonly at: number;
+    readonly expiresAt: number;
+    readonly participants: readonly TradeParticipantAuthority[];
+}
+
+/** Required real trust/sanctions facts plus an exact-store SQL revalidation unit.
+ * Read/prepare execute outside replayable SQL. The unit owns admission fences;
+ * no default permission, trust score or revoked-consent behavior is fabricated. */
+declare interface TradeAuthoritySource {
+    readonly read: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly tradeId: string;
+        readonly at: number;
+    }) => Effect.Effect<TradeParticipantAuthority, EconomyError>;
+    readonly prepare: (input: TradeAuthorityAdmission) => Effect.Effect<PreparedSqlMutation<void>, EconomyError>;
+}
+
+export declare const tradeCancelIntent: (input: {
+    readonly tradeId: string;
+    readonly requestId: string;
+}) => Readonly<{
+    tradeId: string;
+    requestId: string;
+}>;
+
+export declare interface TradeCurrencyIntention {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+export declare interface TradeEligibilityContext {
+    readonly tenantId: string;
+    readonly proposerId: string;
+    readonly accepterId: string;
+    readonly tradeId: string;
+    readonly proposedToId: string | null;
+    readonly createdAt: number;
+    readonly at: number;
+    readonly expiresAt: number;
+    readonly rules: TradeRules;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly offered: TradeLeg;
+    readonly requested: TradeLeg;
+    readonly proposer: TradeParticipantAuthority;
+    readonly accepter: TradeParticipantAuthority;
+}
+
+export declare type TradeEligibilityPolicy = (input: TradeEligibilityContext) => boolean;
+
+declare interface TradeEscrowOptions {
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly rules: TradeRulesDefinition;
+    readonly taxPolicy?: TradeTaxPolicy | undefined;
+    readonly economy: Pick<WalletEscrowParticipant, 'prepareEscrowReserve' | 'prepareEscrowRelease' | 'prepareEscrowTaxSettle' | 'prepareEscrowReserveTaxSettle' | 'escrow'>;
+    readonly inventory?: Pick<InventorySqlService, 'prepareReserve' | 'prepareRelease' | 'prepareReservationTransfer' | 'prepareReserveTransfer' | 'reservation'> | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+}
+
+declare interface TradeExpiryInput {
+    readonly tenantId: string;
+    readonly maxTrades?: number | undefined;
+}
+
+declare interface TradeExpiryResult {
+    readonly capturedAt: number;
+    readonly scannedRows: number;
+    readonly dueTrades: number;
+    /** Matching original expiry receipts observed by this call, not newly committed closes. */
+    readonly expiredTrades: number;
+    readonly alreadyClosedTrades: number;
+}
+
+export declare interface TradeItemAuthority {
+    readonly instanceId: string;
+    readonly itemId: string;
+    readonly qty: number;
+    readonly tradable: boolean;
+    readonly locked: boolean;
+    readonly reservationId: string | null;
+    readonly expiresAt: number | null;
+}
+
+export declare interface TradeItemIntention {
+    readonly instanceId: string;
+    readonly qty: number;
+}
+
+export declare interface TradeLeg {
+    readonly items: readonly TradeItemIntention[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+}
+
+export declare interface TradeLegDefinition {
+    readonly items: readonly TradeItemIntention[];
+    readonly currencies: readonly TradeCurrencyIntention[];
+}
+
+export declare type TradeObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: TradeReceipt;
+};
+
+export declare interface TradeParticipantAuthority {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly allowed: boolean;
+    readonly trustScore: number;
+    readonly items: readonly TradeItemAuthority[];
+}
+
+export declare interface TradeProposeInput {
+    readonly toId: string | null;
+    readonly offered: TradeLegDefinition;
+    readonly requested: TradeLegDefinition;
+    readonly durationMs: number;
+    readonly requestId: string;
+}
+
+export declare const tradeProposeIntent: (input: TradeProposeInput, currencies: readonly CurrencyDefinition[], rulesInput: TradeRulesDefinition) => Readonly<{
+    offered: TradeLeg;
+    requested: TradeLeg;
+    durationMs: number;
+    toId: string | null;
+    requestId: string;
+}>;
+
+export declare interface TradeReceipt {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly trade: TradeView;
+}
+
+export declare interface TradeRules {
+    readonly version: string;
+    readonly taxBps: number;
+    readonly maxDurationMs: number;
+    readonly minTrustScore: number;
+}
+
+export declare interface TradeRulesDefinition {
+    readonly version: string;
+    readonly taxBps?: number;
+    readonly maxDurationMs?: number;
+    readonly minTrustScore?: number;
+}
+
+export declare interface TradesPluginOptions extends Omit<TradeStoreOptions, 'currencies' | 'economy' | 'authority'> {
+    readonly authority?: TradeStoreOptions['authority'];
+    readonly service?: TradesService;
+    /** Complete replacements require actual query invalidation sources. Defaults may add app facts. */
+    readonly querySources?: {
+        readonly mine: readonly string[] | undefined;
+        readonly receipt: readonly string[];
+    };
+}
+
+export declare class TradesPort extends TradesPort_base {
+}
+
+declare const TradesPort_base: Context.ServiceClass<TradesPort, "@voltro/TradesPort", TradesService>;
+
+/** Full owning service; no default implementation or escrow installation is
+ * inferred from a Tag. SQL reservation/transfer/expiry/privacy own acceptance. */
+export declare interface TradesService {
+    readonly propose: (subject: Subject, input: TradeProposeInput) => Effect.Effect<TradeReceipt, EconomyError>;
+    readonly accept: (subject: Subject, input: TradeAcceptInput) => Effect.Effect<TradeReceipt, EconomyError>;
+    readonly cancel: (subject: Subject, input: {
+        readonly tradeId: string;
+        readonly requestId: string;
+    }) => Effect.Effect<TradeReceipt, EconomyError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly TradeView[], EconomyError>;
+    readonly receipt: (subject: Subject, input: {
+        readonly requestId: string;
+    }) => Effect.Effect<TradeObservation, EconomyError>;
+    readonly rebuild: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly tradeId: string;
+    }) => Effect.Effect<TradeView, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface TradesSqlService extends TradesService {
+    readonly expireDue: (subject: Subject, input: TradeExpiryInput) => Effect.Effect<TradeExpiryResult, EconomyError>;
+    readonly expire: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly tradeId: string;
+    }) => Effect.Effect<TradeReceipt, EconomyError>;
+}
+
+declare interface TradeStoreOptions extends TradeEscrowOptions {
+    readonly authority: TradeAuthoritySource;
+    readonly inventory?: NonNullable<TradeEscrowOptions['inventory']> & Pick<InventorySqlService, 'reservationEvidence'> | undefined;
+    readonly eligibility?: TradeEligibilityPolicy | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+export declare interface TradeTaxContext {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+    readonly rules: TradeRules;
+}
+
+export declare type TradeTaxPolicy = (input: TradeTaxContext) => EconomyAmountInput;
+
+export declare interface TradeTaxView {
+    readonly leg: 'offered' | 'requested';
+    readonly currency: string;
+    readonly gross: string;
+    readonly net: string;
+    readonly tax: string;
+}
+
+export declare interface TradeView {
+    readonly tradeId: string;
+    readonly tradeDigest: string;
+    readonly proposerId: string;
+    readonly toId: string | null;
+    readonly offered: TradeLeg;
+    readonly requested: TradeLeg;
+    readonly createdAt: number;
+    readonly expiresAt: number;
+    readonly state: 'proposed' | 'accepted' | 'cancelled' | 'expired';
+    readonly accepterId: string | null;
+    readonly rulesVersion: string;
+    readonly taxes: readonly TradeTaxView[];
+}
+
+export declare const utcSpendWindows: (at: number) => Readonly<{
+    day: Readonly<{
+        from: number;
+        until: number;
+    }>;
+    month: Readonly<{
+        from: number;
+        until: number;
+    }>;
+}>;
+
+declare const verifiedCurrentState: unique symbol;
+
+/** Fresh provider observation bound to revalidated original SQL. Never copied player refund authority. */
+declare interface VerifiedIapCurrentState {
+    readonly [verifiedCurrentState]: true;
+    readonly orderId: string;
+}
+
+/** Authenticated notice, never current purchase state or grant/refund authority. */
+declare interface VerifiedIapNotification {
+    readonly [verifiedNotification]: true;
+    readonly noticeId: string;
+    readonly channel: IapRefundChannel;
+}
+
+/** Process-local opaque evidence. A serialized object is never a verification capability. */
+declare interface VerifiedIapPurchase {
+    readonly [verifiedPurchase]: true;
+    readonly scope: IapScope;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly requestId: string;
+    readonly verifiedAt: number;
+    readonly identity: string;
+    readonly facts: IapTransactionFacts;
+}
+
+declare const verifiedNotification: unique symbol;
+
+declare const verifiedPurchase: unique symbol;
+
+export declare interface VirtualPriceAdjustment {
+    readonly currency: string;
+    /** Inclusive integer 0..10000. */
+    readonly discountBps: number;
+    /** A trusted floor, enforced independently of a custom resolver. */
+    readonly minimum: EconomyAmountInput;
+}
+
+export declare interface VirtualPriceOption {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+declare interface WalletEscrowFundedSettlementReceipt {
+    readonly reserve: EconomyReceipt;
+    readonly settlement: WalletEscrowSettlementReceipt;
+}
+
+declare interface WalletEscrowInput {
+    readonly tenantId: string;
+    readonly owner: EscrowWallet;
+    readonly reservationId: string;
+    readonly currency: string;
+}
+
+declare type WalletEscrowObservation = {
+    readonly reservationId: string;
+    readonly currency: string;
+    readonly state: 'not-observed';
+} | {
+    readonly reservationId: string;
+    readonly currency: string;
+    readonly amount: string;
+    readonly state: 'held' | 'released' | 'settled';
+    readonly receipt: EconomyReceipt;
+    readonly closingReceipt: EconomyReceipt | null;
+    readonly taxReceipt: EconomyReceipt | null;
+};
+
+declare interface WalletEscrowParticipant {
+    readonly prepareEscrowReserve: (subject: Subject, input: WalletEscrowReserveInput) => Effect.Effect<PreparedSqlMutation<EconomyReceipt>, EconomyError>;
+    readonly prepareEscrowRelease: (subject: Subject, input: WalletEscrowInput) => Effect.Effect<PreparedSqlMutation<EconomyReceipt>, EconomyError>;
+    /** Whole gross payout; use prepareEscrowTaxSettle for an exact net/sink split. */
+    readonly prepareEscrowSettle: (subject: Subject, input: WalletEscrowSettleInput) => Effect.Effect<PreparedSqlMutation<EconomyReceipt>, EconomyError>;
+    readonly prepareEscrowTaxSettle: (subject: Subject, input: WalletEscrowTaxSettleInput) => Effect.Effect<PreparedSqlMutation<WalletEscrowSettlementReceipt>, EconomyError>;
+    readonly prepareEscrowReserveTaxSettle: (subject: Subject, input: WalletEscrowReserveTaxSettleInput) => Effect.Effect<PreparedSqlMutation<WalletEscrowFundedSettlementReceipt>, EconomyError>;
+    readonly escrow: (subject: Subject, input: WalletEscrowInput) => Effect.Effect<WalletEscrowObservation, EconomyError>;
+}
+
+declare interface WalletEscrowReserveInput extends WalletEscrowInput {
+    readonly amount: EconomyAmountInput;
+}
+
+declare interface WalletEscrowReserveTaxSettleInput extends WalletEscrowReserveInput {
+    readonly to: EscrowWallet;
+    readonly taxAmount: EconomyAmountInput;
+    readonly taxAccountId?: string | undefined;
+}
+
+declare interface WalletEscrowSettleInput extends WalletEscrowInput {
+    readonly to: EscrowWallet;
+}
+
+declare interface WalletEscrowSettlementReceipt {
+    readonly reservationId: string;
+    readonly currency: string;
+    readonly gross: string;
+    readonly net: string;
+    readonly tax: string;
+    readonly payout: EconomyReceipt | null;
+    readonly taxReceipt: EconomyReceipt | null;
+}
+
+declare interface WalletEscrowTaxSettleInput extends WalletEscrowSettleInput {
+    readonly taxAmount: EconomyAmountInput;
+    readonly taxAccountId?: string | undefined;
+}
+
+export declare type WalletOwnerKind = 'player' | 'guild';
+
+export { }