project-cpu-mcp 0.9.1 → 0.11.1

package/dist/services/types.d.ts

@@ -1,10 +1,11 @@
 import type { Address, Hash, Log } from 'viem';
 import type { ApiClient } from '../api/client.js';
-import type { BuildingType, BuildingView, CraftRecipeId, CraftStackView, IRevealRequestsReader, LotAvailability, LotSort, OpenRevealRequestView, RandomnessDescriptor, RecipeView, RevealPaymentView, StorageConfigView, SyndicateSort, TransportRoutingView } from '../api/types.js';
+import type { BuildingType, BuildingView, CraftRecipeId, CraftStackView, IRevealRequestsReader, LotAvailability, LotSort, LotState, OpenRevealRequestView, RandomnessDescriptor, RecipeView, RevealPaymentView, StorageConfigView, SyndicateSort, TransportRoutingView } from '../api/types.js';
 import type { Network } from '../config/types.js';
+import type { OnChainLotState } from '../contracts/trade.types.js';
 import type { CellCoord } from '../geometry/types.js';
 import type { ILogger } from '../logger/types.js';
-import type { Cell, RevealCellReader } from '../map/types.js';
+import type { RevealCellReader, RoutingSnapshot } from '../map/types.js';
 import type { IFulfilmentClaims, IRandomnessStrategyFactory, ISelfServiceRandomnessResolver, PushRandomness, SelfServiceRandomness } from '../randomness/types.js';
 import type { SessionManager } from '../session/manager.js';
 import type { ConfirmedTx, IContractClient, TxStatus, WalletManager, WalletProvider } from '../wallet/types.js';
@@ -14,10 +15,6 @@ export interface AuthServiceOptions {
     wallet: WalletProvider;
     logger: ILogger;
 }
-export interface DeviceAuthResult {
-    verificationUrl: string;
-    userCode: string;
-}
 /** Resolved contract addresses for the configured network. */
 export interface AppContracts {
     land: string;
@@ -45,9 +42,17 @@ export type ModeSwitchView = {
 } | {
     kind: ModeSwitchKind.Unknown;
 };
-export interface CatalogBuildingView extends BuildingView {
-    modeSwitch: ModeSwitchView;
-}
+type CatalogBuildingBaseView = Omit<BuildingView, 'modeSwitchCost'>;
+export type CatalogBuildingView = (CatalogBuildingBaseView & {
+    modeSwitch: Exclude<ModeSwitchView, {
+        kind: ModeSwitchKind.Unknown;
+    }>;
+    modeSwitchCost: string | null;
+}) | (CatalogBuildingBaseView & {
+    modeSwitch: Extract<ModeSwitchView, {
+        kind: ModeSwitchKind.Unknown;
+    }>;
+});
 export type ModeKey = string | number | bigint;
 export declare enum ModeCostKind {
     Free = "free",
@@ -88,10 +93,7 @@ export interface AppConfig {
     recipes: Array<RecipeView>;
     /** Per-building catalog — on-chain id, kind, costs, and mine/craft bindings. */
     buildings: Array<CatalogBuildingView>;
-    /**
-     * The two gameplay legs every reveal is charged; `null` when the game API serves no reveal payment at
-     * all. Never the total to send — a reveal is always funded from `ICellClient.quoteReveal`.
-     */
+    /** The reveal budget and $CPU burn; `null` when the game API serves no usable reveal payment. */
     reveal: RevealPaymentView | null;
     transport: TransportRoutingView;
     /** Trade fee params, normalized to the MCP's percent surface. */
@@ -129,16 +131,15 @@ export interface RequestRevealParams {
     value: bigint;
 }
 /**
- * What one reveal costs right now, read from the Cell itself and the only source a reveal is funded from:
- * `totalRequiredWei` is the whole ETH the reveal is charged and `cpuBurnWei` the exact burn to approve. The
- * transaction carries headroom over the total (see `bufferedRevealValue`); the burn is approved as quoted.
- * Any leg may be zero.
+ * What one reveal costs right now, read from the Cell itself. The three ETH legs sum to `ethBudgetWei`; the
+ * transaction carries refundable headroom over that budget and approves the $CPU burn exactly as quoted.
  */
 export interface RevealQuote {
-    ethContributionWei: bigint;
+    poolContributionWei: bigint;
     randomnessFeeWei: bigint;
-    totalRequiredWei: bigint;
+    ethBudgetWei: bigint;
     cpuBurnWei: bigint;
+    metadataPublicationChargeWei: bigint;
 }
 export interface PlaceParams {
     cell: Address;
@@ -174,6 +175,7 @@ export interface CellViewResult {
     buildingType: number;
     modeResource: number;
     modeRecipeId: bigint;
+    processDrawPerCycle: bigint;
 }
 export interface ICellClient {
     readCellView(cell: Address, tokenId: bigint): Promise<CellViewResult>;
@@ -199,9 +201,12 @@ export interface RevealServiceOptions {
 }
 export declare enum CellRevertName {
     INSUFFICIENT_REVEAL_PAYMENT = "InsufficientRevealPayment",
+    REVEAL_SERVICE_FEES_EXCEED_BUDGET = "RevealServiceFeesExceedBudget",
     REVEAL_PAYMENT_NOT_CONFIGURED = "RevealPaymentNotConfigured",
     REVEAL_HOOK_NOT_CONFIGURED = "RevealHookNotConfigured",
     HOOK_DELIVERY_FAILED = "HookDeliveryFailed",
+    METADATA_PUBLISHER_NOT_CONFIGURED = "MetadataPublisherNotConfigured",
+    PUBLISHER_DELIVERY_FAILED = "PublisherDeliveryFailed",
     REFUND_FAILED = "RefundFailed",
     REVEAL_NOT_CONFIGURED = "RevealNotConfigured",
     REVEAL_CELL_OCCUPIED = "RevealCellOccupied",
@@ -211,6 +216,9 @@ export declare enum CellRevertName {
     DEPOSITS_NOT_EXHAUSTED = "DepositsNotExhausted",
     REVEAL_REQUEST_ID_IN_USE = "RevealRequestIdInUse"
 }
+export declare enum TransportRevertName {
+    STORAGE_FULL = "StorageFull"
+}
 export declare enum UpgradeRevertName {
     NOT_REVEALED = "NotRevealed",
     PROCESS_ACTIVE = "ProcessActive",
@@ -251,7 +259,7 @@ export interface RevealRequestContext {
     source: Address;
     requestTxHash: Hash | null;
     approveTxHash: Hash | null;
-    /** The whole ETH the reveal cost, as the Cell quoted it; the transaction carries headroom above it. */
+    /** The ETH budget the Cell quoted; the transaction carries refundable headroom above it. */
     paidWei: bigint;
     cpuBurnWei: bigint;
     status: TxStatus | null;
@@ -291,10 +299,9 @@ export interface RevealResult {
     status: TxStatus | null;
     blockNumber: string | null;
     /**
-     * The whole ETH this reveal cost (decimal), as the cell quoted it — the liquidity contribution and the
-     * randomness fee together, not the fee alone; "0" when the call sent no request of its own. The
-     * transaction carries headroom above it and the excess comes back in the same transaction, so this is
-     * what the wallet is left down by.
+     * The whole ETH budget this reveal was quoted (decimal): pool contribution, randomness fee, and metadata
+     * publication charge together; "0" when the call sent no request of its own. The transaction carries
+     * refundable headroom above it.
      */
     ethPaid: string;
     /** $CPU burned by this reveal (decimal); "0" when the call sent no request of its own. */
@@ -593,13 +600,14 @@ export interface FinalizeResult {
     blockNumber: string;
 }
 export interface RouteCellReader {
-    allCells(): Promise<Array<Cell>>;
+    routingSnapshot(): Promise<RoutingSnapshot>;
 }
 export interface RouteServiceOptions {
     wallet: WalletProvider;
     appConfig: IAppConfig;
     mapReader: RouteCellReader;
     logger: ILogger;
+    artifactDirectory: string | null;
 }
 export interface NextHopsInput {
     from: number;
@@ -612,57 +620,92 @@ export interface NextHopView {
     hopDistance: number;
     isOwn: boolean;
     isHub: boolean;
+    /** Open ground: no completed reveal, so nobody controls it and anyone's cargo may pass through. */
+    isVirgin: boolean;
     ready: boolean | null;
-    owner: string;
+    /** null on ground nobody has minted yet. */
+    owner: string | null;
+    /** Reach this waypoint contributes in grid steps: its Ready hub's own radius, or the move radius. */
+    radius: number;
     transitFeePerUnit: string | null;
     distanceToTarget: number | null;
 }
 export interface NextHopsResult {
     from: string;
     fromIsHub: boolean;
+    fromIsVirgin: boolean;
     fromReady: boolean | null;
+    /** Reach the origin contributes in grid steps — a hop is legal up to `fromRadius + radius - 1`. */
+    fromRadius: number;
     towards: string | null;
     targetDistance: number | null;
-    reach: {
-        moveRadius: number;
-        hubRadius: number;
-    };
     hops: Array<NextHopView>;
     note: string;
 }
 export interface RouteNetworkInput {
-    from: number | null;
-    towards: number | null;
+    from: number;
+    towards: number;
     resourceId: number;
+    amount: string;
 }
-export interface NetworkNodeView {
+/** The one move the graph was cut for, normalized — the artifact carries it whole. */
+export interface RouteRequestView {
+    from: string;
+    towards: string;
+    resourceId: number;
+    amount: string;
+}
+/**
+ * Membership is the eligibility statement: a node in the artifact is an Intermediate waypoint the contract
+ * accepts, so no separate eligibility flag is carried.
+ */
+export interface RouteGraphNodeView {
     tokenId: string;
-    pos: CellCoord;
+    /** null on ground nobody has minted yet. */
+    owner: string | null;
+    /** Open ground: no completed reveal, so nobody controls it and any payer may route through it. */
+    isVirgin: boolean;
     isOwn: boolean;
+    /** An Active Hub: a Hub-kind building whose construction has finished, not merely one placed. */
     isHub: boolean;
-    ready: boolean | null;
-    owner: string;
+    /** Reach this node contributes in grid steps — a hop is legal up to radius(a)+radius(b)−1. */
+    radius: number;
+    /** Nominal per-unit transit fee for the requested resource; null where passage costs nothing. */
     transitFeePerUnit: string | null;
-    distFromSource: number | null;
-    distToTarget: number | null;
-    component: number;
 }
-export interface NetworkEdgeView {
+export interface RouteGraphEdgeView {
     a: string;
     b: string;
     distance: number;
 }
+export interface RouteGraphArtifact {
+    schemaVersion: number;
+    snapshotVersion: number;
+    request: RouteRequestView;
+    connected: boolean;
+    nodes: Array<RouteGraphNodeView>;
+    edges: Array<RouteGraphEdgeView>;
+}
+/** `path` stays empty: the chain is the agent's to compute from the graph, and no endpoint pair is a route. */
+export interface QuoteTransportArgumentsView {
+    path: Array<string>;
+    resourceId: number;
+    amount: string;
+}
+export interface QuoteTransportCallView {
+    tool: string;
+    arguments: QuoteTransportArgumentsView;
+}
 export interface RouteNetworkResult {
-    from: string | null;
-    towards: string | null;
-    fromToTarget: number | null;
-    reach: {
-        moveRadius: number;
-        hubRadius: number;
-    };
-    components: number;
-    nodes: Array<NetworkNodeView>;
-    edges: Array<NetworkEdgeView>;
+    artifactPath: string;
+    schemaVersion: number;
+    snapshotVersion: number;
+    request: RouteRequestView;
+    connected: boolean;
+    nodeCount: number;
+    edgeCount: number;
+    instructions: ReadonlyArray<string>;
+    quoteTemplate: QuoteTransportCallView;
     note: string;
 }
 export interface CraftServiceOptions {
@@ -853,15 +896,101 @@ export interface CancelLotParams {
     returnTokenIds: Array<bigint>;
     maxFee: bigint;
 }
-/** Sends the Trade writes — implemented by TradeClient. Lot state comes from the game API. */
+export interface ReclaimLotParams {
+    trade: Address;
+    lotId: bigint;
+    returnTokenIds: Array<bigint>;
+    maxFee: bigint;
+}
+export interface EvictLotParams {
+    trade: Address;
+    lotId: bigint;
+}
+export interface GetLotParams {
+    trade: Address;
+    lotId: bigint;
+}
+export interface GetLotsParams {
+    trade: Address;
+    lotIds: Array<bigint>;
+}
+export interface GetTradeConfigParams {
+    trade: Address;
+}
+export interface LotBoundParams {
+    trade: Address;
+    hub: bigint;
+    res: number;
+}
+export interface SellerLotCountParams {
+    trade: Address;
+    seller: Address;
+    hub: bigint;
+    res: number;
+}
+export interface SellerEvictedCountParams {
+    trade: Address;
+    seller: Address;
+    hub: bigint;
+}
+export interface QuoteReturnParams {
+    trade: Address;
+    lotId: bigint;
+    returnTokenIds: Array<bigint>;
+    seller: Address;
+}
+/**
+ * The lot exactly as the Trade contract stores it. `hubRadius` and `hubMoveFee` are the hub's routing
+ * terms captured at listing — they bound what the seller can be charged to bring the remainder home, and
+ * the game API does not project either, so return-aware routing has to read them here.
+ */
+export interface OnChainLot {
+    seller: Address;
+    hub: bigint;
+    resource: number;
+    remaining: bigint;
+    pricePerUnit: bigint;
+    state: OnChainLotState;
+    maxSaleFeeBp: number;
+    hubRadius: number;
+    hubMoveFee: bigint;
+}
+/** The deployed tunable trade parameters. Effective per-hub bounds are never derived from these. */
+export interface OnChainTradeConfig {
+    minPricePerUnit: bigint;
+    saleBurnPercent: number;
+    minLotShareBp: number;
+    maxLotShareBp: number;
+    maxLotsPerSellerResource: number;
+    minUncappedLotValue: bigint;
+    maxUncappedLotValue: bigint;
+}
+export interface ReturnQuoteResult {
+    transitFee: bigint;
+    transitDiscount: bigint;
+    totalDistance: bigint;
+    arrivalAt: bigint;
+    amount: bigint;
+}
+/** The Trade reads and writes — implemented by TradeClient. Lot discovery comes from the game API. */
 export interface ITradeClient {
     createLot(params: CreateLotParams): Promise<Hash>;
     buy(params: BuyLotParams): Promise<Hash>;
     cancel(params: CancelLotParams): Promise<Hash>;
+    reclaim(params: ReclaimLotParams): Promise<Hash>;
+    evict(params: EvictLotParams): Promise<Hash>;
     setSaleFee(params: SetSaleFeeParams): Promise<Hash>;
     getSaleFee(params: GetSaleFeeParams): Promise<number>;
+    getLot(params: GetLotParams): Promise<OnChainLot>;
+    getLots(params: GetLotsParams): Promise<Array<OnChainLot>>;
+    getConfig(params: GetTradeConfigParams): Promise<OnChainTradeConfig>;
+    getMinLotValue(params: LotBoundParams): Promise<bigint>;
+    getMaxLotValue(params: LotBoundParams): Promise<bigint>;
+    getSellerLotCount(params: SellerLotCountParams): Promise<bigint>;
+    getSellerEvictedCount(params: SellerEvictedCountParams): Promise<bigint>;
     quoteSale(params: QuoteSaleParams): Promise<SaleQuoteResult>;
     quoteBuy(params: QuoteBuyParams): Promise<BuyQuoteResult>;
+    quoteReturn(params: QuoteReturnParams): Promise<ReturnQuoteResult>;
 }
 export interface SetSaleFeeResult {
     hubTokenId: string;
@@ -959,6 +1088,150 @@ export interface TradeQuote {
     arrivalAt: number | null;
     total: string;
 }
+/**
+ * The tunable listing rules the deployed Trade contract holds, in the units an agent reads. Shares are
+ * percentages of the hub's storage shelf for the resource; the uncapped pair is the absolute window used
+ * instead when that shelf is uncapped. Neither pair yields the effective bounds for a given hub and
+ * resource — only the contract's own bound views do.
+ */
+export interface LotListingRulesView {
+    minLotSharePercent: number;
+    maxLotSharePercent: number;
+    /** Resource units. */
+    minUncappedLotValue: string;
+    maxUncappedLotValue: string;
+    maxLotsPerSellerHubResource: number;
+    /** Anti-dust floor on a lot's asking price, in $CPU per unit (decimal). */
+    minPricePerUnit: string;
+}
+/** Reads the deployed listing rules off the chain — implemented by TradeRulesService. */
+export interface ITradeRules {
+    /** Null when the chain cannot be read right now (no wallet yet, or the RPC is unreachable). */
+    loadLotListingRules(): Promise<LotListingRulesView | null>;
+}
+export interface TradeRulesServiceOptions {
+    appConfig: IAppConfig;
+    wallet: WalletProvider;
+    tradeClient: ITradeClient;
+    logger: ILogger;
+}
+export interface LotTermsInput {
+    hubTokenId: string;
+    resourceId: number;
+}
+/** Why a new listing on this hub and resource cannot go ahead right now. */
+export declare enum LotListingBlocker {
+    /** The seller has an evicted remainder on this hub with no return scheduled — checked before anything else. */
+    EvictedPending = "evicted_pending",
+    /** Every live-lot slot for this seller/hub/resource is taken. */
+    SellerLotLimit = "seller_lot_limit",
+    /** The hub cannot hold a lot of this resource at all: its window has no room between the bounds. */
+    EmptyWindow = "empty_window"
+}
+/**
+ * The live listing terms for one hub and resource, read from the Trade views rather than derived from the
+ * static shares. Amounts are resource units as decimal strings.
+ */
+export interface LotTermsResult {
+    hubTokenId: string;
+    resourceId: number;
+    sellerAddress: string;
+    /** Smallest value one new lot may hold here. */
+    effectiveMin: string;
+    /** Largest value one new lot may hold here. */
+    effectiveMax: string;
+    /** Delivering, Open and Evicted lots this seller holds for the hub and resource. */
+    sellerLotCount: number;
+    /** Configured ceiling on that count. */
+    sellerLotLimit: number;
+    /** Evicted lots this seller still owes a return on, across every resource on this hub. */
+    outstandingEvictedCount: number;
+    canList: boolean;
+    blockers: Array<LotListingBlocker>;
+}
+export interface EvictLotInput {
+    lotId: string;
+}
+/** A confirmed eviction: the lot stops selling and frees the hub, and not one unit of it moves. */
+export interface EvictLotResult {
+    lotId: string;
+    hubTokenId: string;
+    sellerAddress: string;
+    resourceId: number;
+    /** The whole remainder, still the seller's and still escrowed. */
+    remaining: string;
+    state: LotState;
+    txHash: Hash;
+    status: TxStatus;
+    blockNumber: string;
+}
+export interface LotReturnQuoteInput {
+    lotId: string;
+    /** Waypoint tokenIds, `[hub, …waypoints, sellerDest]` — the seller's explicit route home. */
+    chain: Array<number>;
+}
+export interface LotReturnInput extends LotReturnQuoteInput {
+    /**
+     * The most transit the seller will pay, in wei, carried over from the quote they were shown. Wei rather
+     * than decimal $CPU so the figure reaches the contract with no parse between the quote and the call:
+     * a ceiling one wei low refuses a return that was never too expensive.
+     */
+    maxTransitFeeWei: string;
+}
+/** Whether the whole remainder fits in the destination as it stands right now, reservations included. */
+export interface DestinationCapacityView {
+    fits: boolean;
+    required: string;
+    /** Free units at the destination; null when its storage for the resource is uncapped. */
+    free: string | null;
+}
+/** A non-destructive preview of one Lot return, priced by the contract's own return quote. */
+export interface LotReturnQuote {
+    lotId: string;
+    hubTokenId: string;
+    resourceId: number;
+    /** The whole current remainder — a Lot return never sends part of a lot. */
+    amount: string;
+    destinationTokenId: string;
+    /** What the route costs right now and so the ceiling to carry into the return, in $CPU (decimal). */
+    maxTransitFee: string;
+    /** The same ceiling in wei — the figure to hand `cpu_return_lot` unchanged, exact to the last wei. */
+    maxTransitFeeWei: string;
+    transitDiscount: string;
+    /** Grid steps the route covers end to end. */
+    totalDistance: number;
+    arrivalAt: number;
+    capacity: DestinationCapacityView;
+}
+/** Which contract branch settled a Lot return — one player intent, two lifecycle sources. */
+export declare enum LotReturnBranch {
+    /** An Open lot: the offer is withdrawn and the remainder ships home. */
+    Cancelled = "cancelled",
+    /** An Evicted lot: the remainder the hub owner threw out ships home. */
+    Reclaimed = "reclaimed"
+}
+/** A confirmed Lot return, normalized so both branches read the same. */
+export interface LotReturnResult {
+    lotId: string;
+    /** The lot's authoritative state before the return — Open or Evicted. */
+    originalState: LotState;
+    branch: LotReturnBranch;
+    hubTokenId: string;
+    resourceId: number;
+    /** Units on their way back to the seller. */
+    returned: string;
+    /** Transit fee actually debited, in $CPU (decimal). */
+    transitPaid: string;
+    transitDiscount: string;
+    destinationTokenId: string;
+    deliveryId: string;
+    arrivalAt: number;
+    /** Transport-fee approve, when the route owed a fee at all. */
+    approveTxHash: Hash | null;
+    txHash: Hash;
+    status: TxStatus;
+    blockNumber: string;
+}
 export interface SwapServiceOptions {
     wallet: WalletProvider;
     appConfig: IAppConfig;
@@ -1045,12 +1318,12 @@ export interface MintInput {
 }
 /** The active SeaDrop public-drop terms for the land collection, read on-chain. */
 export interface PublicDropView {
-    /** ETH price per cell, in wei. */
+    /** Per-cell amount in native ETH, in wei, as the drop sets it — may be zero. */
     mintPrice: bigint;
     startTime: number;
     endTime: number;
     maxTotalMintableByWallet: number;
-    /** OpenSea fee, in basis points of the (inclusive) mint price. */
+    /** OpenSea fee, in basis points of the (inclusive) per-cell amount. */
     feeBps: number;
     restrictFeeRecipients: boolean;
 }
@@ -1060,26 +1333,26 @@ export interface PreparedMint {
     land: Address;
     drop: PublicDropView;
     quantity: number;
-    /** quantity × mintPrice, in wei — the exact ETH the mint must pay. */
+    /** quantity × the live per-cell amount, in wei — the value the mint transaction sends. */
     totalWei: bigint;
 }
 export interface MintQuote {
     land: Address;
     quantity: number;
-    /** Per-cell price in native ETH (decimal). */
+    /** Live per-cell amount in native ETH (decimal), as read from the drop terms. */
     mintPrice: string;
-    /** quantity × mintPrice in native ETH (decimal). */
+    /** quantity × the live per-cell amount, in native ETH (decimal). */
     total: string;
     feeBps: number;
     startTime: number;
     endTime: number;
     maxTotalMintableByWallet: number;
 }
-/** A confirmed mint — the on-chain SeaDrop public-drop purchase of `quantity` cells, paid in ETH. */
+/** A confirmed mint — `quantity` cells issued on-chain through the SeaDrop public drop. */
 export interface MintResult {
     land: Address;
     quantity: number;
-    /** quantity × mintPrice in native ETH (decimal). */
+    /** quantity × the live per-cell amount, in native ETH (decimal). */
     total: string;
     txHash: Hash;
     status: TxStatus;
@@ -1166,7 +1439,6 @@ export interface JoinSyndicateResult {
     syndicateId: string;
     joinedAt: number;
     leaveAvailableAt: number;
-    name: string | null;
     rates: SyndicateRatesView | null;
 }
 export interface LeaveSyndicateResult {
@@ -1188,8 +1460,6 @@ export interface CreateSyndicateInput {
 export interface CreateSyndicateResult {
     syndicateId: string;
     manager: string;
-    name: string;
-    link: string;
     rates: SyndicateRatesView;
     joinedAt: number;
     leaveAvailableAt: number;
@@ -1202,8 +1472,6 @@ export interface SetSyndicateParamsInput {
 }
 export interface SetSyndicateParamsResult {
     syndicateId: string;
-    name: string;
-    link: string;
     rates: SyndicateRatesView;
 }
 export interface TransferSyndicateManagerInput {
@@ -1218,12 +1486,15 @@ export interface TransferSyndicateManagerResult {
 export interface SyndicateCardView {
     id: string;
     manager: string;
-    name: string;
-    link: string;
     rates: SyndicateRatesView;
     memberCount: number;
     createdAt: number;
 }
+export interface SyndicatePlayerContentView {
+    syndicateId: string;
+    name: string;
+    link: string;
+}
 export interface SyndicateMemberView {
     address: string;
     joinedAt: number;
@@ -1256,4 +1527,5 @@ export interface SyndicateMembershipView {
     leaveAvailableAt: number | null;
     syndicate: SyndicateCardView | null;
 }
+export {};
 //# sourceMappingURL=types.d.ts.map