@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/server.d.ts

@@ -0,0 +1,3856 @@
+import { AggregateDefinition } from '@voltro/runtime';
+import { BrandedScheduleDefinition } from '@voltro/runtime';
+import { ColumnBuilder } from '@voltro/database';
+import { Context } from 'effect';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { FieldCipher } from '@voltro/database';
+import { FieldDefinitions } from '@voltro/database';
+import { InventoryError } from '@voltro/plugin-inventory/errors';
+import { InventoryGrant } from '@voltro/plugin-inventory';
+import { InventoryReceipt } from '@voltro/plugin-inventory';
+import { InventoryReservationTransferReceipt } from '@voltro/plugin-inventory/server';
+import { InventorySqlService } from '@voltro/plugin-inventory/server';
+import { ItemDefinition } from '@voltro/plugin-inventory/items';
+import { Layer } from 'effect';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { PreparedSqlMutation } from '@voltro/database/sql';
+import { SanctionsSqlAdmissionService } from '@voltro/plugin-sanctions/server';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { Table } from '@voltro/database';
+import { YieldableError } from 'effect/Cause';
+
+declare const acceptedCompletion: unique symbol;
+
+/** SQL-issued capability. A player reference or serialized object cannot authorize provider completion. */
+export declare interface AcceptedIapCompletion {
+    readonly [acceptedCompletion]: true;
+    readonly orderId: string;
+}
+
+/** Read-only SQL custody capability, never current provider state or refund authority. */
+export declare interface AcceptedIapNotificationTarget {
+    readonly [acceptedNotificationTarget]: true;
+    readonly orderId: string;
+    readonly noticeId: string;
+}
+
+declare const acceptedNotificationTarget: unique symbol;
+
+export declare interface AppleIapCredentials {
+    readonly signingKey: string;
+    readonly keyId: string;
+    readonly issuerId: string;
+}
+
+export declare interface AppleIapCredentialSource {
+    /** App Store Connect credentials supplied by the operator; rotation is observed per verification. */
+    readonly read: () => Effect.Effect<AppleIapCredentials, EconomyError>;
+}
+
+export declare interface AppleIapCurrentStateOptions extends Omit<IapCurrentStateOptions, 'channel'> {
+    readonly appleRootCertificates: readonly Uint8Array[];
+    readonly appAppleId?: number | undefined;
+    readonly credentials: AppleIapCredentialSource;
+}
+
+/** Fresh App Store Server API response + SDK signature verification, SQL/account evidence; no writes. */
+export declare const appleIapCurrentStatePort: (input: AppleIapCurrentStateOptions) => IapCurrentStateService;
+
+export declare interface AppleIapNotificationOptions extends AppleIapTrustOptions {
+    readonly maxBodyBytes?: number;
+    readonly now?: (() => number) | undefined;
+}
+
+/** App Store Notifications v2. Actual SDK trust/online checks, no shared webhook secret or unsigned mode. */
+export declare const appleIapNotificationPort: (input: AppleIapNotificationOptions) => IapNotificationService;
+
+/** Installed Apple verifier declaration. StoreKit transaction finishing remains native-client-owned. */
+export declare const appleIapProvider: (input: AppleIapProviderOptions) => IapProviderDefinition;
+
+export declare type AppleIapProviderOptions = Pick<AppleIapVerificationOptions, 'environment' | 'applicationId' | 'appleRootCertificates' | 'appAppleId' | 'credentials'>;
+
+declare type AppleIapTrustOptions = Pick<AppleIapVerificationOptions, 'realMoney' | 'environment' | 'applicationId' | 'appleRootCertificates' | 'appAppleId'>;
+
+export declare interface AppleIapVerificationOptions extends Omit<IapVerificationOptions, 'channel'> {
+    /** DER Apple root certificates from the operator's trusted deployment, never from a receipt. */
+    readonly appleRootCertificates: readonly Uint8Array[];
+    readonly appAppleId?: number | undefined;
+    readonly credentials: AppleIapCredentialSource;
+}
+
+/** Real StoreKit 2 JWS and fresh App Store Server API status. No Xcode/unsigned mode. */
+export declare const appleIapVerificationPort: (input: AppleIapVerificationOptions) => IapVerificationService;
+
+declare interface Bundle {
+    readonly offer: ShopOffer;
+    readonly parts: readonly {
+        readonly offer: ShopOffer;
+        readonly qty: number;
+    }[];
+    readonly showValue: 'sumOfParts';
+}
+
+/** Existing owning read-only Shop receipt is the unit-price authority. Only
+ * accepted single-unit virtual/free purchases, with matching full content/rule
+ * identity, qualify. No current store price, provider/refund verification,
+ * quote guarantee, new SQL table or automatic bundle purchase is implied. */
+export declare const bundleValueFromShopReceipts: (options: ShopBundleValueOptions) => Readonly<{
+    read: (subject: Subject, input: ShopBundleValueInput) => Effect.Effect<Readonly<{
+        offerId: string;
+        offerVersion: string;
+        comparison: "sumOfParts";
+        capturedAt: number;
+        sources: readonly Readonly<{
+            offerId: string;
+            offerVersion: string;
+            referenceId: string;
+            observedAt: number;
+        }>[];
+        comparisons: readonly {
+            readonly kind: "virtual" | "real";
+            readonly currency: string;
+            readonly partsValue: string;
+            readonly bundleAmount: string;
+            readonly saving: string;
+        }[];
+    }>, EconomyError, never>;
+}>;
+
+export declare const captureIapAccountBindingService: (input: IapAccountBindingService) => IapAccountBindingService;
+
+export declare const captureIapCheckoutService: (input: IapCheckoutService) => IapCheckoutService;
+
+export declare const captureIapCompletionService: (input: IapCompletionService) => IapCompletionService;
+
+export declare const captureIapCurrentStateService: (service: IapCurrentStateService) => IapCurrentStateService;
+
+export declare const captureIapDeliveryService: (input: IapDeliveryService) => IapDeliveryService;
+
+export declare const captureIapManagementService: (input: IapManagementService) => IapManagementService;
+
+export declare const captureIapNotificationService: (input: IapNotificationService) => IapNotificationService;
+
+export declare const captureIapSystemService: (input: IapSystemService) => IapSystemService;
+
+/** Detached original admission. Never retain author-owned participant arrays. */
+export declare const captureTradeAuthorityAdmission: (input: TradeAuthorityAdmission) => TradeAuthorityAdmission;
+
+export declare const captureTradeExpiryInput: (input: TradeExpiryInput) => Readonly<{
+    tenantId: string;
+    maxTrades: number;
+}>;
+
+/** Default SQL ownership only. Union financial history with materialization so deleted wallets are still audited. */
+export declare const checkSqlEconomyConsistency: (store: DataStore, service: EconomyService, currencies: readonly string[], subject: Subject, input: EconomyConsistencyInput) => Effect.Effect<EconomyConsistencyResult, EconomyError>;
+
+export declare const codeClaimsTable: Table<"_voltro_eco_code_claims", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly codeKey: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly accepted: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly intent: ColumnBuilder<unknown, "json", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly fulfilledAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>;
+
+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;
+    };
+}
+
+declare type CodeEligibility = (input: CodeEligibilityContext) => boolean;
+
+declare interface CodeEligibilityContext {
+    readonly definition: PromoCode;
+    readonly at: number;
+    readonly claims: number;
+    readonly playerClaims: number;
+}
+
+declare type CodeObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: CodeReceipt;
+};
+
+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;
+    }[];
+}
+
+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>;
+}
+
+export declare const codesTable: Table<"_voltro_eco_codes", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly codeDigest: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+export 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;
+}
+
+export declare const codeSubjectsTable: Table<"_voltro_eco_code_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+export declare const codeTables: readonly [ Table<"_voltro_eco_code_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_codes", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly codeDigest: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_eco_code_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_code_claims", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly codeKey: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly accepted: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly intent: ColumnBuilder<unknown, "json", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly fulfilledAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>];
+
+export declare const codeTenantsTable: Table<"_voltro_eco_code_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+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;
+}
+
+export 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[];
+}
+
+/** Normalized captured content/rules, never a player-authorizing local digest. */
+export declare const containerDefinitionDigest: (container: Container, rulesVersion: string) => string;
+
+export declare const containerDefinitionsTable: Table<"_voltro_eco_containers", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+    readonly currencies: ColumnBuilder<unknown, "json", boolean>;
+    readonly realMoney: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+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;
+};
+
+export declare const containerOpeningsTable: Table<"_voltro_eco_container_openings", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly intent: ColumnBuilder<unknown, "json", boolean>;
+    readonly selection: ColumnBuilder<unknown, "json", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly sequence: ColumnBuilder<number | null, "integer", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly fulfilledAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>;
+
+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;
+}
+
+/** Server authority only: no player draw/seed/state is accepted by any route. */
+declare class ContainerRandomPort extends ContainerRandomPort_base {
+}
+
+declare const ContainerRandomPort_base: Context.ServiceClass<ContainerRandomPort, "@voltro/ContainerRandomPort", ContainerRandomService>;
+
+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;
+
+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>;
+}
+
+export 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;
+}
+
+export declare const containerSubjectsTable: Table<"_voltro_eco_container_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly pendingId: ColumnBuilder<string | null, "text", boolean>;
+}>, true, never>;
+
+export declare const containerTables: readonly [ Table<"_voltro_eco_container_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_containers", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+    readonly currencies: ColumnBuilder<unknown, "json", boolean>;
+    readonly realMoney: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_eco_container_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly pendingId: ColumnBuilder<string | null, "text", boolean>;
+}>, true, never>, Table<"_voltro_eco_container_openings", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly intent: ColumnBuilder<unknown, "json", boolean>;
+    readonly selection: ColumnBuilder<unknown, "json", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly sequence: ColumnBuilder<number | null, "integer", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly fulfilledAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>];
+
+export declare const containerTenantsTable: Table<"_voltro_eco_container_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+declare interface ContainerView {
+    readonly container: Container;
+    readonly containerDigest: string;
+    readonly disclosureDigest: string;
+    readonly misses: number;
+    readonly price: Price;
+    readonly disclosure: ReturnType<typeof discloseContainer>;
+}
+
+declare interface CreateCodeInput {
+    readonly tenantId: string;
+    readonly code: string;
+    readonly definition: CodeDefinition | PromoCode;
+}
+
+/** Native cryptographic rejection sampling, never modulo-biased or Math.random.
+ * A bounded failure refuses instead of silently changing randomness sources. */
+export declare const cryptoContainerRandom: Readonly<ContainerRandomService>;
+
+export declare const cryptoContainerRandomLayer: Layer.Layer<ContainerRandomPort, never, never>;
+
+declare interface CurrencyDefinition {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap?: EconomyAmountInput;
+    readonly premium?: boolean;
+    readonly display?: {
+        readonly nameKey: string;
+    } | null;
+}
+
+export declare const dataStoreCodes: (store: DataStore, input: CodeStoreOptions) => CodeService;
+
+/** Ordinary cold SQL authority. All custom callbacks/RNG/preparations are outside
+ * replayable transaction callbacks; actual writers share one exact-store group.
+ * One unresolved original request per owner prevents reroll/Pity races. */
+export declare const dataStoreContainers: (store: DataStore, input: ContainersStoreOptions) => ContainersService;
+
+/** Borrowed SQL owner; no timers, clients, hot-state cache or process-local locks. */
+export declare const dataStoreEconomy: (store: DataStore, input: EconomyStoreOptions) => EconomySqlService;
+
+/** One SQL owner and the actual existing prepared asset writers, never tick I/O. */
+export declare const dataStoreIap: (store: DataStore, input: IapStoreOptions) => IapSqlService;
+
+export declare const dataStoreIapAccountOwners: (store: DataStore, input: IapAccountStoreOptions) => IapAccountOwners;
+
+/** Public pseudonymous account tokens are minted at runtime, not credentials or shared placeholders. */
+export declare const dataStoreIapAccounts: (store: DataStore, input: IapAccountStoreOptions) => IapAccountBindingService;
+
+/** Five ordinary borrowed SQL roles. Complete accepted ordered rows plus the
+ * subject's durable tail count are the sole points/rebuild truth. There is no
+ * materialized points cache, tick read/write, hot backend or second ledger. */
+export declare const dataStoreLoyalty: (store: DataStore, input: LoyaltyStoreOptions) => LoyaltyService;
+
+/** Accepted fills/unlocks and durable end count are bank truth. Unlock payment,
+ * actual wallet grant, reset event and receipt share one exact-store SQL group.
+ * One existing wallet writer; no points cache or Tick/hot/native connection. */
+export declare const dataStorePiggyBanks: (store: DataStore, input: PiggyStoreOptions) => PiggyBanksService;
+
+/** Actual server SQL owner; caller supplies exact-store prepared participants. No provider, tick or native client. */
+export declare const dataStoreShop: (store: DataStore, input: ShopStoreOptions) => ShopSqlService;
+
+/** Complete ordered accepted events are entitlement/day truth and rebuild
+ * source. No materialized entitlement or daily counter, Tick or HotStore I/O.
+ * All strategies, facts, clocks and participant preparation precede SQL replay. */
+export declare const dataStoreSubscriptions: (store: DataStore, input: SubscriptionsStoreOptions) => SubscriptionsService;
+
+export declare const dataStoreTrades: (store: DataStore, input: TradeStoreOptions) => TradesSqlService;
+
+/** 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;
+    }>[];
+}>;
+
+declare type EconomyAccount = {
+    readonly kind: 'wallet';
+    readonly ownerId: string;
+    readonly ownerKind: WalletOwnerKind;
+} | {
+    readonly kind: 'system';
+    readonly id: string;
+};
+
+declare type EconomyAmountInput = string | number | bigint;
+
+declare type EconomyChannel = 'web' | 'ios' | 'android' | 'steam';
+
+export declare interface EconomyConsistencyInput {
+    readonly tenantId: string;
+    readonly maxLedgerRows?: number | undefined;
+    readonly maxWallets?: number;
+}
+
+export declare interface EconomyConsistencyResult {
+    readonly checked: number;
+    readonly mismatches: number;
+    readonly matches: boolean;
+    readonly ledgerRows: number;
+}
+
+export declare interface EconomyConsistencyRunner {
+    readonly checkConsistency: (subject: Subject, input: EconomyConsistencyInput) => Effect.Effect<EconomyConsistencyResult, EconomyError>;
+}
+
+/** Ordinary app-owned cron lifecycle; divergence makes the firing fail. Never auto-repair. */
+export declare const economyConsistencySchedule: (input: EconomyConsistencyScheduleOptions) => BrandedScheduleDefinition;
+
+export declare interface EconomyConsistencyScheduleOptions extends EconomyConsistencyInput {
+    readonly runner: EconomyConsistencyRunner;
+    readonly name?: string;
+    readonly cron?: string;
+    readonly timezone?: string;
+}
+
+export declare const economyCurrenciesTable: Table<"_voltro_eco_currencies", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly currency: ColumnBuilder<string, "text", boolean>;
+    readonly config: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+/** Redacted codes; never carries owners, amounts or provider payloads. */
+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 interface EconomyFlowAggregateOptions extends EconomyReportOptions {
+    readonly name?: string;
+    readonly refresh?: string;
+}
+
+export declare interface EconomyFlowRow {
+    readonly day: string;
+    readonly currency: string;
+    readonly reason: string;
+    readonly sources: string;
+    readonly sinks: string;
+    readonly playerTransfers: string;
+    readonly transactions: number;
+}
+
+export declare const EconomyFlowRowSchema: Schema.Struct<{
+    readonly day: Schema.String;
+    readonly currency: Schema.String;
+    readonly reason: Schema.String;
+    readonly sources: Schema.String;
+    readonly sinks: Schema.String;
+    readonly playerTransfers: Schema.String;
+    readonly transactions: Schema.Number;
+}>;
+
+/** Write this explicit factory as the default export of an app-owned .aggregate.ts file. */
+export declare const economyFlowsAggregate: (input: EconomyFlowAggregateOptions) => AggregateDefinition<EconomyFlowRow>;
+
+export declare const economyLedgerTable: Table<"_voltro_eco_ledger", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly txId: ColumnBuilder<string, "text", boolean>;
+    readonly currency: ColumnBuilder<string, "text", boolean>;
+    readonly accountKind: ColumnBuilder<"system" | "wallet", "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKind: ColumnBuilder<"player" | "guild" | null, "text", boolean>;
+    readonly walletKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly systemAccount: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerSequence: ColumnBuilder<number | null, "integer", boolean>;
+    readonly debtPolicy: ColumnBuilder<"allowNegative" | "blockSpend" | null, "text", boolean>;
+    readonly debit: ColumnBuilder<string, "bigint", boolean>;
+    readonly credit: ColumnBuilder<string, "bigint", boolean>;
+    readonly reason: ColumnBuilder<string, "text", boolean>;
+    readonly refKind: ColumnBuilder<string | null, "text", boolean>;
+    readonly refId: ColumnBuilder<string | null, "text", boolean>;
+    readonly actor: ColumnBuilder<string | null, "text", boolean>;
+    readonly at: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+declare interface EconomyReceipt {
+    readonly txId: string;
+    readonly currency: string;
+    readonly amount: string;
+    readonly at: number;
+}
+
+declare interface EconomyReference {
+    readonly kind: string;
+    readonly id: string;
+}
+
+export declare interface EconomyReportOptions {
+    readonly tenantId: string;
+    readonly maxRows?: number;
+    readonly maxGroups?: number;
+}
+
+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 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>;
+}
+
+export 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 economySubjectsTable: Table<"_voltro_eco_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerKind: ColumnBuilder<"player" | "guild", "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly entriesCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+/** Full installed replacement adds both privacy hooks; the dependent port stays four methods. */
+declare interface EconomySystemService extends EconomyService {
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+export declare const economyTables: readonly [ Table<"_voltro_eco_currencies", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly currency: ColumnBuilder<string, "text", boolean>;
+    readonly config: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_wallets", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerKind: ColumnBuilder<"player" | "guild", "text", boolean>;
+    readonly currency: ColumnBuilder<string, "text", boolean>;
+    readonly balance: ColumnBuilder<string, "bigint", boolean>;
+    readonly updatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly debtPolicy: ColumnBuilder<"allowNegative" | "blockSpend" | null, "text", boolean>;
+}>, true, never>, Table<"_voltro_eco_ledger", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly txId: ColumnBuilder<string, "text", boolean>;
+    readonly currency: ColumnBuilder<string, "text", boolean>;
+    readonly accountKind: ColumnBuilder<"system" | "wallet", "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKind: ColumnBuilder<"player" | "guild" | null, "text", boolean>;
+    readonly walletKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly systemAccount: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerSequence: ColumnBuilder<number | null, "integer", boolean>;
+    readonly debtPolicy: ColumnBuilder<"allowNegative" | "blockSpend" | null, "text", boolean>;
+    readonly debit: ColumnBuilder<string, "bigint", boolean>;
+    readonly credit: ColumnBuilder<string, "bigint", boolean>;
+    readonly reason: ColumnBuilder<string, "text", boolean>;
+    readonly refKind: ColumnBuilder<string | null, "text", boolean>;
+    readonly refId: ColumnBuilder<string | null, "text", boolean>;
+    readonly actor: ColumnBuilder<string | null, "text", boolean>;
+    readonly at: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_eco_tx", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "pending" | "committed", "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly escrow: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_eco_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerKind: ColumnBuilder<"player" | "guild", "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly entriesCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>];
+
+export declare const economyTransactionsTable: Table<"_voltro_eco_tx", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "pending" | "committed", "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly escrow: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+declare interface EconomyWallet {
+    readonly currency: string;
+    readonly balance: string;
+    readonly updatedAt: number | null;
+}
+
+declare interface EconomyWalletAudit {
+    readonly currency: string;
+    readonly balance: string;
+    readonly ledgerBalance: string;
+    readonly ledgerRows: number;
+    readonly matches: boolean;
+}
+
+export declare const economyWalletsTable: Table<"_voltro_eco_wallets", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerKind: ColumnBuilder<"player" | "guild", "text", boolean>;
+    readonly currency: ColumnBuilder<string, "text", boolean>;
+    readonly balance: ColumnBuilder<string, "bigint", boolean>;
+    readonly updatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly debtPolicy: ColumnBuilder<"allowNegative" | "blockSpend" | null, "text", boolean>;
+}>, true, never>;
+
+export declare type EscrowWallet = Extract<EconomyAccount, {
+    readonly kind: 'wallet';
+}>;
+
+export declare interface GoogleIapAccessTokenSource {
+    /** Server-side service-account OAuth authority with androidpublisher scope. Never player input. */
+    readonly read: () => Effect.Effect<string, EconomyError>;
+}
+
+/** Explicit completion only after accepted SQL capability. Never grants, refunds or infers POST success. */
+export declare const googleIapCompletionPort: (input: GoogleIapVerificationOptions) => IapCompletionService;
+
+export declare interface GoogleIapCurrentStateOptions extends Omit<IapCurrentStateOptions, 'channel'> {
+    readonly accessTokens: GoogleIapAccessTokenSource;
+    readonly subscriptionPlans?: readonly GoogleIapSubscriptionPlan[];
+    readonly timeoutMs?: number;
+    readonly maxResponseBytes?: number;
+}
+
+/** Fresh authenticated product or pinned subscription-order GET, actual SQL/account revalidation and bounded evidence; no writes. */
+export declare const googleIapCurrentStatePort: (input: GoogleIapCurrentStateOptions) => IapCurrentStateService;
+
+export declare interface GoogleIapNotificationOptions {
+    readonly realMoney: boolean;
+    readonly applicationId: string;
+    readonly audience: string;
+    readonly serviceAccountEmail: string;
+    readonly subscription: string;
+    /** Input work budget, not measured delivery capacity. */
+    readonly maxBodyBytes?: number;
+    readonly now?: (() => number) | undefined;
+}
+
+/** Authenticated Pub/Sub RTDN, using the shared JWKS verifier. Payload is a hint, never current state. */
+export declare const googleIapNotificationPort: (input: GoogleIapNotificationOptions) => IapNotificationService;
+
+/** One installed Play declaration with real verification and explicit completion. Construction performs no I/O. */
+export declare const googleIapProvider: (input: GoogleIapProviderOptions) => IapProviderDefinition;
+
+export declare type GoogleIapProviderOptions = Pick<GoogleIapVerificationOptions, 'environment' | 'applicationId' | 'accessTokens' | 'timeoutMs' | 'maxResponseBytes' | 'subscriptionPlans'> & {
+    readonly notifications?: Pick<GoogleIapNotificationOptions, 'audience' | 'serviceAccountEmail' | 'subscription' | 'maxBodyBytes'> | undefined;
+};
+
+export declare interface GoogleIapSubscriptionPlan {
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly basePlanId: string;
+    readonly storeOfferId: string | null;
+}
+
+export declare interface GoogleIapVerificationOptions extends Omit<IapVerificationOptions, 'channel'> {
+    readonly accessTokens: GoogleIapAccessTokenSource;
+    readonly subscriptionPlans?: readonly GoogleIapSubscriptionPlan[];
+    /** Work budgets, not measured provider latency or response capacity. */
+    readonly timeoutMs?: number;
+    readonly maxResponseBytes?: number;
+}
+
+/** Authenticated Products v2 or Subscription v2 plus pinned Orders lookup. No grant or provider write occurs here. */
+export declare const googleIapVerificationPort: (input: GoogleIapVerificationOptions) => IapVerificationService;
+
+declare interface IapAcceptedCompletionContext {
+    readonly orderId: string;
+    readonly scope: IapScope;
+    readonly intent: IapReceiptIntent;
+    readonly product: IapProduct;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly facts: IapTransactionFacts;
+}
+
+/** Internal provider consumers only; private push material is never an RPC/inspect projection. */
+declare interface IapAcceptedNotificationContext extends IapAcceptedNotificationObservation {
+    readonly notification: VerifiedIapNotification;
+    readonly scope: IapScope;
+    readonly product: IapProduct;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly facts: IapTransactionFacts;
+    readonly fingerprint: string;
+    readonly material: Readonly<Record<string, unknown>>;
+}
+
+export declare interface IapAcceptedNotificationObservation {
+    readonly orderId: string;
+    readonly notice: IapNotificationNotice;
+    readonly receipt: IapOrderReceipt;
+}
+
+export 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>;
+}
+
+/** Which owner a provider-held account token belongs to. A provider that delivers purchases on its
+ * own (a renewal webhook) knows only the token it was given at checkout; `null` when the token is
+ * unknown or its owner was erased. Read-only: no seed, no fence, no token is minted. */
+export declare interface IapAccountOwners {
+    readonly owner: (token: string) => Effect.Effect<IapScope | null, EconomyError>;
+}
+
+export declare type IapAccountSource = Pick<IapAccountBindingService, 'read' | 'prepareBinding'>;
+
+export declare class IapAccountsPort extends IapAccountsPort_base {
+}
+
+declare const IapAccountsPort_base: Context.ServiceClass<IapAccountsPort, "@voltro/IapAccountsPort", IapAccountBindingService>;
+
+export declare const iapAccountsTable: Table<"_voltro_eco_iap_accounts", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly applicationId: ColumnBuilder<string, "text", boolean>;
+    readonly channel: ColumnBuilder<"web" | "ios" | "android" | "steam", "text", boolean>;
+    readonly environment: ColumnBuilder<"production" | "sandbox", "text", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly token: ColumnBuilder<string | null, "text", boolean>;
+    readonly tokenKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, "voltro_eco_iap_accounts_owner_idx">;
+
+export declare interface IapAccountStoreOptions {
+    readonly realMoney: boolean;
+    readonly applicationId: string;
+    readonly channel: EconomyChannel;
+    readonly environment: IapEnvironment;
+}
+
+export declare const iapAccountTables: readonly [ Table<"_voltro_eco_iap_accounts", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly applicationId: ColumnBuilder<string, "text", boolean>;
+    readonly channel: ColumnBuilder<"web" | "ios" | "android" | "steam", "text", boolean>;
+    readonly environment: ColumnBuilder<"production" | "sandbox", "text", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly token: ColumnBuilder<string | null, "text", boolean>;
+    readonly tokenKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, "voltro_eco_iap_accounts_owner_idx">, Table<"_voltro_eco_iap_account_tokens", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly applicationId: ColumnBuilder<string, "text", boolean>;
+    readonly channel: ColumnBuilder<"web" | "ios" | "android" | "steam", "text", boolean>;
+    readonly environment: ColumnBuilder<"production" | "sandbox", "text", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly accountKey: ColumnBuilder<string, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+}>, true, "voltro_eco_iap_account_tokens_scope_idx">];
+
+/** Permanent uniqueness custody survives removal of the public account-binding token. */
+export declare const iapAccountTokensTable: Table<"_voltro_eco_iap_account_tokens", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly applicationId: ColumnBuilder<string, "text", boolean>;
+    readonly channel: ColumnBuilder<"web" | "ios" | "android" | "steam", "text", boolean>;
+    readonly environment: ColumnBuilder<"production" | "sandbox", "text", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly accountKey: ColumnBuilder<string, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+}>, true, "voltro_eco_iap_account_tokens_scope_idx">;
+
+/** A web checkout about to start: nothing is paid or verified yet. */
+export 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. */
+export declare interface IapCheckoutContext {
+    readonly scope: IapScope;
+    readonly product: IapProduct;
+    readonly requestId: string;
+    readonly accountToken: string;
+    readonly returnUrl: string;
+    readonly at: number;
+}
+
+export declare interface IapCheckoutIntent {
+    readonly channel: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly requestId: string;
+    readonly returnUrl: string;
+}
+
+/** 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. */
+export 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. */
+export declare interface IapCheckoutSession {
+    readonly checkoutId: string;
+    readonly redirectUrl: string;
+    readonly expiresAt: number;
+}
+
+export declare interface IapCompletionAuthority {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    /** Actual fresh provider state must confirm completion, not only an accepted POST. */
+    readonly complete: (context: IapCompletionContext) => Effect.Effect<IapCompletionReceipt, EconomyError>;
+}
+
+export declare interface IapCompletionContext extends IapAcceptedCompletionContext {
+    readonly accountToken: string;
+    readonly at: number;
+}
+
+export declare class IapCompletionPort extends IapCompletionPort_base {
+}
+
+/** Deliberate trusted server authority, with actual SQL capability and account/declaration admission. */
+export declare const iapCompletionPort: (input: IapVerificationOptions, authorityInput: IapCompletionAuthority) => IapCompletionService;
+
+declare const IapCompletionPort_base: Context.ServiceClass<IapCompletionPort, "@voltro/IapCompletionPort", IapCompletionService>;
+
+export declare interface IapCompletionReceipt {
+    readonly orderId: string;
+    readonly channel: EconomyChannel;
+    readonly operation: 'acknowledge' | 'consume' | 'finalize' | 'finish';
+    readonly observedAt: number;
+}
+
+export declare interface IapCompletionService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly complete: (evidence: AcceptedIapCompletion) => Effect.Effect<IapCompletionReceipt, EconomyError>;
+}
+
+export 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;
+}
+
+/** Trusted server read projection; opaque state cannot be reconstructed from this result. */
+export declare const iapCurrentPurchaseState: (proof: VerifiedIapCurrentState) => Effect.Effect<IapCurrentPurchaseState, EconomyError>;
+
+export declare interface IapCurrentStateAuthority {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly read: (context: IapCurrentStateContext) => Effect.Effect<IapCurrentPurchaseState, EconomyError>;
+}
+
+export declare interface IapCurrentStateContext extends IapAcceptedNotificationContext {
+    readonly accountToken: string;
+    readonly at: number;
+}
+
+export declare interface IapCurrentStateOptions extends IapNotificationTargetOptions {
+    readonly accounts: Pick<IapAccountBindingService, 'observe' | 'prepareBinding'>;
+    /** Evidence lifetime budget, not an external provider consistency guarantee. */
+    readonly maxAgeMs?: number;
+    readonly now?: (() => number) | undefined;
+}
+
+export declare class IapCurrentStatePort extends IapCurrentStatePort_base {
+}
+
+/** The provider receives accepted history only after actual SQL and account admission; I/O never writes assets. */
+export declare const iapCurrentStatePort: (input: IapCurrentStateOptions, authorityInput: IapCurrentStateAuthority) => IapCurrentStateService;
+
+declare const IapCurrentStatePort_base: Context.ServiceClass<IapCurrentStatePort, "@voltro/IapCurrentStatePort", IapCurrentStateService>;
+
+export declare interface IapCurrentStateService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly read: (target: AcceptedIapNotificationTarget) => Effect.Effect<VerifiedIapCurrentState, EconomyError>;
+}
+
+export 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. */
+export 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). */
+export 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;
+}
+
+export declare interface IapEntitlementsOptions {
+    readonly realMoney: boolean;
+    readonly version: string;
+    /** Actual default SQL adapter, or a source owning the same complete accepted-history/privacy contract. */
+    readonly orders: Pick<IapSqlService, 'subscriptionPeriods' | 'exportSubject' | 'eraseSubject'>;
+    readonly policy?: IapEntitlementPolicy;
+    readonly now?: (() => number) | undefined;
+}
+
+export declare interface IapEntitlementsPluginOptions {
+    readonly version: string;
+    readonly policy?: IapEntitlementPolicy;
+    readonly service?: IapEntitlementsService;
+    readonly querySources?: readonly string[] | undefined;
+}
+
+/** Actual accepted SQL period observation. This read is not a prepared value-write authority. */
+export declare const iapEntitlementsPort: (input: IapEntitlementsOptions) => IapEntitlementsService;
+
+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). */
+export 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;
+}
+
+export 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>;
+}
+
+export declare const iapNamespacesTable: Table<"_voltro_eco_iap_namespaces", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly namespace: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly ordersCount: ColumnBuilder<number, "integer", boolean>;
+    readonly receiptsCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+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';
+}
+
+export 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>>;
+}
+
+export declare interface IapNotificationNotice {
+    readonly channel: IapRefundChannel;
+    readonly applicationId: string;
+    /** RTDN itself does not identify sandbox/production. Fresh lookup must establish it. */
+    readonly environment: IapEnvironment | null;
+    readonly noticeId: string;
+    readonly sourceType: string;
+    readonly kind: 'one-time' | 'subscription' | 'voided' | 'review' | 'test';
+    readonly occurredAt: number;
+    readonly transactionId: string | null;
+    readonly originalTransactionId: string | null;
+    readonly storeProductId: string | null;
+}
+
+export declare const iapNotificationNotice: (input: VerifiedIapNotification) => IapNotificationNotice;
+
+export declare class IapNotificationPort extends IapNotificationPort_base {
+}
+
+declare const IapNotificationPort_base: Context.ServiceClass<IapNotificationPort, "@voltro/IapNotificationPort", IapNotificationService>;
+
+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>;
+}
+
+export 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>;
+}
+
+export declare interface IapNotificationTargetOptions {
+    readonly realMoney: boolean;
+    readonly channel: IapRefundChannel;
+    readonly applicationId: string;
+    readonly environment: IapEnvironment;
+}
+
+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;
+    }[];
+}
+
+export declare const iapOrdersTable: Table<"_voltro_eco_iap_orders", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly namespace: ColumnBuilder<string, "text", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly accepted: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly offerId: ColumnBuilder<string, "text", boolean>;
+    readonly acceptedQuantity: ColumnBuilder<number | null, "integer", boolean>;
+    readonly acceptedDay: ColumnBuilder<number | null, "integer", boolean>;
+    readonly offerVersion: ColumnBuilder<string, "text", boolean>;
+    readonly channel: ColumnBuilder<"web" | "ios" | "android" | "steam", "text", boolean>;
+    readonly configurationDigest: ColumnBuilder<string, "text", boolean>;
+    readonly intentDigest: ColumnBuilder<string | null, "text", boolean>;
+    readonly receiptKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly snapshot: ColumnBuilder<unknown, "json", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly fulfilledAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>;
+
+/** Provider units retain their own decimal scale. Reference prices are never substituted. */
+declare interface IapPaidAmount {
+    readonly currency: string;
+    readonly units: string;
+    readonly scale: number;
+}
+
+export 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';
+
+export 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;
+}
+
+export 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;
+}
+
+export 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. */
+export 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;
+}
+
+/** Primary identity is application/environment/channel/transaction, independent of namespace and tenant. */
+export declare const iapReceiptsTable: Table<"_voltro_eco_iap_receipts", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly namespace: ColumnBuilder<string, "text", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly orderKey: ColumnBuilder<string, "text", boolean>;
+    readonly identity: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly accepted: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly factsDigest: ColumnBuilder<string, "text", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly fulfilledAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>;
+
+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. */
+export 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. */
+export 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>;
+}
+
+/** A real-money admission: app eligibility plus a monthly spend limit per owner over the
+ * owner's accepted orders, checked in the purchase's own transaction. */
+export declare const iapSpendAdmission: (store: DataStore, input: IapSpendAdmissionOptions) => IapPurchaseAdmissionSource;
+
+export declare interface IapSpendAdmissionOptions {
+    /** The IAP system's `namespace`: whose accepted orders count towards the limit. */
+    readonly namespace: string;
+    /** Real money one owner may pay per UTC calendar month, per currency, in that currency's
+     * provider units (`{ EUR: { units: '5000', scale: 2 } }` = 50.00 EUR). A purchase in a
+     * currency without a limit, or without a paid amount, is refused. A later period of a
+     * subscription the owner already holds is not limited (it still counts for other purchases). */
+    readonly monthlyLimits: Readonly<Record<string, {
+        readonly units: string;
+        readonly scale: number;
+    }>>;
+    /** App eligibility (age gate, upgraded account, consent...), inside the purchase transaction
+     * and once more before a web checkout starts. `false` refuses the purchase. */
+    readonly eligible: (tx: DataStore, input: IapCheckoutAdmission) => Promise<boolean>;
+    /** Accepted orders read per check; more refuses as the limit cannot be proven. Default 1000. */
+    readonly maxOrdersPerMonth?: number;
+}
+
+/** SQL original after the owning adapter has validated its immutable custody and receipt. */
+export declare interface IapSqlOriginalPurchase {
+    readonly orderId: string;
+    readonly scope: IapScope;
+    readonly receipt: IapOrderReceipt;
+    readonly product: IapProduct;
+    readonly facts: IapTransactionFacts;
+    readonly currencies: readonly CurrencyDefinition[];
+}
+
+export declare interface IapSqlService extends IapService {
+    /** Complete owned accepted subscription periods. SQL reads only; never current provider status. */
+    readonly subscriptionPeriods: (subject: Subject) => Effect.Effect<readonly IapSubscriptionPeriod[], EconomyError>;
+    /** Server only: the provider's original transaction IDs (a Stripe subscription) of the owner's
+     * accepted subscription orders on `channel`, newest period first. Never a player projection. */
+    readonly subscriptionOriginals: (subject: Subject, channel: EconomyChannel) => Effect.Effect<readonly string[], EconomyError>;
+    /** Actual original IAP/account/retained-notice SQL fences; joins the same-store financial mutation group. */
+    readonly prepareCurrentState: (evidence: VerifiedIapCurrentState) => Effect.Effect<PreparedSqlMutation<IapCurrentPurchaseState>, EconomyError>;
+    /** Trusted server declaration + authenticated notice; read accepted SQL, never seed or fulfill. */
+    readonly prepareNotification: (options: IapNotificationTargetOptions, notice: VerifiedIapNotification) => Effect.Effect<AcceptedIapNotificationTarget, EconomyError>;
+    /** Read accepted SQL original and issue a revalidated capability; no grant, clock or provider call. */
+    readonly prepareCompletion: (subject: Subject, intent: Parameters<IapService['redeem']>[1]) => Effect.Effect<AcceptedIapCompletion, EconomyError>;
+}
+
+export 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;
+}
+
+export declare const iapSubjectsTable: Table<"_voltro_eco_iap_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly namespace: ColumnBuilder<string, "text", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly ordersCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+/** 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;
+}
+
+export declare class IapSystemPort extends IapSystemPort_base {
+}
+
+declare const IapSystemPort_base: Context.ServiceClass<IapSystemPort, "@voltro/IapSystemPort", IapSystemService>;
+
+/** Complete system replacement owns provider readiness, accounts, financial authority and privacy. */
+export 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>;
+}
+
+export declare const iapTables: readonly [ Table<"_voltro_eco_iap_namespaces", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly namespace: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly ordersCount: ColumnBuilder<number, "integer", boolean>;
+    readonly receiptsCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_iap_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly namespace: ColumnBuilder<string, "text", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly ordersCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_iap_orders", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly namespace: ColumnBuilder<string, "text", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly accepted: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly offerId: ColumnBuilder<string, "text", boolean>;
+    readonly acceptedQuantity: ColumnBuilder<number | null, "integer", boolean>;
+    readonly acceptedDay: ColumnBuilder<number | null, "integer", boolean>;
+    readonly offerVersion: ColumnBuilder<string, "text", boolean>;
+    readonly channel: ColumnBuilder<"web" | "ios" | "android" | "steam", "text", boolean>;
+    readonly configurationDigest: ColumnBuilder<string, "text", boolean>;
+    readonly intentDigest: ColumnBuilder<string | null, "text", boolean>;
+    readonly receiptKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly snapshot: ColumnBuilder<unknown, "json", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly fulfilledAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_eco_iap_receipts", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly namespace: ColumnBuilder<string, "text", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly orderKey: ColumnBuilder<string, "text", boolean>;
+    readonly identity: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly accepted: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly factsDigest: ColumnBuilder<string, "text", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly fulfilledAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>];
+
+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';
+}
+
+/** Trusted server replacement. It owns provider authenticity, fresh status and account binding. */
+export declare interface IapVerificationAuthority {
+    /** Required provider setup/credential readiness; no permissive initialization fallback. */
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly verify: (context: IapVerificationContext) => Effect.Effect<IapTransactionFacts, EconomyError>;
+}
+
+export declare interface IapVerificationContext {
+    readonly scope: IapScope;
+    readonly intent: IapReceiptIntent;
+    readonly product: IapProduct;
+    readonly accountToken: string;
+    readonly at: number;
+}
+
+export declare interface IapVerificationOptions {
+    readonly realMoney: boolean;
+    readonly channel: EconomyChannel;
+    readonly environment: IapEnvironment;
+    readonly applicationId: string;
+    readonly products: readonly IapProductDefinition[];
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly accounts: IapAccountSource;
+    readonly now?: (() => number) | undefined;
+}
+
+export declare class IapVerificationPort extends IapVerificationPort_base {
+}
+
+/** Captures one deliberately trusted server authority; never call with player data. */
+export declare const iapVerificationPort: (input: IapVerificationOptions, authorityInput: IapVerificationAuthority) => IapVerificationService;
+
+declare const IapVerificationPort_base: Context.ServiceClass<IapVerificationPort, "@voltro/IapVerificationPort", IapVerificationService>;
+
+export declare interface IapVerificationService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly verify: (scope: IapScope, input: IapReceiptIntent) => Effect.Effect<VerifiedIapPurchase, EconomyError>;
+}
+
+export declare interface IapWalletRefundInput {
+    readonly requestId: string;
+    readonly currency: string;
+    readonly amount: string;
+    readonly debtPolicy: IapDebtPolicy;
+}
+
+export declare interface InventoryTradeAuthorityOptions {
+    readonly permissions: TradePermissionSource;
+    readonly inventory: Pick<InventorySqlService, 'mine' | 'reservationEvidence'>;
+    readonly items: readonly ItemDefinition[];
+}
+
+/** Actual Inventory ownership and original reservation evidence plus mandatory
+ * application policy. Asset writers still revalidate fresh stock and expiry in
+ * the same SQL group. This installs no sanctions, consent records or new tables. */
+export declare const inventoryTradeAuthoritySource: (store: DataStore, input: InventoryTradeAuthorityOptions) => TradeAuthoritySource;
+
+export declare const isIapRefundChannel: (value: unknown) => value is IapRefundChannel;
+
+/** Internal authenticated adapters or validated encrypted SQL custody only. Deliberately absent from the public server entry. */
+export declare const issueVerifiedIapNotification: (notice: IapNotificationNotice, material: Readonly<Record<string, unknown>>, validate?: () => Effect.Effect<void, EconomyError>, prepare?: () => Effect.Effect<PreparedSqlMutation<unknown>, EconomyError>) => VerifiedIapNotification;
+
+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;
+}
+
+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. */
+declare interface LoyaltyCreditInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly loyaltyId: string;
+    readonly sourceId: string;
+    readonly purchaseId: string;
+    readonly requestId: string;
+}
+
+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 const loyaltyDefinitionsTable: Table<"_voltro_eco_loyalty_definitions", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly loyaltyId: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+    readonly currencies: ColumnBuilder<unknown, "json", boolean>;
+    readonly realMoney: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+}>, true, never>;
+
+export declare const loyaltyEntriesTable: Table<"_voltro_eco_loyalty_entries", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly loyaltyId: ColumnBuilder<string, "text", boolean>;
+    readonly sequence: ColumnBuilder<number, "integer", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled", "text", boolean>;
+    readonly purchaseKey: ColumnBuilder<string, "text", boolean>;
+    readonly refundKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly body: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+declare interface LoyaltyMineInput {
+    readonly loyaltyId: string;
+}
+
+declare type LoyaltyObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: LoyaltyReceipt;
+};
+
+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;
+    }[];
+};
+
+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;
+};
+
+declare interface LoyaltyPerksContext extends LoyaltyTierContext {
+    readonly tierId: string;
+}
+
+declare type LoyaltyPerksResolver = (input: LoyaltyPerksContext) => readonly LoyaltyPerk[];
+
+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;
+};
+
+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;
+    }[];
+}
+
+/** 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. */
+export 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';
+}
+
+declare interface LoyaltyRebuildInput extends LoyaltyMineInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+}
+
+declare interface LoyaltyReceipt {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly loyaltyId: string;
+    readonly entry: LoyaltyPointEntry;
+    readonly points: string;
+}
+
+declare interface LoyaltyReceiptInput {
+    readonly requestId: string;
+}
+
+export 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>;
+}
+
+export declare interface LoyaltyRefundEvidence {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly authorityId: string;
+    readonly purchaseId: string;
+    readonly refundId: string;
+    readonly totalRefunded: string;
+    readonly refundedAt: number;
+}
+
+declare interface LoyaltyReverseInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly loyaltyId: string;
+    readonly originalId: string;
+    readonly refundId: string;
+    readonly requestId: string;
+}
+
+export declare interface LoyaltySeason {
+    readonly id: string;
+    readonly startsAt: number;
+    readonly endsAt: number;
+}
+
+export declare interface LoyaltySeasonSource {
+    readonly read: (input: {
+        readonly tenantId: string;
+        readonly loyaltyId: string;
+        readonly at: number;
+    }) => Effect.Effect<LoyaltySeason, EconomyError>;
+}
+
+export declare const loyaltySeasonsTable: Table<"_voltro_eco_loyalty_seasons", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly loyaltyId: ColumnBuilder<string, "text", boolean>;
+    readonly seasonId: ColumnBuilder<string, "text", boolean>;
+    readonly startsAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly endsAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+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>;
+}
+
+declare interface LoyaltyState {
+    readonly loyalty: Loyalty;
+    readonly rulesVersion: string;
+    readonly seasonId: string | null;
+    readonly points: string;
+    readonly tierId: string;
+    readonly perks: readonly LoyaltyPerk[];
+}
+
+export 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 const loyaltySubjectsTable: Table<"_voltro_eco_loyalty_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly entriesCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+/** Shared immutable definitions/seasons survive subject erasure. */
+export declare const loyaltyTables: readonly [ Table<"_voltro_eco_loyalty_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_loyalty_definitions", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly loyaltyId: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+    readonly currencies: ColumnBuilder<unknown, "json", boolean>;
+    readonly realMoney: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+}>, true, never>, Table<"_voltro_eco_loyalty_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly entriesCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_loyalty_entries", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly loyaltyId: ColumnBuilder<string, "text", boolean>;
+    readonly sequence: ColumnBuilder<number, "integer", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled", "text", boolean>;
+    readonly purchaseKey: ColumnBuilder<string, "text", boolean>;
+    readonly refundKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly body: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_eco_loyalty_seasons", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly loyaltyId: ColumnBuilder<string, "text", boolean>;
+    readonly seasonId: ColumnBuilder<string, "text", boolean>;
+    readonly startsAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly endsAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>];
+
+export declare const loyaltyTenantsTable: Table<"_voltro_eco_loyalty_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+declare interface LoyaltyTierContext {
+    readonly loyalty: Loyalty;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly points: EconomyAmountInput;
+    readonly rulesVersion?: string;
+}
+
+declare type LoyaltyTierResolver = (context: LoyaltyTierContext) => string;
+
+/** Trusted server observation. No owner/raw push material, writes, grant or refund from this helper. */
+export declare const observeAcceptedIapNotificationTarget: (target: AcceptedIapNotificationTarget) => Effect.Effect<IapAcceptedNotificationObservation, EconomyError>;
+
+/** Actual pending SQL event authority. Copies and serialized payloads cannot authorize delivery acknowledgement. */
+declare interface PendingIapRefundEvent {
+    readonly [refundEvent]: true;
+    readonly eventId: string;
+}
+
+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';
+}
+
+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 const piggyBankDigest: (bank: PiggyBank, version: string) => string;
+
+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 const piggyDefinitionsTable: Table<"_voltro_eco_piggy_definitions", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly bankId: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+    readonly currencies: ColumnBuilder<unknown, "json", boolean>;
+    readonly realMoney: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+}>, true, never>;
+
+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 const piggyEventsTable: Table<"_voltro_eco_piggy_events", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly sequence: ColumnBuilder<number, "integer", boolean>;
+    readonly bankId: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled", "text", boolean>;
+    readonly eventKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly body: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+declare interface PiggyFillContext extends PiggyRuleContext {
+    readonly acceptedAmount: EconomyAmountInput;
+}
+
+export declare interface PiggyFillEvidence {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly authorityId: string;
+    readonly eventId: string;
+    readonly sourceId: string;
+    readonly amount: string;
+    readonly acceptedAt: number;
+}
+
+declare interface PiggyFillInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly bankId: string;
+    readonly sourceId: string;
+    readonly eventId: string;
+    readonly requestId: string;
+}
+
+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. */
+export 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>;
+}
+
+declare type PiggyObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: PiggyReceipt;
+};
+
+declare interface PiggyProjection {
+    readonly events: readonly PiggyEvent[];
+    readonly available: string;
+    readonly cycles: number;
+}
+
+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;
+};
+
+declare type PiggyResetPolicy = (context: PiggyRuleContext) => EconomyAmountInput;
+
+declare interface PiggyRuleContext {
+    readonly bank: PiggyBank;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly available: EconomyAmountInput;
+    readonly rulesVersion?: string;
+}
+
+export 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 const piggySubjectsTable: Table<"_voltro_eco_piggy_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly entriesCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+export declare const piggyTables: readonly [ Table<"_voltro_eco_piggy_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_piggy_definitions", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly bankId: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+    readonly currencies: ColumnBuilder<unknown, "json", boolean>;
+    readonly realMoney: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+}>, true, never>, Table<"_voltro_eco_piggy_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly entriesCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_piggy_events", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly sequence: ColumnBuilder<number, "integer", boolean>;
+    readonly bankId: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled", "text", boolean>;
+    readonly eventKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly body: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>];
+
+export declare const piggyTenantsTable: Table<"_voltro_eco_piggy_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+declare interface PiggyUnlockInput {
+    readonly bankId: string;
+    readonly bankVersion: string;
+    readonly bankDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+}
+
+export 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>;
+}
+
+declare interface PiggyView {
+    readonly bank: PiggyBank;
+    readonly bankDigest: string;
+    readonly available: string;
+    readonly cycles: number;
+}
+
+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';
+};
+
+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';
+};
+
+declare type PriceResolver = (context: PriceResolverContext) => Price;
+
+declare interface PriceResolverContext {
+    readonly price: Price;
+    readonly currencies: readonly ResolvedCurrency[];
+    readonly realMoney: boolean;
+    readonly adjustments: readonly Readonly<{
+        currency: string;
+        discountBps: number;
+        minimum: string;
+    }>[];
+}
+
+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;
+    };
+}
+
+/** SQL is the only input. Bounded whole work refuses a prefix; no repair, backend fallback or timer. */
+export declare const readEconomyFlows: (store: DataStore, input: EconomyReportOptions) => Effect.Effect<readonly EconomyFlowRow[], EconomyError>;
+
+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>>>;
+}
+
+declare interface RedeemCodeInput {
+    readonly code: string;
+    readonly requestId: string;
+}
+
+declare const refundEvent: unique symbol;
+
+/** Ordinary authoritative SQL only. Prepared wallet/item units are the actual
+ * existing writers, combined into one exact-store commit; never a Room tick. */
+export declare const resolveCodeStoreOptions: (input: CodeStoreOptions) => Readonly<{
+    currencies: readonly ResolvedCurrency[];
+    economy: Pick<EconomySqlService, "prepareTransfer">;
+    inventory: Pick<InventorySqlService, "prepareGrant"> | undefined;
+    systemAccount: string;
+    allowedServices: readonly string[];
+    maxHistoryRows: number;
+    now: () => number;
+    eligibility: CodeEligibility;
+    version: string;
+}>;
+
+export declare const resolveContainersStoreOptions: (input: ContainersStoreOptions) => Readonly<{
+    containers: readonly Container[];
+    currencies: readonly ResolvedCurrency[];
+    realMoney: boolean;
+    economy: Pick<EconomySqlService, "prepareTransfer">;
+    inventory: Pick<InventorySqlService, "prepareGrant"> | undefined;
+    accessSource: ContainerAccessSource;
+    random: ContainerRandomService;
+    version: string;
+    probability: ContainerProbabilityResolver;
+    roll: ContainerRollResolver;
+    eligibility: ContainerEligibility;
+    priceResolver: PriceResolver;
+    systemAccount: string;
+    maxHistoryRows: number;
+    now: () => number;
+}>;
+
+declare interface ResolvedCurrency {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap: string;
+    readonly premium: boolean;
+    readonly display: {
+        readonly nameKey: string;
+    } | null;
+}
+
+declare interface ResolvedVirtualPriceOption {
+    readonly currency: string;
+    readonly amount: string;
+}
+
+export declare const resolveEconomyStoreOptions: (input: EconomyStoreOptions) => Readonly<{
+    currencies: readonly ResolvedCurrency[];
+    allowedServices: readonly string[];
+    maxLedgerRows: number;
+    maxExportRows: number;
+    now: () => number;
+    spendLimits: Readonly<{
+        limits: readonly SpendLimit[];
+        source: SpendFactsSource;
+        version: string;
+        policy: SpendLimitPolicy;
+    }> | undefined;
+}>;
+
+export declare const resolveIapStoreOptions: (input: IapStoreOptions) => Readonly<{
+    namespace: string;
+    currencies: readonly ResolvedCurrency[];
+    verification: Pick<IapVerificationService, "verify">;
+    admission: IapPurchaseAdmissionSource;
+    economy: Pick<EconomySqlService, "prepareTransfer">;
+    inventory: Pick<InventorySqlService, "prepareGrant"> | undefined;
+    refundDisposition: IapRefundDispositionSource | undefined;
+    systemAccount: string;
+    maxHistoryRows: number;
+    now: () => number;
+}>;
+
+export declare const resolveLoyaltyStoreOptions: (input: LoyaltyStoreOptions) => Readonly<{
+    loyalty: readonly Loyalty[];
+    currencies: readonly ResolvedCurrency[];
+    realMoney: boolean;
+    receiptSource: LoyaltyReceiptSource;
+    seasonSource: LoyaltySeasonSource | undefined;
+    version: string;
+    tier: LoyaltyTierResolver;
+    perks: LoyaltyPerksResolver;
+    now: () => number;
+    allowedServices: readonly string[];
+    maxHistoryRows: number;
+    maxDefinitionRows: number;
+    maxSeasonRows: number;
+}>;
+
+export declare const resolvePiggyStoreOptions: (input: PiggyStoreOptions) => Readonly<{
+    banks: readonly PiggyBank[];
+    currencies: readonly ResolvedCurrency[];
+    realMoney: boolean;
+    economy: Pick<EconomySqlService, "prepareTransfer">;
+    fillSource: PiggyFillSource;
+    unlockSource: PiggyUnlockSource;
+    version: string;
+    fill: PiggyFillPolicy;
+    reset: PiggyResetPolicy;
+    priceResolver: PriceResolver;
+    now: () => number;
+    allowedServices: readonly string[];
+    systemAccount: string;
+    maxHistoryRows: number;
+}>;
+
+export declare const resolveShopStoreOptions: (input: ShopStoreOptions) => Readonly<{
+    offers: readonly ShopOffer[];
+    currencies: readonly ResolvedCurrency[];
+    realMoney: boolean;
+    priceResolver: PriceResolver;
+    version: string;
+    contextSource: ShopContextSource | undefined;
+    economy: Readonly<{
+        prepareTransfer: (subject: Subject, input: LedgerTransferInput) => Effect.Effect<PreparedSqlMutation< EconomyReceipt>, EconomyError>;
+    }>;
+    inventory: Readonly<{
+        prepareGrant: (subject: Subject, input: InventoryGrant) => Effect.Effect<PreparedSqlMutation< InventoryReceipt>, InventoryError>;
+    }> | undefined;
+    systemAccount: string;
+    maxOrders: number;
+    maxAuditRows: number;
+    now: () => number;
+}>;
+
+export declare const resolveSubscriptionsStoreOptions: (input: SubscriptionsStoreOptions) => Readonly<{
+    subscriptions: readonly Subscription[];
+    currencies: readonly ResolvedCurrency[];
+    realMoney: boolean;
+    economy: Pick<EconomySqlService, "prepareTransfer">;
+    inventory: Pick<InventorySqlService, "prepareGrant"> | undefined;
+    accessSource: SubscriptionAccessSource;
+    version: string;
+    period: SubscriptionPeriodResolver;
+    daily: SubscriptionDailyGrantPolicy;
+    priceResolver: PriceResolver;
+    now: () => number;
+    systemAccount: string;
+    maxHistoryRows: number;
+}>;
+
+/** Sampling only, ordinary server boundary. No payment, grant, persisted pity or
+ * player route; caller must atomically accept this result in its owned journal. */
+export declare const sampleContainer: (input: ContainerProbabilityContext, probability?: ContainerProbabilityResolver, roll?: ContainerRollResolver) => Effect.Effect<Readonly<{
+    drop: ContainerDrop;
+    misses: number;
+    distribution: ContainerDistribution;
+}>, EconomyError, ContainerRandomPort>;
+
+/** Uses the actual server-only Sanctions capability, never separate sanction
+ * table reads or synthesized trust. Additional app consent gates must compose
+ * their own prepared SQL unit; this adapter establishes sanctions alone. */
+export declare const sanctionsTradePermissionSource: (store: DataStore, input: SanctionsSqlAdmissionService) => TradePermissionSource;
+
+export declare interface ShopAudit {
+    readonly matches: boolean;
+    readonly acceptedOrders: number;
+    readonly counters: number;
+}
+
+export declare interface ShopBundleValueInput {
+    readonly at: number;
+    readonly bundlePrice: Price;
+    readonly originals: readonly ShopBuyInput[];
+}
+
+export declare interface ShopBundleValueOptions {
+    readonly shop: Pick<ShopService, 'receipt'>;
+    readonly bundle: Bundle;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly version: string;
+    readonly maxPriceAgeMs: number;
+}
+
+declare interface ShopBuyInput {
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly offerDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+    readonly qty?: number | undefined;
+}
+
+declare interface ShopContextInput {
+    readonly subject: Subject;
+    readonly offer: ShopOffer;
+    readonly at: number;
+}
+
+declare interface ShopContextSnapshot {
+    readonly eligible: boolean;
+    readonly adjustments: readonly VirtualPriceAdjustment[];
+}
+
+/** Trusted external profile/segment/flag facts; never inside a replayable SQL callback. */
+declare interface ShopContextSource {
+    readonly read: (input: ShopContextInput) => Effect.Effect<ShopContextSnapshot, EconomyError>;
+}
+
+export declare const shopCountersTable: Table<"_voltro_eco_shop_counters", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly offerId: ColumnBuilder<string, "text", boolean>;
+    readonly scope: ColumnBuilder<"day" | "global" | "player", "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly day: ColumnBuilder<number | null, "integer", boolean>;
+    readonly units: ColumnBuilder<number, "integer", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+declare interface ShopCurrencyGrant {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+declare interface ShopItemGrant {
+    readonly itemId: string;
+    readonly qty: number;
+}
+
+/** Default SQL Shop receipt authority. Reads the real historical original through
+ * its owning service; never trusts a submitted amount or a configured price.
+ * Shop has no refund writer here: callers must supply an actual verified refund
+ * source to enable reversals. Omission refuses, never invents a refund. This is
+ * not a cross-system transaction or an automatic purchase event consumer. */
+export declare const shopLoyaltyReceiptSource: (store: DataStore, input: {
+    readonly shop: Pick<ShopService, "receipt">;
+    readonly refunds?: {
+        readonly read: LoyaltyReceiptSource["refund"];
+    };
+}) => LoyaltyReceiptSource;
+
+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;
+}
+
+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;
+}
+
+/** Server-owned immutable declaration/rule identity, reused by query, buy and fixtures. */
+export declare const shopOfferDigest: (offer: ShopOffer, rulesVersion: string) => string;
+
+export declare const shopOffersTable: Table<"_voltro_eco_offers", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly offerId: ColumnBuilder<string, "text", boolean>;
+    readonly version: ColumnBuilder<string, "text", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+}>, true, never>;
+
+declare interface ShopOfferView {
+    readonly offerDigest: string;
+    readonly offer: ShopOffer;
+    readonly price: Price;
+}
+
+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 shopOrdersTable: Table<"_voltro_eco_orders", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly intent: ColumnBuilder<unknown, "json", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly acceptedQty: ColumnBuilder<number | null, "integer", boolean>;
+    readonly counterKeys: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly fulfilledAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>;
+
+/** Nonterminal observations never authorize a new request identity or prove that no purchase can commit. */
+declare type ShopPurchaseObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: ShopOrderReceipt;
+};
+
+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;
+}
+
+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>;
+}
+
+export declare interface ShopSqlService extends ShopService {
+    readonly auditShop: (subject: Subject, tenantId: string) => Effect.Effect<ShopAudit, EconomyError>;
+    readonly rebuildShop: (subject: Subject, tenantId: string) => Effect.Effect<ShopAudit, EconomyError>;
+}
+
+export 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 const shopSubjectsTable: Table<"_voltro_eco_shop_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+export declare const shopTables: readonly [ Table<"_voltro_eco_shop_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_shop_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_offers", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly offerId: ColumnBuilder<string, "text", boolean>;
+    readonly version: ColumnBuilder<string, "text", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+}>, true, never>, Table<"_voltro_eco_orders", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly intent: ColumnBuilder<unknown, "json", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly acceptedQty: ColumnBuilder<number | null, "integer", boolean>;
+    readonly counterKeys: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly fulfilledAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_eco_shop_counters", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly offerId: ColumnBuilder<string, "text", boolean>;
+    readonly scope: ColumnBuilder<"day" | "global" | "player", "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly day: ColumnBuilder<number | null, "integer", boolean>;
+    readonly units: ColumnBuilder<number, "integer", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>];
+
+export declare const shopTenantsTable: Table<"_voltro_eco_shop_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+declare interface SpendBudget {
+    readonly daily: string | null;
+    readonly monthly: string | null;
+    readonly allowed: boolean;
+}
+
+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;
+}
+
+declare interface SpendFactsInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly ownerKind: 'player' | 'guild';
+    readonly currency: string;
+    readonly at: number;
+}
+
+declare interface SpendFactsSource {
+    readonly read: (input: SpendFactsInput) => Effect.Effect<SpendFacts, EconomyError>;
+}
+
+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;
+}
+
+declare interface SpendLimitContext {
+    readonly limit: SpendLimit;
+    readonly facts: SpendFacts;
+    readonly version: string;
+}
+
+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;
+    };
+}
+
+declare type SpendLimitPolicy = (input: SpendLimitContext) => SpendBudget;
+
+declare interface SpendLimitsOptions {
+    readonly limits: readonly (SpendLimitDefinition | SpendLimit)[];
+    readonly source: SpendFactsSource;
+    readonly version: string;
+    readonly policy?: SpendLimitPolicy;
+}
+
+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. */
+export 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>;
+}
+
+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;
+}
+
+declare interface SubscriptionCancelInput {
+    readonly entitlementId: string;
+    readonly requestId: string;
+}
+
+declare interface SubscriptionCancellationReceipt {
+    readonly operationId: string;
+    readonly entitlementId: string;
+    readonly at: number;
+    readonly renews: false;
+}
+
+declare interface SubscriptionDailyContext {
+    readonly entitlement: SubscriptionEntitlement;
+    readonly at: number;
+    readonly claimedDays: readonly number[];
+    readonly rulesVersion?: string;
+}
+
+declare type SubscriptionDailyGrantPolicy = (input: SubscriptionDailyContext) => boolean;
+
+declare interface SubscriptionDailyInput {
+    readonly entitlementId: string;
+    readonly requestId: string;
+}
+
+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 const subscriptionDefinitionDigest: (subscription: Subscription, version: string) => string;
+
+export declare const subscriptionDefinitionsTable: Table<"_voltro_eco_subscriptions", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+    readonly currencies: ColumnBuilder<unknown, "json", boolean>;
+    readonly realMoney: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+}>, true, never>;
+
+declare interface SubscriptionEntitlement {
+    readonly startsAt: number;
+    readonly expiresAt: number;
+    readonly graceUntil: number;
+    readonly state: 'active' | 'grace' | 'expired';
+}
+
+export declare const subscriptionEventsTable: Table<"_voltro_eco_subscription_events", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly sequence: ColumnBuilder<number, "integer", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled", "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly body: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+declare interface SubscriptionGift {
+    readonly items: ShopOffer['items'];
+    readonly currencies: ShopOffer['currencies'];
+}
+
+declare interface SubscriptionGiftDefinition {
+    readonly items?: ShopOfferDefinition['items'] | undefined;
+    readonly currencies?: ShopOfferDefinition['currencies'] | undefined;
+}
+
+declare type SubscriptionObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: SubscriptionValueReceipt | SubscriptionCancellationReceipt;
+};
+
+declare interface SubscriptionPeriodContext {
+    readonly subscription: Subscription;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly originAt: number;
+    readonly index: number;
+    readonly rulesVersion?: string;
+}
+
+declare type SubscriptionPeriodResolver = (input: SubscriptionPeriodContext) => SubscriptionWindow;
+
+declare type SubscriptionReceiptInput = {
+    readonly kind: 'start';
+    readonly intent: SubscriptionStartInput;
+} | {
+    readonly kind: 'renew' | 'daily' | 'cancel';
+    readonly intent: SubscriptionDailyInput;
+};
+
+declare interface SubscriptionRenewInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly entitlementId: string;
+    readonly requestId: string;
+}
+
+/** 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. */
+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>;
+}
+
+export 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. */
+declare interface SubscriptionStartInput {
+    readonly subscriptionId: string;
+    readonly subscriptionVersion: string;
+    readonly subscriptionDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+}
+
+export declare const subscriptionSubjectsTable: Table<"_voltro_eco_subscription_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+export declare const subscriptionTables: readonly [ Table<"_voltro_eco_subscription_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_subscriptions", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly definition: ColumnBuilder<unknown, "json", boolean>;
+    readonly currencies: ColumnBuilder<unknown, "json", boolean>;
+    readonly realMoney: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly rulesVersion: ColumnBuilder<string, "text", boolean>;
+}>, true, never>, Table<"_voltro_eco_subscription_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_subscription_events", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly sequence: ColumnBuilder<number, "integer", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled", "text", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly body: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>];
+
+export declare const subscriptionTenantsTable: Table<"_voltro_eco_subscription_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+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;
+}
+
+declare interface SubscriptionView {
+    readonly subscription: Subscription;
+    readonly subscriptionDigest: string;
+}
+
+declare interface SubscriptionWindow {
+    readonly startsAt: number;
+    readonly expiresAt: number;
+}
+
+declare interface TradeAcceptInput {
+    readonly tradeId: string;
+    readonly tradeDigest: string;
+    readonly requestId: string;
+}
+
+export declare interface TradeAuthorityAdmission {
+    readonly tenantId: string;
+    readonly tradeId: string;
+    readonly phase: 'propose' | 'accept';
+    readonly at: number;
+    readonly expiresAt: number;
+    readonly participants: readonly TradeParticipantAuthority[];
+}
+
+export declare interface TradeAuthorityReadInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly tradeId: string;
+    readonly at: number;
+}
+
+/** 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. */
+export 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>;
+}
+
+declare interface TradeCurrencyIntention {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+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;
+}
+
+declare type TradeEligibilityPolicy = (input: TradeEligibilityContext) => boolean;
+
+export declare interface TradeEscrowExchangeInput extends TradeEscrowTerms {
+    readonly accepterId: string;
+}
+
+export declare interface TradeEscrowExchangeReceipt {
+    readonly tradeId: string;
+    readonly offered: TradeEscrowLegReceipt;
+    readonly requested: TradeEscrowLegReceipt;
+}
+
+export declare interface TradeEscrowLegReceipt {
+    readonly inventory: InventoryReservationTransferReceipt | null;
+    readonly currencies: readonly {
+        readonly reserve: EconomyReceipt;
+        readonly settlement: WalletEscrowSettlementReceipt;
+    }[];
+}
+
+export 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;
+}
+
+/** Server composition only. The mandatory exact-store admission belongs to the
+ * durable Trade writer and actual eligibility authority. This does not install
+ * player routes, infer consent/sanctions or replace durable Trade custody. */
+export declare interface TradeEscrowParticipant {
+    readonly prepareReserve: (subject: Subject, input: TradeEscrowTerms, admission: PreparedSqlMutation<void>) => Effect.Effect<PreparedSqlMutation<TradeEscrowReserveReceipt>, EconomyError>;
+    readonly prepareRelease: (subject: Subject, input: TradeEscrowTerms, admission: PreparedSqlMutation<void>) => Effect.Effect<PreparedSqlMutation<TradeEscrowReserveReceipt>, EconomyError>;
+    readonly prepareExchange: (subject: Subject, input: TradeEscrowExchangeInput, admission: PreparedSqlMutation<void>) => Effect.Effect<PreparedSqlMutation<TradeEscrowExchangeReceipt>, EconomyError>;
+}
+
+export declare const tradeEscrowParticipant: (store: DataStore, input: TradeEscrowOptions) => TradeEscrowParticipant;
+
+export declare interface TradeEscrowReserveReceipt {
+    readonly tradeId: string;
+    readonly inventory: InventoryReceipt | null;
+    readonly currencies: readonly EconomyReceipt[];
+}
+
+export declare interface TradeEscrowTerms {
+    readonly tenantId: string;
+    readonly tradeId: string;
+    readonly proposerId: string;
+    readonly offered: TradeLegDefinition;
+    readonly requested: TradeLegDefinition;
+}
+
+export declare interface TradeExpiryInput {
+    readonly tenantId: string;
+    readonly maxTrades?: number | undefined;
+}
+
+export 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 TradeExpiryRunner {
+    readonly expireDueTrades: (subject: Subject, input: TradeExpiryInput) => Effect.Effect<TradeExpiryResult, EconomyError>;
+}
+
+/** Explicit app-owned registration; no plugin-wide automatic scheduler or new writer. */
+export declare const tradeExpirySchedule: (input: TradeExpiryScheduleOptions) => BrandedScheduleDefinition;
+
+export declare interface TradeExpiryScheduleOptions extends TradeExpiryInput {
+    readonly runner: TradeExpiryRunner;
+    readonly name?: string;
+    readonly cron?: string;
+    readonly timezone?: string;
+}
+
+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;
+}
+
+declare interface TradeItemIntention {
+    readonly instanceId: string;
+    readonly qty: number;
+}
+
+declare interface TradeLeg {
+    readonly items: readonly TradeItemIntention[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+}
+
+declare interface TradeLegDefinition {
+    readonly items: readonly TradeItemIntention[];
+    readonly currencies: readonly TradeCurrencyIntention[];
+}
+
+declare type TradeObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: TradeReceipt;
+};
+
+export declare const tradeOperationsTable: Table<"_voltro_eco_trade_operations", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly tradeId: ColumnBuilder<string | null, "text", boolean>;
+    readonly kind: ColumnBuilder<"expire" | "cancel" | "accept" | "propose", "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly sequence: ColumnBuilder<number | null, "integer", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly request: ColumnBuilder<unknown, "json", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly at: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>;
+
+declare interface TradeParticipantAuthority {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly allowed: boolean;
+    readonly trustScore: number;
+    readonly items: readonly TradeItemAuthority[];
+}
+
+export declare interface TradePermissionAdmission {
+    readonly tenantId: string;
+    readonly tradeId: string;
+    readonly phase: 'propose' | 'accept';
+    readonly at: number;
+    readonly expiresAt: number;
+    readonly participants: readonly TradePermissionFacts[];
+}
+
+export declare interface TradePermissionFacts {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly allowed: boolean;
+    readonly trustScore: number;
+}
+
+/** The owning sanctions/consent implementation must lock its actual SQL admission
+ * rows and revalidate these facts in the returned exact-store unit. A read-only
+ * sanctions port cannot provide this capability. No allow or trust default. */
+export declare interface TradePermissionSource {
+    readonly read: (input: TradeAuthorityReadInput) => Effect.Effect<TradePermissionFacts, EconomyError>;
+    readonly prepare: (input: TradePermissionAdmission) => Effect.Effect<PreparedSqlMutation<void>, EconomyError>;
+}
+
+declare interface TradeProposeInput {
+    readonly toId: string | null;
+    readonly offered: TradeLegDefinition;
+    readonly requested: TradeLegDefinition;
+    readonly durationMs: number;
+    readonly requestId: string;
+}
+
+declare interface TradeReceipt {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly trade: TradeView;
+}
+
+declare interface TradeRules {
+    readonly version: string;
+    readonly taxBps: number;
+    readonly maxDurationMs: number;
+    readonly minTrustScore: number;
+}
+
+declare interface TradeRulesDefinition {
+    readonly version: string;
+    readonly taxBps?: number;
+    readonly maxDurationMs?: number;
+    readonly minTrustScore?: number;
+}
+
+/** Full owning service; no default implementation or escrow installation is
+ * inferred from a Tag. SQL reservation/transfer/expiry/privacy own acceptance. */
+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>;
+}
+
+export 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>;
+}
+
+export declare const tradesTable: Table<"_voltro_eco_trades", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly proposerKey: ColumnBuilder<string, "text", boolean>;
+    readonly targetKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly accepterKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly accepted: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly state: ColumnBuilder<"erased" | "expired" | "pending" | "cancelled" | "accepted" | "proposed", "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly proposal: ColumnBuilder<unknown, "json", boolean>;
+    readonly closing: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly expiresAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>;
+
+export 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 const tradeSubjectsTable: Table<"_voltro_eco_trade_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly operationsCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+export declare const tradeTables: readonly [ Table<"_voltro_eco_trade_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly tradesCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_trade_subjects", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly operationsCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_eco_trades", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly proposerKey: ColumnBuilder<string, "text", boolean>;
+    readonly targetKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly accepterKey: ColumnBuilder<string | null, "text", boolean>;
+    readonly accepted: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly state: ColumnBuilder<"erased" | "expired" | "pending" | "cancelled" | "accepted" | "proposed", "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly proposal: ColumnBuilder<unknown, "json", boolean>;
+    readonly closing: ColumnBuilder<unknown, "json", boolean>;
+    readonly createdAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly expiresAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_eco_trade_operations", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerKey: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly tradeId: ColumnBuilder<string | null, "text", boolean>;
+    readonly kind: ColumnBuilder<"expire" | "cancel" | "accept" | "propose", "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "fulfilled" | "pending", "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly sequence: ColumnBuilder<number | null, "integer", boolean>;
+    readonly digest: ColumnBuilder<string | null, "text", boolean>;
+    readonly request: ColumnBuilder<unknown, "json", boolean>;
+    readonly receipt: ColumnBuilder<unknown, "json", boolean>;
+    readonly at: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>];
+
+declare interface TradeTaxContext {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+    readonly rules: TradeRules;
+}
+
+declare type TradeTaxPolicy = (input: TradeTaxContext) => EconomyAmountInput;
+
+declare interface TradeTaxView {
+    readonly leg: 'offered' | 'requested';
+    readonly currency: string;
+    readonly gross: string;
+    readonly net: string;
+    readonly tax: string;
+}
+
+export declare const tradeTenantsTable: Table<"_voltro_eco_trade_tenants", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly tradesCount: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+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[];
+}
+
+declare const verifiedCurrentState: unique symbol;
+
+/** Fresh provider observation bound to revalidated original SQL. Never copied player refund authority. */
+export declare interface VerifiedIapCurrentState {
+    readonly [verifiedCurrentState]: true;
+    readonly orderId: string;
+}
+
+/** Authenticated notice, never current purchase state or grant/refund authority. */
+export declare interface VerifiedIapNotification {
+    readonly [verifiedNotification]: true;
+    readonly noticeId: string;
+    readonly channel: IapRefundChannel;
+}
+
+/** Process-local opaque evidence. A serialized object is never a verification capability. */
+export 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;
+
+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;
+}
+
+declare interface VirtualPriceOption {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+export declare interface WalletEscrowFundedSettlementReceipt {
+    readonly reserve: EconomyReceipt;
+    readonly settlement: WalletEscrowSettlementReceipt;
+}
+
+export declare interface WalletEscrowInput {
+    readonly tenantId: string;
+    readonly owner: EscrowWallet;
+    readonly reservationId: string;
+    readonly currency: string;
+}
+
+export 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;
+};
+
+export 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>;
+}
+
+export declare interface WalletEscrowReserveInput extends WalletEscrowInput {
+    readonly amount: EconomyAmountInput;
+}
+
+export declare interface WalletEscrowReserveTaxSettleInput extends WalletEscrowReserveInput {
+    readonly to: EscrowWallet;
+    readonly taxAmount: EconomyAmountInput;
+    readonly taxAccountId?: string | undefined;
+}
+
+export declare interface WalletEscrowSettleInput extends WalletEscrowInput {
+    readonly to: EscrowWallet;
+}
+
+export 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;
+}
+
+export declare interface WalletEscrowTaxSettleInput extends WalletEscrowSettleInput {
+    readonly taxAmount: EconomyAmountInput;
+    readonly taxAccountId?: string | undefined;
+}
+
+declare type WalletOwnerKind = 'player' | 'guild';
+
+export { }