@aegis-engine/core 0.6.0 → 0.8.0

package/dist/engine/account/activity.d.ts

@@ -0,0 +1,42 @@
+import type { AegisEngineAccountActivityEvent, AegisEnginePortfolioPosition, AegisEnginePortfolioPrice } from './types.js';
+export type AegisEngineActivityMovement = {
+    positionId: string;
+    poolId: string;
+    /** Vault balance changes are not wallet receipts. Lending uses Engine settlement signs. */
+    scope: 'vault-idle' | 'lending-settlement';
+    amount0Raw: string;
+    amount1Raw: string;
+};
+export type AegisEngineAccountActivityTransaction = {
+    id: string;
+    chainId: number;
+    txHash: string;
+    timestamp: number;
+    blockNumber: number;
+    transactionIndex: number;
+    status: 'indexed';
+    kinds: AegisEngineAccountActivityEvent['action']['kind'][];
+    events: AegisEngineAccountActivityEvent[];
+    movements: AegisEngineActivityMovement[];
+    /** Raw Engine principal, deliberately not labeled as a single-token loan amount. */
+    principalChanges: {
+        positionId: string;
+        deltaRlRaw: string;
+    }[];
+};
+/** Deduplicates event identities before transaction grouping. A transaction
+ * split across page boundaries accumulates its events instead of losing one. */
+export declare function groupEngineAccountActivity(events: readonly AegisEngineAccountActivityEvent[]): AegisEngineAccountActivityTransaction[];
+/** Exact human units; metadata absence is explicit and never assumes 18 decimals. */
+export declare function formatEngineAccountTokenAmount(raw: string, decimals: number | null, maximumFractionDigits?: number): {
+    text: string;
+    exact: string;
+    available: boolean;
+};
+export declare function enginePortfolioPriceFor(prices: readonly AegisEnginePortfolioPrice[], chainId: number, address: string | null): AegisEnginePortfolioPrice | null;
+/** Classification uses protocol position kind; it does not infer Long/Short
+ * intent from collateral ratios or fabricate historical performance. */
+export declare function groupEnginePortfolioPositions(positions: readonly AegisEnginePortfolioPosition[]): {
+    borrowing: AegisEnginePortfolioPosition[];
+    lending: AegisEnginePortfolioPosition[];
+};

package/dist/engine/account/activitySchemas.d.ts

@@ -0,0 +1,327 @@
+import { z } from 'zod';
+export declare const ActivityCollectionSchema: z.ZodEnum<{
+    vaultCreatedActions: "vaultCreatedActions";
+    vaultBurnedActions: "vaultBurnedActions";
+    vaultLockedActions: "vaultLockedActions";
+    debtModifiedActions: "debtModifiedActions";
+    idleModifiedActions: "idleModifiedActions";
+    vaultMicroLiquidatedActions: "vaultMicroLiquidatedActions";
+    liquidityModifiedActions: "liquidityModifiedActions";
+    marketShareTransfers: "marketShareTransfers";
+}>;
+export declare const ActivityActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"vault_created">;
+    owner: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"vault_burned">;
+    caller: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"vault_locked">;
+    ltvPips: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"debt_modified">;
+    principalDeltaRequestedRaw: z.ZodString;
+    principalDeltaActualRaw: z.ZodString;
+    borrowIndexWad: z.ZodString;
+    deltaIdle0Raw: z.ZodString;
+    deltaIdle1Raw: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"idle_modified">;
+    deltaAmount0Raw: z.ZodString;
+    deltaAmount1Raw: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"vault_micro_liquidated">;
+    caller: z.ZodString;
+    zeroForOne: z.ZodBoolean;
+    swapDelta0Raw: z.ZodString;
+    swapDelta1Raw: z.ZodString;
+    debtRepaidRlRaw: z.ZodString;
+    idleDelta0Raw: z.ZodString;
+    idleDelta1Raw: z.ZodString;
+    keeperFee0Raw: z.ZodString;
+    keeperFee1Raw: z.ZodString;
+    initialLtvPips: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        deposit: "deposit";
+        withdraw: "withdraw";
+    }>;
+    deltaSharesRaw: z.ZodString;
+    deltaAmount0Raw: z.ZodString;
+    deltaAmount1Raw: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        transfer_in: "transfer_in";
+        transfer_out: "transfer_out";
+        transfer_self: "transfer_self";
+    }>;
+    sharesRaw: z.ZodString;
+    counterparty: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const ActivityEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    chainId: z.ZodNumber;
+    engine: z.ZodString;
+    sourceId: z.ZodString;
+    sourceCollection: z.ZodEnum<{
+        vaultCreatedActions: "vaultCreatedActions";
+        vaultBurnedActions: "vaultBurnedActions";
+        vaultLockedActions: "vaultLockedActions";
+        debtModifiedActions: "debtModifiedActions";
+        idleModifiedActions: "idleModifiedActions";
+        vaultMicroLiquidatedActions: "vaultMicroLiquidatedActions";
+        liquidityModifiedActions: "liquidityModifiedActions";
+        marketShareTransfers: "marketShareTransfers";
+    }>;
+    txHash: z.ZodString;
+    blockNumber: z.ZodNumber;
+    transactionIndex: z.ZodNumber;
+    logIndex: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    positionId: z.ZodString;
+    vaultId: z.ZodNullable<z.ZodString>;
+    poolId: z.ZodString;
+    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"vault_created">;
+        owner: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"vault_burned">;
+        caller: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"vault_locked">;
+        ltvPips: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"debt_modified">;
+        principalDeltaRequestedRaw: z.ZodString;
+        principalDeltaActualRaw: z.ZodString;
+        borrowIndexWad: z.ZodString;
+        deltaIdle0Raw: z.ZodString;
+        deltaIdle1Raw: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"idle_modified">;
+        deltaAmount0Raw: z.ZodString;
+        deltaAmount1Raw: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"vault_micro_liquidated">;
+        caller: z.ZodString;
+        zeroForOne: z.ZodBoolean;
+        swapDelta0Raw: z.ZodString;
+        swapDelta1Raw: z.ZodString;
+        debtRepaidRlRaw: z.ZodString;
+        idleDelta0Raw: z.ZodString;
+        idleDelta1Raw: z.ZodString;
+        keeperFee0Raw: z.ZodString;
+        keeperFee1Raw: z.ZodString;
+        initialLtvPips: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            deposit: "deposit";
+            withdraw: "withdraw";
+        }>;
+        deltaSharesRaw: z.ZodString;
+        deltaAmount0Raw: z.ZodString;
+        deltaAmount1Raw: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            transfer_in: "transfer_in";
+            transfer_out: "transfer_out";
+            transfer_self: "transfer_self";
+        }>;
+        sharesRaw: z.ZodString;
+        counterparty: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type ActivityEvent = z.infer<typeof ActivityEventSchema>;
+export declare const ActivityPageQuerySchema: z.ZodObject<{
+    account: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    chainIds: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number[], string>>, z.ZodTransform<number[], number[]>>;
+    limit: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ActivityPageQuery = z.infer<typeof ActivityPageQuerySchema>;
+export declare const ActivityChainCursorSchema: z.ZodObject<{
+    chainId: z.ZodNumber;
+    engine: z.ZodString;
+    vaultRegistry: z.ZodString;
+    version: z.ZodString;
+    frame: z.ZodNullable<z.ZodObject<{
+        blockNumber: z.ZodNumber;
+        blockHash: z.ZodString;
+        blockTimestamp: z.ZodNumber;
+        deployment: z.ZodString;
+    }, z.core.$strict>>;
+    beforeBlock: z.ZodNumber;
+    eventBlock: z.ZodNullable<z.ZodNumber>;
+    beforeLog: z.ZodNullable<z.ZodNumber>;
+    eventTimestamp: z.ZodNullable<z.ZodNumber>;
+    done: z.ZodBoolean;
+    unavailable: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const ActivityCursorSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    account: z.ZodString;
+    chainIds: z.ZodArray<z.ZodNumber>;
+    limit: z.ZodNumber;
+    expiresAt: z.ZodString;
+    chains: z.ZodArray<z.ZodObject<{
+        chainId: z.ZodNumber;
+        engine: z.ZodString;
+        vaultRegistry: z.ZodString;
+        version: z.ZodString;
+        frame: z.ZodNullable<z.ZodObject<{
+            blockNumber: z.ZodNumber;
+            blockHash: z.ZodString;
+            blockTimestamp: z.ZodNumber;
+            deployment: z.ZodString;
+        }, z.core.$strict>>;
+        beforeBlock: z.ZodNumber;
+        eventBlock: z.ZodNullable<z.ZodNumber>;
+        beforeLog: z.ZodNullable<z.ZodNumber>;
+        eventTimestamp: z.ZodNullable<z.ZodNumber>;
+        done: z.ZodBoolean;
+        unavailable: z.ZodBoolean;
+    }, z.core.$strict>>;
+    rejectedRows: z.ZodNumber;
+}, z.core.$strict>;
+export type ActivityCursor = z.infer<typeof ActivityCursorSchema>;
+export type ActivityChainCursor = z.infer<typeof ActivityChainCursorSchema>;
+export declare const ActivityPageResponseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"2">;
+    account: z.ZodString;
+    chainIds: z.ZodArray<z.ZodNumber>;
+    scope: z.ZodLiteral<"currently-owned-vaults-and-account-lending">;
+    ordering: z.ZodLiteral<"chain-execution-order-merged-by-timestamp">;
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        chainId: z.ZodNumber;
+        engine: z.ZodString;
+        sourceId: z.ZodString;
+        sourceCollection: z.ZodEnum<{
+            vaultCreatedActions: "vaultCreatedActions";
+            vaultBurnedActions: "vaultBurnedActions";
+            vaultLockedActions: "vaultLockedActions";
+            debtModifiedActions: "debtModifiedActions";
+            idleModifiedActions: "idleModifiedActions";
+            vaultMicroLiquidatedActions: "vaultMicroLiquidatedActions";
+            liquidityModifiedActions: "liquidityModifiedActions";
+            marketShareTransfers: "marketShareTransfers";
+        }>;
+        txHash: z.ZodString;
+        blockNumber: z.ZodNumber;
+        transactionIndex: z.ZodNumber;
+        logIndex: z.ZodNumber;
+        timestamp: z.ZodNumber;
+        positionId: z.ZodString;
+        vaultId: z.ZodNullable<z.ZodString>;
+        poolId: z.ZodString;
+        action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"vault_created">;
+            owner: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"vault_burned">;
+            caller: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"vault_locked">;
+            ltvPips: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"debt_modified">;
+            principalDeltaRequestedRaw: z.ZodString;
+            principalDeltaActualRaw: z.ZodString;
+            borrowIndexWad: z.ZodString;
+            deltaIdle0Raw: z.ZodString;
+            deltaIdle1Raw: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"idle_modified">;
+            deltaAmount0Raw: z.ZodString;
+            deltaAmount1Raw: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"vault_micro_liquidated">;
+            caller: z.ZodString;
+            zeroForOne: z.ZodBoolean;
+            swapDelta0Raw: z.ZodString;
+            swapDelta1Raw: z.ZodString;
+            debtRepaidRlRaw: z.ZodString;
+            idleDelta0Raw: z.ZodString;
+            idleDelta1Raw: z.ZodString;
+            keeperFee0Raw: z.ZodString;
+            keeperFee1Raw: z.ZodString;
+            initialLtvPips: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                deposit: "deposit";
+                withdraw: "withdraw";
+            }>;
+            deltaSharesRaw: z.ZodString;
+            deltaAmount0Raw: z.ZodString;
+            deltaAmount1Raw: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                transfer_in: "transfer_in";
+                transfer_out: "transfer_out";
+                transfer_self: "transfer_self";
+            }>;
+            sharesRaw: z.ZodString;
+            counterparty: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodString;
+    coverage: z.ZodObject<{
+        status: z.ZodEnum<{
+            partial: "partial";
+            complete: "complete";
+        }>;
+        categories: z.ZodArray<z.ZodEnum<{
+            vaultCreatedActions: "vaultCreatedActions";
+            vaultBurnedActions: "vaultBurnedActions";
+            vaultLockedActions: "vaultLockedActions";
+            debtModifiedActions: "debtModifiedActions";
+            idleModifiedActions: "idleModifiedActions";
+            vaultMicroLiquidatedActions: "vaultMicroLiquidatedActions";
+            liquidityModifiedActions: "liquidityModifiedActions";
+            marketShareTransfers: "marketShareTransfers";
+        }>>;
+        returnedEvents: z.ZodNumber;
+        candidateRowsRead: z.ZodNumber;
+        evaluatedRows: z.ZodNumber;
+        rejectedRows: z.ZodNumber;
+        rejectedRowsSinceStart: z.ZodNumber;
+        exhausted: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    chains: z.ZodArray<z.ZodObject<{
+        chainId: z.ZodNumber;
+        engine: z.ZodString;
+        vaultRegistry: z.ZodString;
+        frame: z.ZodNullable<z.ZodObject<{
+            blockNumber: z.ZodNumber;
+            blockHash: z.ZodString;
+            blockTimestamp: z.ZodNumber;
+            deployment: z.ZodString;
+        }, z.core.$strict>>;
+        status: z.ZodEnum<{
+            unavailable: "unavailable";
+            available: "available";
+        }>;
+        exhausted: z.ZodBoolean;
+        range: z.ZodNullable<z.ZodObject<{
+            start: z.ZodObject<{
+                done: z.ZodBoolean;
+                beforeBlock: z.ZodNumber;
+                eventBlock: z.ZodNullable<z.ZodNumber>;
+                beforeLog: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>;
+            end: z.ZodObject<{
+                done: z.ZodBoolean;
+                beforeBlock: z.ZodNumber;
+                eventBlock: z.ZodNullable<z.ZodNumber>;
+                beforeLog: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        canonicality: z.ZodLiteral<"indexer-only-not-rpc-verified">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const ActivityPageErrorSchema: z.ZodObject<{
+    error: z.ZodLiteral<"Engine activity unavailable">;
+    code: z.ZodString;
+}, z.core.$strict>;

package/dist/engine/account/amountSchemas.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const EngineRawAmountSchema: z.ZodString;
+export declare const EngineIndexedFrameSchema: z.ZodObject<{
+    blockNumber: z.ZodNumber;
+    blockHash: z.ZodString;
+    blockTimestamp: z.ZodNumber;
+    deployment: z.ZodString;
+}, z.core.$strict>;
+export type EngineIndexedFrame = z.infer<typeof EngineIndexedFrameSchema>;

package/dist/engine/account/catalogSchemas.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+export declare const EngineHistoryCatalogDeploymentSchema: z.ZodObject<{
+    version: z.ZodEnum<{
+        "v1.0.2": "v1.0.2";
+        "v1.0.3": "v1.0.3";
+        "v0.4.0": "v0.4.0";
+    }>;
+    engine: z.ZodString;
+    vaultRegistry: z.ZodString;
+}, z.core.$strict>;
+export declare const EngineHistoryCatalogPositionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"lend_shares">;
+    id: z.ZodString;
+    poolId: z.ZodString;
+    status: z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+    }>;
+    indexedBalanceRaw: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"borrow_vault">;
+    id: z.ZodString;
+    poolId: z.ZodString;
+    vaultId: z.ZodString;
+    status: z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+    }>;
+    indexedOwner: z.ZodString;
+    createdAt: z.ZodString;
+    burnedAt: z.ZodNullable<z.ZodString>;
+    burnedAtBlockNumber: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>], "kind">;
+export type EngineHistoryCatalogPosition = z.infer<typeof EngineHistoryCatalogPositionSchema>;
+export declare const EngineHistoryCatalogResponseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    chainId: z.ZodNumber;
+    account: z.ZodString;
+    deployment: z.ZodObject<{
+        version: z.ZodEnum<{
+            "v1.0.2": "v1.0.2";
+            "v1.0.3": "v1.0.3";
+            "v0.4.0": "v0.4.0";
+        }>;
+        engine: z.ZodString;
+        vaultRegistry: z.ZodString;
+    }, z.core.$strict>;
+    scope: z.ZodEnum<{
+        "account-lending-and-current-or-last-owned-vaults": "account-lending-and-current-or-last-owned-vaults";
+        "account-lending-and-ever-owned-vaults": "account-lending-and-ever-owned-vaults";
+    }>;
+    ownershipEpochs: z.ZodLiteral<"unavailable">;
+    ordering: z.ZodLiteral<"vaults-then-lending-by-source-id">;
+    positions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"lend_shares">;
+        id: z.ZodString;
+        poolId: z.ZodString;
+        status: z.ZodEnum<{
+            open: "open";
+            closed: "closed";
+        }>;
+        indexedBalanceRaw: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"borrow_vault">;
+        id: z.ZodString;
+        poolId: z.ZodString;
+        vaultId: z.ZodString;
+        status: z.ZodEnum<{
+            open: "open";
+            closed: "closed";
+        }>;
+        indexedOwner: z.ZodString;
+        createdAt: z.ZodString;
+        burnedAt: z.ZodNullable<z.ZodString>;
+        burnedAtBlockNumber: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>], "kind">>;
+    pagination: z.ZodObject<{
+        limit: z.ZodNumber;
+        nextCursor: z.ZodNullable<z.ZodString>;
+        expiresAt: z.ZodString;
+    }, z.core.$strict>;
+    coverage: z.ZodObject<{
+        status: z.ZodEnum<{
+            partial: "partial";
+            complete: "complete";
+        }>;
+        exhausted: z.ZodBoolean;
+        evaluatedRowCount: z.ZodNumber;
+        returnedPositionCount: z.ZodNumber;
+        reasons: z.ZodArray<z.ZodLiteral<"more-positions">>;
+    }, z.core.$strict>;
+    freshness: z.ZodObject<{
+        source: z.ZodLiteral<"engine-subgraph">;
+        frame: z.ZodObject<{
+            blockNumber: z.ZodNumber;
+            blockHash: z.ZodString;
+            blockTimestamp: z.ZodNumber;
+            deployment: z.ZodString;
+        }, z.core.$strict>;
+        fetchedAt: z.ZodString;
+        canonicality: z.ZodLiteral<"indexer-only-not-rpc-verified">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type EngineHistoryCatalogResponse = z.infer<typeof EngineHistoryCatalogResponseSchema>;
+export declare const EngineHistoryCatalogErrorSchema: z.ZodObject<{
+    error: z.ZodLiteral<"Engine history position catalog unavailable">;
+    code: z.ZodString;
+}, z.core.$strict>;

package/dist/engine/account/client.d.ts

@@ -0,0 +1,14 @@
+export { AegisEngineAccountReadError } from './transport.js';
+import { type AegisEngineAccountActivityPage, type AegisEngineAccountPortfolio, type AegisEngineAccountReadInput, type AegisEngineTransactionStatus, type AegisEngineTransactionStatusInput } from './types.js';
+/** Loads one complete, bounded snapshot. Failed/expired pagination discards
+ * the whole result, so positions and totals never come from different reads. */
+export declare function fetchEngineAccountPortfolio(input: AegisEngineAccountReadInput): Promise<AegisEngineAccountPortfolio>;
+/** One bounded activity page. A continuation always belongs to the same
+ * account/chain set and limit. Indexer observations are not receipt finality. */
+export declare function fetchEngineAccountActivity(input: AegisEngineAccountReadInput & {
+    cursor?: string;
+    limit?: number;
+}): Promise<AegisEngineAccountActivityPage>;
+/** Read-only acknowledgement. Even `ready` is checked-at-read, not finalized;
+ * no returned status authorizes submitting a transaction again. */
+export declare function fetchEngineTransactionStatus(input: AegisEngineTransactionStatusInput): Promise<AegisEngineTransactionStatus>;

package/dist/engine/account/history.d.ts

@@ -0,0 +1,40 @@
+import type { Address, Hex } from 'viem';
+import type { AegisEngineRestSource } from '../types.js';
+import { type EnginePositionHistoryResponse } from './historySchemas.js';
+import { type EngineHistoryCatalogResponse } from './catalogSchemas.js';
+export { EngineHistoryCatalogResponseSchema as engineHistoryCatalogResponseSchema } from './catalogSchemas.js';
+export { PositionHistoryResponseSchema as enginePositionHistoryResponseSchema } from './historySchemas.js';
+export type AegisEnginePositionHistory = EnginePositionHistoryResponse;
+export type AegisEnginePositionHistoryInput = {
+    source: AegisEngineRestSource;
+    account: Address;
+    chainId: number;
+    poolId: Hex;
+    window?: '1d' | '7d' | '30d' | 'since-open';
+    /** Exclusive older-page boundary returned as coverage.nextBefore. */
+    before?: string;
+    signal?: AbortSignal;
+} & ({
+    kind: 'lend_shares';
+    vaultId?: never;
+} | {
+    kind: 'borrow_vault';
+    vaultId: string;
+});
+/** One bounded page of actual observations. The consumer retains coverage,
+ * missing values and native units; it does not interpolate or sum page PnL. */
+export declare function fetchEnginePositionHistory(input: AegisEnginePositionHistoryInput): Promise<AegisEnginePositionHistory>;
+export type AegisEngineHistoryPositions = EngineHistoryCatalogResponse;
+export type AegisEngineHistoryPositionsInput = {
+    source: AegisEngineRestSource;
+    account: Address;
+    chainId: number;
+    limit?: number;
+    cursor?: string;
+    /** Requires a deployed ownership index; never silently falls back to current owners. */
+    ownerScope?: 'current-or-last' | 'ever-owned';
+    signal?: AbortSignal;
+};
+/** Includes zero-share lending records and burned vaults at one indexed frame.
+ * A catalog entry does not guarantee observed chart points or personal PnL. */
+export declare function fetchEngineHistoryPositions(input: AegisEngineHistoryPositionsInput): Promise<AegisEngineHistoryPositions>;