@liquidium/client 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2216 @@
+import { Identity, HttpAgent } from '@dfinity/agent';
+import { PublicClient } from 'viem';
+
+/** Minimal viem-compatible client shape required for SDK EVM read calls. */
+type EvmReadClient = Pick<PublicClient, "readContract">;
+/**
+ * Runtime options for `new LiquidiumClient(config)`.
+ *
+ * Canister-backed reads and SDK HTTP features work with `{}` defaults. Set
+ * `apiBaseUrl` only when overriding the Liquidium production API root.
+ */
+interface LiquidiumClientConfig {
+    /** Preset canister IDs. Only `mainnet` is bundled. */
+    environment?: Environment;
+    /** ICP replica host override (defaults follow `@dfinity/agent`). */
+    icHost?: string;
+    /** Agent identity for signed canister calls. */
+    identity?: Identity;
+    /**
+     * Base URL for the Liquidium SDK HTTP API root (e.g. `https://app.example.com/api/sdk`).
+     * Defaults to the Liquidium production API root. Endpoint versions are owned
+     * by this SDK package version.
+     */
+    apiBaseUrl?: string;
+    /** Extra headers sent with every SDK API request. */
+    headers?: Record<string, string>;
+    /** Override individual canister principals for custom deployments. */
+    canisterIds?: Partial<CanisterIds>;
+    /** Custom `fetch` implementation for SDK API requests. */
+    fetch?: typeof fetch;
+    /** Per-request timeout for SDK API calls in milliseconds. */
+    timeoutMs?: number;
+    /** Ethereum RPC URL used for public ERC-20 reads in EVM supply flows. */
+    evmRpcUrl?: string;
+    /** Optional headers for RPC providers that authenticate via HTTP headers. */
+    evmRpcHeaders?: Record<string, string>;
+    /** Existing viem public client or compatible read client for EVM reads. */
+    evmPublicClient?: EvmReadClient;
+}
+/** Principal text values for canisters used by the client. */
+interface CanisterIds {
+    /** Liquidium lending canister principal. */
+    lending: string;
+    /** BTC pool canister principal. */
+    btcPool: string;
+    /** ERC-20 pool canister principal. */
+    ercPool: string;
+    /** ckETH minter deposit helper canister principal. */
+    ethDeposit: string;
+    /** Accountless instant-loans canister principal. */
+    instantLoans: string;
+}
+/** Supported deployment environments with bundled canister ids. */
+declare const Environment: {
+    readonly mainnet: "mainnet";
+};
+/** Supported deployment environment name. */
+type Environment = (typeof Environment)[keyof typeof Environment];
+/** Canonical asset symbols supported by state-mutating protocol flows. */
+declare const Asset: {
+    readonly BTC: "BTC";
+    readonly SOL: "SOL";
+    readonly USDC: "USDC";
+    readonly USDT: "USDT";
+};
+/** Canonical asset symbol supported by state-mutating protocol flows. */
+type Asset = (typeof Asset)[keyof typeof Asset];
+/** Canonical chain identifiers used by wallet and protocol actions. */
+declare const Chain: {
+    readonly BTC: "BTC";
+    readonly ETH: "ETH";
+};
+/** Canonical chain identifier used by wallet and protocol actions. */
+type Chain = (typeof Chain)[keyof typeof Chain];
+/** Asset symbol as returned by market-data APIs, including future assets. */
+type MarketAsset = string;
+/** Chain name as returned by market-data APIs, including future chains. */
+type MarketChain = string;
+/** Inflow operation performed by a supply target. */
+declare const SupplyAction: {
+    readonly deposit: "deposit";
+    readonly repayment: "repayment";
+};
+/** Inflow operation performed by a supply target. */
+type SupplyAction = (typeof SupplyAction)[keyof typeof SupplyAction];
+/** Outflow operation reported by the lending canister. */
+declare const OutflowType: {
+    readonly borrow: "borrow";
+    readonly feeClaim: "feeClaim";
+    readonly withdraw: "withdraw";
+};
+/** Outflow operation reported by the lending canister. */
+type OutflowType = (typeof OutflowType)[keyof typeof OutflowType];
+/** Inflow submit type expected by the SDK API. */
+declare const InflowSubmitType: {
+    readonly DEPOSIT: "DEPOSIT";
+    readonly REPAY: "REPAY";
+};
+/** Inflow submit type expected by the SDK API. */
+type InflowSubmitType = (typeof InflowSubmitType)[keyof typeof InflowSubmitType];
+/** Wallet address and chain pair linked to a Liquidium profile. */
+interface Wallet {
+    /** Chain where the wallet address is valid. */
+    chain: Chain;
+    /** Wallet address as stored by the protocol. */
+    address: string;
+}
+
+interface CanisterContext {
+    agent: HttpAgent;
+    canisterIds: CanisterIds;
+}
+
+/** Asset transfer path used for wallet-executed actions. */
+declare const TransferMode: {
+    readonly ck: "ck";
+    readonly native: "native";
+};
+/** Asset transfer path used for wallet-executed actions. */
+type TransferMode = (typeof TransferMode)[keyof typeof TransferMode];
+/** Wallet capability required to execute a prepared SDK action. */
+declare const WalletExecutionKind: {
+    readonly sendEthTransaction: "send-eth-transaction";
+    readonly signMessage: "sign-message";
+    readonly signPsbt: "sign-psbt";
+};
+/** Wallet capability required to execute a prepared SDK action. */
+type WalletExecutionKind = (typeof WalletExecutionKind)[keyof typeof WalletExecutionKind];
+/** Protocol action represented by a prepared wallet action. */
+declare const WalletActionKind: {
+    readonly createAccount: "create-account";
+    readonly createBorrow: "create-borrow";
+    readonly createWithdraw: "create-withdraw";
+};
+/** Protocol action represented by a prepared wallet action. */
+type WalletActionKind = (typeof WalletActionKind)[keyof typeof WalletActionKind];
+/** EVM transaction request passed to wallet adapters. */
+interface EthTransactionRequest {
+    /** Destination address or contract address. */
+    to: string;
+    /** Hex-encoded calldata for contract interactions. */
+    data?: string;
+    /** Native ETH value in wei, serialized as a decimal string. */
+    value?: string;
+    /** Optional EVM chain id for wallet implementations that require it. */
+    chainId?: number;
+}
+/** Message-signing request passed to wallet adapters. */
+interface SignMessageRequest {
+    /** Chain for the signing wallet. */
+    chain: Chain;
+    /** Plaintext message to sign. */
+    message: string;
+    /** Optional account override for the signing wallet. */
+    account?: string;
+    /** SDK action type that produced this request. */
+    actionType: string;
+    /** Transfer path associated with the action. */
+    transferMode: TransferMode;
+}
+/** PSBT-signing request passed to BTC wallet adapters. */
+interface SignPsbtRequest {
+    /** BTC chain discriminator. */
+    chain: Extract<Chain, "BTC">;
+    /** Base64-encoded unsigned PSBT. */
+    psbtBase64: string;
+    /** Optional BTC account override. */
+    account?: string;
+    /** SDK action type that produced this request. */
+    actionType: string;
+    /** Transfer path associated with the action. */
+    transferMode: TransferMode;
+}
+/** ETH transaction-sending request passed to wallet adapters. */
+interface SendEthTransactionRequest {
+    /** ETH chain discriminator. */
+    chain: Extract<Chain, "ETH">;
+    /** Transaction payload to send. */
+    transaction: EthTransactionRequest;
+    /** Optional account override for the sending wallet. */
+    account?: string;
+    /** SDK action type that produced this request. */
+    actionType: string;
+    /** Transfer path associated with the action. */
+    transferMode: TransferMode;
+}
+/** BTC transaction-sending request passed to wallet adapters. */
+interface SendBtcTransactionRequest {
+    /** BTC chain discriminator. */
+    chain: Extract<Chain, "BTC">;
+    /** Recipient BTC address. */
+    toAddress: string;
+    /** Amount in satoshis when the SDK knows the transfer amount. */
+    amountSats?: bigint;
+    /** Optional account override for the sending wallet. */
+    account?: string;
+    /** SDK action type that produced this request. */
+    actionType: string;
+    /** Transfer path associated with the action. */
+    transferMode: TransferMode;
+}
+/**
+ * Optional wallet capabilities. Implement only what your flow uses:
+ *
+ * - `signMessage` - account creation, borrow, withdraw
+ * - `sendBtcTransaction` / `sendEthTransaction` - automated transfer-path supply
+ * - `sendEthTransaction` - contract-interaction supply and ETH native sends
+ * - `signPsbt` - reserved for PSBT-based actions when exposed
+ */
+interface WalletAdapter {
+    /** Signs an SDK plaintext message and returns the wallet signature. */
+    signMessage?: (request: SignMessageRequest) => Promise<string>;
+    /** Signs an SDK-provided BTC PSBT and returns the signed PSBT as base64. */
+    signPsbt?: (request: SignPsbtRequest) => Promise<string>;
+    /** Sends an EVM transaction and returns its transaction hash. */
+    sendEthTransaction?: (request: SendEthTransactionRequest) => Promise<string>;
+    /** Sends a BTC transaction and returns its transaction id. */
+    sendBtcTransaction?: (request: SendBtcTransactionRequest) => Promise<string>;
+}
+/** Signature payload submitted to a sign-message action. */
+interface SignatureInfo {
+    /** Wallet signature over the action message. */
+    signature: string;
+    /** Chain used to produce the signature. */
+    chain: Chain;
+    /** Account that produced the signature, when different from the action default. */
+    account?: string;
+}
+/** Prepared action that requires message signing before submit. */
+interface SignMessageWalletAction<TData, TResult> {
+    /** Protocol action kind. */
+    kind: string;
+    /** Wallet capability required to execute the action. */
+    executionKind: typeof WalletExecutionKind.signMessage;
+    /** Adapter-facing action type. */
+    actionType: string;
+    /** Transfer path associated with the action. */
+    transferMode: TransferMode;
+    /** Default account to pass to the wallet adapter. */
+    account: string;
+    /** Plaintext message that must be signed. */
+    message: string;
+    /** Original request data needed to submit the signed action. */
+    data: TData;
+    /** Submits the signature and resolves the protocol result. */
+    submit(signatureInfo: SignatureInfo): Promise<TResult>;
+}
+/** Prepared action that requires BTC PSBT signing before submit. */
+interface SignPsbtWalletAction<TResult> {
+    /** Protocol action kind. */
+    kind: string;
+    /** Wallet capability required to execute the action. */
+    executionKind: typeof WalletExecutionKind.signPsbt;
+    /** Adapter-facing action type. */
+    actionType: string;
+    /** Transfer path associated with the action. */
+    transferMode: TransferMode;
+    /** Optional default account to pass to the wallet adapter. */
+    account?: string;
+    /** Base64-encoded unsigned PSBT. */
+    psbtBase64: string;
+    /** Submits the signed PSBT and resolves the protocol result. */
+    submit(request: {
+        signedPsbtBase64: string;
+    }): Promise<TResult>;
+}
+/** Prepared action that requires sending an ETH transaction before submit. */
+interface SendEthTransactionWalletAction<TResult> {
+    /** Protocol action kind. */
+    kind: string;
+    /** Wallet capability required to execute the action. */
+    executionKind: typeof WalletExecutionKind.sendEthTransaction;
+    /** Adapter-facing action type. */
+    actionType: string;
+    /** Transfer path associated with the action. */
+    transferMode: TransferMode;
+    /** Optional default account to pass to the wallet adapter. */
+    account?: string;
+    /** EVM transaction request to send. */
+    transaction: EthTransactionRequest;
+    /** Submits the transaction hash and resolves the protocol result. */
+    submit(request: {
+        txHash: string;
+    }): Promise<TResult>;
+}
+/** Any prepared action returned by SDK methods and executable by {@link executeWith}. */
+type WalletAction<TResult> = SignMessageWalletAction<unknown, TResult> | SignPsbtWalletAction<TResult> | SendEthTransactionWalletAction<TResult>;
+
+/** Data embedded in a prepared profile-creation action. */
+interface CreateAccountData {
+    /** Expiry timestamp, in protocol nanoseconds, included in the signed message. */
+    expiryTimestamp: bigint;
+}
+/** Sign-message action that can be submitted after wallet signing. */
+interface SignableAction<TData, TResult> extends SignMessageWalletAction<TData, TResult> {
+}
+/** Prepared action for creating a Liquidium profile. */
+interface CreateAccountAction extends SignableAction<CreateAccountData, string> {
+    /** Protocol action kind. */
+    kind: typeof WalletActionKind.createAccount;
+    /** Required wallet capability. */
+    executionKind: typeof WalletExecutionKind.signMessage;
+    /** Adapter-facing action type. */
+    actionType: typeof WalletActionKind.createAccount;
+}
+/** Signed canister request used to register a new profile. */
+interface CreateAccountRequest {
+    /** Profile-creation data that was signed. */
+    data: CreateAccountData;
+    /** Wallet signature and signer metadata. */
+    signatureInfo: SignatureInfo;
+}
+
+type PrepareCreateProfileOptions = {
+    account: string;
+};
+type CreateProfileParams = {
+    account: string;
+    chain: Chain;
+    walletAdapter: WalletAdapter;
+};
+/** Profile lifecycle and linked-wallet helpers. */
+declare class AccountsModule {
+    readonly canisterContext: CanisterContext;
+    constructor(canisterContext: CanisterContext);
+    /**
+     * Prepares a profile-creation action that can be signed and submitted later.
+     *
+     * Use this when you need direct control over the signing flow.
+     *
+     * @param options - `account` is the wallet address that will own the new profile.
+     * @returns A signable {@link CreateAccountAction} with `submit` wired to the canister.
+     */
+    prepareCreateProfile(options: PrepareCreateProfileOptions): Promise<CreateAccountAction>;
+    /**
+     * Creates a Liquidium profile using the provided wallet adapter.
+     *
+     * This is the convenience form of `prepareCreateProfile(...)` plus execution.
+     *
+     * @param params - Wallet `account`, signing `chain`, and `walletAdapter` with `signMessage`.
+     * @returns The new profile principal as text.
+     */
+    createProfile(params: CreateProfileParams): Promise<string>;
+    /**
+     * Resolves the Liquidium profile id linked to a wallet address.
+     *
+     * @param walletAddress - Wallet address string as registered with the protocol.
+     * @returns Profile principal text, or `null` if none exists.
+     */
+    getProfileId(walletAddress: string): Promise<string | null>;
+    /**
+     * Returns the current nonce for a wallet address.
+     *
+     * This is mainly useful for custom signing flows built on prepared actions.
+     *
+     * @param walletAddress - Wallet address used in `get_nonce` on the lending canister.
+     * @returns The next signing nonce as a bigint.
+     */
+    getWalletNonce(walletAddress: string): Promise<bigint>;
+    /**
+     * Lists the wallets currently linked to a profile.
+     *
+     * @param profileId - The Liquidium profile principal text.
+     * @returns The wallets currently linked to the requested profile.
+     */
+    listLinkedWallets(profileId: string): Promise<Wallet[]>;
+    private buildCreateProfileAction;
+    private submitCreateProfile;
+}
+
+interface ApiClient {
+    get<T>(path: string): Promise<T>;
+    post<TResponse, TBody>(path: string, body: TBody): Promise<TResponse>;
+}
+
+/** Activity list state filter. */
+declare const ActivityFilter: {
+    readonly active: "active";
+    readonly completed: "completed";
+    readonly all: "all";
+};
+/** Activity list state filter. */
+type ActivityFilter = (typeof ActivityFilter)[keyof typeof ActivityFilter];
+/** Direction of value movement for an activity. */
+declare const ActivityDirection: {
+    readonly inflow: "inflow";
+    readonly outflow: "outflow";
+};
+/** Direction of value movement for an activity. */
+type ActivityDirection = (typeof ActivityDirection)[keyof typeof ActivityDirection];
+/** Consumer-facing activity kind. */
+declare const ActivityKind: {
+    readonly deposit: "deposit";
+    readonly repayment: "repayment";
+    readonly borrow: "borrow";
+    readonly withdraw: "withdraw";
+};
+/** Consumer-facing activity kind. */
+type ActivityKind = (typeof ActivityKind)[keyof typeof ActivityKind];
+/** Consumer-facing activity lifecycle status. */
+declare const ActivityStatus: {
+    readonly requested: "requested";
+    readonly pending: "pending";
+    readonly detected: "detected";
+    readonly processing: "processing";
+    readonly sent: "sent";
+    readonly confirmed: "confirmed";
+    readonly failed: "failed";
+};
+/** Consumer-facing activity lifecycle status. */
+type ActivityStatus = (typeof ActivityStatus)[keyof typeof ActivityStatus];
+/** Fee top-up state for an inflow activity. */
+interface ActivityTopUp {
+    /** Whether another transfer is needed before processing can continue. */
+    required: boolean;
+    /** Total same-token deposited amount counted toward the current fee. */
+    depositedAmount: bigint;
+    /** Current deposit-address processing fee. */
+    feeAmount: bigint;
+    /** Additional amount needed before processing can start. */
+    shortfallAmount: bigint;
+}
+/** Activity kind emitted by deposit or repayment inflows. */
+type InflowActivityKind = typeof ActivityKind.deposit | typeof ActivityKind.repayment;
+/** Activity kind emitted by borrow or withdraw outflows. */
+type OutflowActivityKind = typeof ActivityKind.borrow | typeof ActivityKind.withdraw;
+/** Lifecycle status that can appear on an inflow activity. */
+type InflowActivityStatus = typeof ActivityStatus.requested | typeof ActivityStatus.pending | typeof ActivityStatus.detected | typeof ActivityStatus.processing | typeof ActivityStatus.confirmed | typeof ActivityStatus.failed;
+/** Lifecycle status that can appear on an outflow activity. */
+type OutflowActivityStatus = typeof ActivityStatus.requested | typeof ActivityStatus.pending | typeof ActivityStatus.sent | typeof ActivityStatus.confirmed | typeof ActivityStatus.failed;
+interface BaseActivity {
+    id: string;
+    poolId: string;
+    asset: string | null;
+    chain: Chain | null;
+    amount: bigint;
+    timestampMs: number;
+    txid: string | null;
+    txids?: string[];
+    confirmations: number | null;
+    requiredConfirmations: number | null;
+}
+/** Deposit or repayment activity returned by the activity API. */
+interface InflowActivity extends BaseActivity {
+    /** Direction discriminator. */
+    direction: typeof ActivityDirection.inflow;
+    /** Deposit or repayment kind. */
+    kind: InflowActivityKind;
+    /** Single consumer-facing lifecycle status. */
+    status: InflowActivityStatus;
+    /** Fee top-up state when the inflow is below the current processing fee. */
+    topUp?: ActivityTopUp;
+}
+/** Borrow or withdraw activity returned by the activity API. */
+interface OutflowActivity extends BaseActivity {
+    /** Direction discriminator. */
+    direction: typeof ActivityDirection.outflow;
+    /** Borrow or withdraw kind. */
+    kind: OutflowActivityKind;
+    /** Single consumer-facing lifecycle status. */
+    status: OutflowActivityStatus;
+    /** Outflows never carry top-up state. */
+    topUp?: never;
+}
+/** Any activity returned by `activities.list` or `activities.getStatus`. */
+type Activity = InflowActivity | OutflowActivity;
+/** Request for listing activities by profile id or instant-loan short reference. */
+type ListActivitiesRequest = {
+    /** Optional state filter; defaults to `all`. */
+    filter?: ActivityFilter;
+} & ({
+    profileId: string;
+} | {
+    shortRef: string;
+});
+/** Request for fetching one activity by id and owner identifier. */
+type GetActivityStatusRequest = {
+    /** Activity or receipt id to look up. */
+    id: string;
+} & ({
+    profileId: string;
+} | {
+    shortRef: string;
+});
+/** Result of an activity status lookup. */
+type GetActivityStatusResponse = {
+    found: true;
+    activity: Activity;
+} | {
+    found: false;
+    id: string;
+};
+
+/** Receipt-oriented activity list and status helpers. */
+declare class ActivitiesModule {
+    readonly apiClient: ApiClient | undefined;
+    readonly canisterContext: CanisterContext;
+    constructor(apiClient: ApiClient | undefined, canisterContext: CanisterContext);
+    /**
+     * Lists profile activities. Defaults to all activities.
+     *
+     * Uses the Liquidium SDK API.
+     *
+     * @param request - Profile id or instant-loan short reference plus optional state filter.
+     * @returns Activities owned by the resolved profile.
+     */
+    list(request: ListActivitiesRequest): Promise<Activity[]>;
+    /**
+     * Fetches the latest status for a single receipt/activity id.
+     *
+     * Uses the Liquidium SDK API.
+     *
+     * @param request - Activity id plus profile id or instant-loan short reference.
+     * @returns The activity when found, otherwise `{ found: false }` with the requested id.
+     */
+    getStatus(request: GetActivityStatusRequest): Promise<GetActivityStatusResponse>;
+    private requireApi;
+    private resolveProfileId;
+}
+
+/** Consumer-facing status for profile transaction history entries. */
+declare const UserHistoryStatus: {
+    readonly requested: "requested";
+    readonly pending: "pending";
+    readonly confirmed: "confirmed";
+    readonly failed: "failed";
+};
+/** Consumer-facing status for profile transaction history entries. */
+type UserHistoryStatus = (typeof UserHistoryStatus)[keyof typeof UserHistoryStatus];
+/** Uppercase status value used by SDK API responses. */
+type UserHistoryStatusApi = Uppercase<UserHistoryStatus>;
+/** User transaction kinds returned by profile transaction history. */
+type UserTransactionHistoryType = "supply" | "borrow" | "repay" | "withdraw";
+/** User liquidation history kind. */
+type UserLiquidationHistoryType = "liquidation";
+/** Any user history kind returned by the history API. */
+type UserHistoryType = UserTransactionHistoryType | UserLiquidationHistoryType;
+interface BaseUserHistoryEntry {
+    id: string;
+    amount: bigint;
+    poolId: string;
+    timestamp: string;
+    txids?: string[];
+}
+/** Supply, borrow, repay, or withdraw entry in user history. */
+interface UserTransactionHistoryEntry extends BaseUserHistoryEntry {
+    /** Transaction history kind. */
+    type: UserTransactionHistoryType;
+    /** Current lifecycle status. */
+    status: UserHistoryStatus;
+}
+/** Liquidation entry in user history. */
+interface UserLiquidationHistoryEntry extends BaseUserHistoryEntry {
+    /** Liquidation kind discriminator. */
+    type: UserLiquidationHistoryType;
+    /** Liquidations are only returned once confirmed. */
+    status: typeof UserHistoryStatus.confirmed;
+}
+/** Any consumer-facing profile history entry. */
+type UserHistoryEntry = UserTransactionHistoryEntry | UserLiquidationHistoryEntry;
+/** Filters for profile transaction history requests. */
+interface UserTransactionHistoryFilters {
+    /** Pagination cursor from a previous response. */
+    cursor?: string;
+    /** Maximum number of entries to return. */
+    limit?: number;
+    /** Market filter accepted by the SDK API. */
+    market?: string;
+    /** Pool principal text filter. */
+    poolId?: string;
+    /** Transaction kind filters. */
+    types?: UserTransactionHistoryType[];
+    /** Status filters. */
+    statuses?: UserHistoryEntry["status"][];
+    /** Inclusive start timestamp filter accepted by the SDK API. */
+    from?: string;
+    /** Inclusive end timestamp filter accepted by the SDK API. */
+    to?: string;
+}
+/** Filters for profile liquidation history requests. */
+interface UserLiquidationHistoryFilters {
+    /** Pagination cursor from a previous response. */
+    cursor?: string;
+    /** Maximum number of entries to return. */
+    limit?: number;
+    /** Market filter accepted by the SDK API. */
+    market?: string;
+    /** Pool principal text filter. */
+    poolId?: string;
+    /** Inclusive start timestamp filter accepted by the SDK API. */
+    from?: string;
+    /** Inclusive end timestamp filter accepted by the SDK API. */
+    to?: string;
+}
+/** Backwards-compatible alias for user transaction history filters. */
+type ActivitiesRequest = UserTransactionHistoryFilters;
+/** Time-window and pagination options for borrow APY history. */
+interface BorrowApyHistoryRequest {
+    /** Pagination cursor from a previous response. */
+    cursor?: string;
+    /** Maximum number of samples to return. */
+    limit?: number;
+    /** Inclusive start timestamp filter accepted by the SDK API. */
+    from?: string;
+    /** Inclusive end timestamp filter accepted by the SDK API. */
+    to?: string;
+}
+/** Time-window and pagination options for pool rate history. */
+type PoolHistoryRequest = BorrowApyHistoryRequest;
+/** Borrow APY sample returned to SDK consumers. */
+interface ApySample {
+    /** Sample date from the SDK API. */
+    date: string;
+    /** Decimal scale for `avgRate`. */
+    rateDecimals: bigint;
+    /** Average borrow rate for the sample, scaled by `rateDecimals`. */
+    avgRate: bigint;
+}
+/** Wire-format user history item returned by the SDK API. */
+interface UserHistoryEntryApiItem {
+    id: string;
+    type: UserHistoryType;
+    amount: string;
+    poolId: string;
+    timestamp: string;
+    status: UserHistoryStatusApi;
+    txids?: string[];
+}
+/** Wire-format user history page returned by the SDK API. */
+interface UserHistoryResponse {
+    success: true;
+    items: UserHistoryEntryApiItem[];
+    nextCursor?: string;
+}
+/** Pool rate and utilization history entry returned to SDK consumers. */
+interface PoolHistoryEntry {
+    /** Sample date from the SDK API. */
+    date: string;
+    /** Decimal scale for rate fields. */
+    rateDecimals: bigint;
+    /** Average borrow rate for the sample, scaled by `rateDecimals`. */
+    avgBorrowRate: bigint;
+    /** Average lend rate for the sample, scaled by `rateDecimals`. */
+    avgLendRate: bigint;
+    /** Average utilization rate for the sample, scaled by `rateDecimals`. */
+    avgUtilizationRate: bigint;
+}
+/** Wire-format pool rate history item returned by the SDK API. */
+interface PoolHistoryEntryApiItem {
+    date: string;
+    rateDecimals: number;
+    avgBorrowRate: string;
+    avgLendRate: string;
+    avgUtilizationRate: string;
+}
+/** Wire-format pool rate history page returned by the SDK API. */
+interface PoolHistoryResponse {
+    success: true;
+    items: PoolHistoryEntryApiItem[];
+    nextCursor?: string;
+}
+/** Pool configuration snapshot returned to SDK consumers. */
+interface PoolConfigHistoryEntry {
+    type: "configuration_change";
+    poolId: string;
+    asset: string;
+    chain: string;
+    timestamp: string;
+    totalSupply: bigint;
+    totalDebt: bigint;
+    supplyCap?: bigint;
+    borrowCap?: bigint;
+    maxLtv: bigint;
+    liquidationThreshold: bigint;
+    liquidationBonus: bigint;
+    protocolLiquidationFee: bigint;
+    reserveFactor: bigint;
+    baseRate: bigint;
+    optimalUtilizationRate: bigint;
+    rateSlopeBefore: bigint;
+    rateSlopeAfter: bigint;
+    lendingIndex: bigint;
+    borrowIndex: bigint;
+    sameAssetBorrowing: boolean;
+    frozen: boolean;
+}
+/** Wire-format pool configuration history item returned by the SDK API. */
+interface PoolConfigHistoryEntryApiItem {
+    type: "configuration_change";
+    poolId: string;
+    asset: string;
+    chain: string;
+    timestamp: string;
+    totalSupply: string;
+    totalDebt: string;
+    supplyCap?: string;
+    borrowCap?: string;
+    maxLtv: string;
+    liquidationThreshold: string;
+    liquidationBonus: string;
+    protocolLiquidationFee: string;
+    reserveFactor: string;
+    baseRate: string;
+    optimalUtilizationRate: string;
+    rateSlopeBefore: string;
+    rateSlopeAfter: string;
+    lendingIndex: string;
+    borrowIndex: string;
+    sameAssetBorrowing: boolean;
+    frozen: boolean;
+}
+/** Wire-format pool configuration history page returned by the SDK API. */
+interface PoolConfigHistoryResponse {
+    success: true;
+    items: PoolConfigHistoryEntryApiItem[];
+    nextCursor?: string;
+}
+/** Any history entry returned by history module methods. */
+type HistoryEntry = UserHistoryEntry | PoolHistoryEntry | PoolConfigHistoryEntry;
+/** Generic SDK API paginated response. */
+interface PaginatedResponse<T> {
+    /** Items in the current page. */
+    items: T[];
+    /** Cursor for the next page when more results are available. */
+    nextCursor?: string;
+}
+
+/** Historical pool, rate, user transaction, and liquidation data helpers. */
+declare class HistoryModule {
+    readonly apiClient: ApiClient | undefined;
+    constructor(apiClient: ApiClient | undefined);
+    private requireApi;
+    /**
+     * Returns paginated rate and utilization history for a pool.
+     *
+     * @param poolId - The pool principal text.
+     * @param window - Optional time window with from/to timestamps and limit.
+     * @returns A page of pool rate history entries and the next cursor when more results are available.
+     */
+    getPoolHistory(poolId: string, window?: PoolHistoryRequest): Promise<PaginatedResponse<PoolHistoryEntry>>;
+    /**
+     * Returns paginated configuration change history for a pool.
+     *
+     * @param poolId - The pool principal text.
+     * @param cursor - An optional pagination cursor from a previous response.
+     * @returns A page of pool configuration changes and the next cursor when more results are available.
+     */
+    getPoolConfigHistory(poolId: string, cursor?: string): Promise<PaginatedResponse<PoolConfigHistoryEntry>>;
+    /**
+     * Returns borrow rate history for a pool.
+     *
+     * @param poolId - The pool principal text.
+     * @param window - Optional time window with from/to timestamps and limit.
+     * @returns Paginated APY samples.
+     */
+    getBorrowRateHistory(poolId: string, window?: BorrowApyHistoryRequest): Promise<PaginatedResponse<ApySample>>;
+    /**
+     * Returns transaction history for a user.
+     *
+     * @param user - The Liquidium profile principal text.
+     * @param filters - Optional pool, type, status, time range, and pagination filters.
+     * @returns Paginated user history entries.
+     */
+    getUserTransactionHistory(user: string, filters?: UserTransactionHistoryFilters): Promise<PaginatedResponse<UserTransactionHistoryEntry>>;
+    getUserTransactionHistory(user: string, market?: string, filters?: UserTransactionHistoryFilters): Promise<PaginatedResponse<UserTransactionHistoryEntry>>;
+    /**
+     * Returns liquidation history for a user.
+     *
+     * @param user - The Liquidium profile principal text.
+     * @param filters - Optional pool, time range, and pagination filters.
+     * @returns Paginated liquidation history entries.
+     */
+    getLiquidationHistory(user: string, filters?: UserLiquidationHistoryFilters): Promise<PaginatedResponse<UserLiquidationHistoryEntry>>;
+    getLiquidationHistory(user: string, market?: string, filters?: UserLiquidationHistoryFilters): Promise<PaginatedResponse<UserLiquidationHistoryEntry>>;
+}
+
+/** Destination account for a completed outflow. */
+interface OutflowReceiver {
+    /** Destination account type reported by the protocol. */
+    type: "Native" | "External";
+    /** Destination principal or external-chain address. */
+    account: string;
+}
+/**
+ * Receipt for a borrow or withdraw submitted to the lending canister.
+ *
+ * `id` is the outflow reference to show users immediately. `txid` may be unset until
+ * the protocol assigns a chain transaction id. `outflowRef` is an optional protocol reference.
+ */
+interface OutflowDetails {
+    /** Protocol outflow id. */
+    id: string;
+    /** Borrow, withdraw, or fee-claim discriminator. */
+    outflowType: OutflowType;
+    /** Optional protocol outflow reference. */
+    outflowRef?: string;
+    /** Chain transaction id when already assigned by the protocol. */
+    txid?: string;
+    /** Outflow amount in the pool asset's base units. */
+    amount: bigint;
+    /** Outflow destination account. */
+    receiver: OutflowReceiver;
+}
+/** Borrow receipt with an external-chain receiver. */
+type BorrowOutflowDetails = OutflowDetails & {
+    outflowType: "borrow";
+    receiver: {
+        type: "External";
+        account: string;
+    };
+};
+/** Withdraw receipt with an external-chain receiver. */
+type WithdrawOutflowDetails = OutflowDetails & {
+    outflowType: "withdraw";
+    receiver: {
+        type: "External";
+        account: string;
+    };
+};
+/** Signature payload for submitting a prepared borrow action. */
+interface BorrowSubmitSignatureInfo extends SignatureInfo {
+}
+/** Signature payload for submitting a prepared withdraw action. */
+interface WithdrawSubmitSignatureInfo extends SignatureInfo {
+}
+/**
+ * Fields to build a borrow request. `amount` is in the borrow pool asset's base units
+ * (e.g. satoshis, token smallest units).
+ */
+interface CreateBorrowRequest {
+    /** Liquidium profile principal text. */
+    profileId: string;
+    /** Borrow pool principal text. */
+    poolId: string;
+    /** Amount to borrow in the borrow asset's base units. */
+    amount: bigint;
+    /** External-chain address that receives the borrowed asset. */
+    receiverAddress: string;
+    /** Wallet address that signs the borrow authorization. */
+    signerWalletAddress: string;
+}
+/** Prepared borrow request data embedded in the signable action. */
+interface CreateBorrowData extends CreateBorrowRequest {
+    /** Expiry timestamp, in protocol nanoseconds, included in the signed message. */
+    expiryTimestamp: bigint;
+}
+/** Prepared action for creating a borrow outflow. */
+interface BorrowAction extends SignMessageWalletAction<CreateBorrowData, BorrowOutflowDetails> {
+    /** Protocol action kind. */
+    kind: typeof WalletActionKind.createBorrow;
+    /** Required wallet capability. */
+    executionKind: typeof WalletExecutionKind.signMessage;
+    /** Adapter-facing action type. */
+    actionType: typeof WalletActionKind.createBorrow;
+}
+/**
+ * Fields to build a withdraw request. `amount` is in the pool asset's base units.
+ */
+interface CreateWithdrawRequest {
+    /** Liquidium profile principal text. */
+    profileId: string;
+    /** Pool principal text to withdraw from. */
+    poolId: string;
+    /** Amount to withdraw in the pool asset's base units. */
+    amount: bigint;
+    /** External-chain address that receives the withdrawn asset. */
+    receiverAddress: string;
+    /** Wallet address that signs the withdraw authorization. */
+    signerWalletAddress: string;
+}
+/** Prepared withdraw request data embedded in the signable action. */
+interface CreateWithdrawData extends CreateWithdrawRequest {
+    /** Expiry timestamp, in protocol nanoseconds, included in the signed message. */
+    expiryTimestamp: bigint;
+}
+/** Prepared action for creating a withdraw outflow. */
+interface WithdrawAction extends SignMessageWalletAction<CreateWithdrawData, WithdrawOutflowDetails> {
+    /** Protocol action kind. */
+    kind: typeof WalletActionKind.createWithdraw;
+    /** Required wallet capability. */
+    executionKind: typeof WalletExecutionKind.signMessage;
+    /** Adapter-facing action type. */
+    actionType: typeof WalletActionKind.createWithdraw;
+}
+/** Supply execution plan selected by the SDK. */
+declare const SupplyPlanType: {
+    readonly contractInteraction: "contractInteraction";
+    readonly transfer: "transfer";
+};
+/** Supply execution plan selected by the SDK. */
+type SupplyPlanType = (typeof SupplyPlanType)[keyof typeof SupplyPlanType];
+/** External-chain address target for manual or wallet-executed transfers. */
+interface NativeAddressSupplyTarget {
+    /** Target discriminator. */
+    type: "nativeAddress";
+    /** Pool principal text receiving the inflow. */
+    poolId: string;
+    /** Asset expected by the target. */
+    asset: MarketAsset;
+    /** Chain where the target address is valid. */
+    chain: MarketChain;
+    /** Deposit or repayment action for the inflow. */
+    action: SupplyAction;
+    /** External-chain address where funds should be sent. */
+    address: string;
+}
+/** ICRC account target for ck-asset or contract-interaction inflows. */
+interface IcrcAccountSupplyTarget {
+    /** Target discriminator. */
+    type: "icrcAccount";
+    /** Pool principal text receiving the inflow. */
+    poolId: string;
+    /** Asset expected by the target. */
+    asset: MarketAsset;
+    /** Chain associated with the inflow. */
+    chain: MarketChain;
+    /** Deposit or repayment action for the inflow. */
+    action: SupplyAction;
+    /** ICRC account owner principal text. */
+    owner: string;
+    /** ICRC subaccount bytes. */
+    subaccount: Uint8Array;
+    /** Text-encoded ICRC account. */
+    account: string;
+}
+/** Supply destination returned by `lending.supply(...)`. */
+type SupplyTarget = NativeAddressSupplyTarget | IcrcAccountSupplyTarget;
+interface BaseSupplyFlowRequest {
+    profileId: string;
+    poolId: string;
+    action: SupplyAction;
+}
+/** Manual transfer-based `lending.supply` request. */
+interface ManualTransferSupplyFlowRequest extends BaseSupplyFlowRequest {
+    /** Optional explicit transfer mechanism. */
+    mechanism?: typeof SupplyPlanType.transfer;
+    /** Disallowed for manual transfer flows. */
+    walletAdapter?: never;
+    /** Disallowed for manual transfer flows. */
+    account?: never;
+    /** Disallowed for manual transfer flows. */
+    amount?: never;
+}
+/** Wallet-executed transfer-based `lending.supply` request. */
+interface WalletTransferSupplyFlowRequest extends BaseSupplyFlowRequest {
+    /** Optional explicit transfer mechanism. */
+    mechanism?: typeof SupplyPlanType.transfer;
+    /** Wallet adapter used to broadcast the transfer. */
+    walletAdapter: Pick<WalletAdapter, "sendBtcTransaction" | "sendEthTransaction">;
+    /** Sender wallet account. */
+    account: string;
+    /** Transfer amount in the target asset's base units. */
+    amount: bigint;
+}
+/** Transfer-based supply request, either manual or wallet-executed. */
+type TransferSupplyFlowRequest = ManualTransferSupplyFlowRequest | WalletTransferSupplyFlowRequest;
+/** Input for contract-interaction `lending.supply`, which always executes now. */
+interface ContractInteractionSupplyFlowRequest extends BaseSupplyFlowRequest {
+    /** Contract-interaction mechanism discriminator. */
+    mechanism: typeof SupplyPlanType.contractInteraction;
+    /** ETH wallet adapter used to approve and deposit ERC-20 assets. */
+    walletAdapter: Pick<WalletAdapter, "sendEthTransaction">;
+    /** Sender EVM wallet address. */
+    account: string;
+    /** Deposit or repayment amount in token base units. */
+    amount: bigint;
+}
+/** Request accepted by `lending.supply(...)`. */
+type SupplyFlowRequest = TransferSupplyFlowRequest | ContractInteractionSupplyFlowRequest;
+/**
+ * Supply receipt returned by `lending.supply(...)`.
+ *
+ * - `txid` is populated when the SDK broadcast the transaction on your behalf
+ *   (wallet-adapter path). When undefined, the caller is expected to broadcast
+ *   themselves and call {@link SupplyFlow.submit} for flows that require txid
+ *   registration.
+ * - `submit` registers a broadcast txid with the SDK API when needed. ETH
+ *   stablecoin deposit-address transfers are indexed from ERC-20 transfer logs,
+ *   so `submit` acknowledges the txid without posting it to the inflow endpoint.
+ *
+ * The SDK does not poll inflow status. When you have a `txid`, it is your
+ * responsibility to track confirmation state with your own polling.
+ */
+interface SupplyFlow {
+    /** Execution plan used by the supply flow. */
+    type: SupplyPlanType;
+    /** Destination where funds should be sent or were sent. */
+    target: SupplyTarget;
+    /** Transaction id when the SDK broadcast the transaction. */
+    txid?: string;
+    /** Registers a broadcast transaction id when the flow requires an indexing hint. */
+    submit(request: SubmitInflowRequest): Promise<SubmitInflowResponse>;
+}
+/** Body for `SupplyFlow.submit` / `lending.submitInflow`. */
+interface SubmitInflowRequest {
+    /** Broadcast transaction id or hash. */
+    txid: string;
+    /** Chain where the transaction was broadcast, when not implied by the flow. */
+    chain?: Chain;
+    /** Deposit or repayment submit type, when not implied by the flow. */
+    type?: InflowSubmitType;
+}
+/** Acknowledgement from the SDK API after submitting an inflow hint. */
+interface SubmitInflowResponse {
+    /** Indicates the submit request was accepted by the SDK API. */
+    success: true;
+    /** Transaction id accepted by the SDK API. */
+    txid: string;
+}
+/** Request for estimating the fee needed for an inflow target. */
+interface EstimateInflowFeeRequest {
+    /** Asset to estimate for. */
+    asset: Asset;
+    /** Chain to estimate for. */
+    chain: Chain;
+}
+/** Fee estimate for an inflow target. */
+interface InflowFeeEstimate {
+    /** Estimated total fee in the asset's base units. */
+    totalFee: bigint;
+}
+/** Request for ERC-20 approval and deposit planning. */
+interface GetEvmSupplyContextRequest {
+    /** Liquidium profile principal text. */
+    profileId: string;
+    /** Pool principal text receiving the inflow. */
+    poolId: string;
+    /** EVM wallet address that will send funds. */
+    walletAddress: string;
+    /** Supply amount in token base units. */
+    amount: bigint;
+    /** Deposit or repayment action for the inflow. */
+    action: SupplyAction;
+}
+/** Approval strategy required before an ERC-20 deposit contract call. */
+declare const EvmSupplyApprovalStrategy: {
+    readonly approveMax: "approve-max";
+    readonly none: "none";
+    readonly resetThenApproveMax: "reset-then-approve-max";
+};
+/** Approval strategy required before an ERC-20 deposit contract call. */
+type EvmSupplyApprovalStrategy = (typeof EvmSupplyApprovalStrategy)[keyof typeof EvmSupplyApprovalStrategy];
+/** ERC-20 supply planning data returned by `lending.getEvmSupplyContext(...)`. */
+interface EvmSupplyContext {
+    /** Indicates the context was computed successfully. */
+    success: true;
+    /** Liquidium profile principal text. */
+    profileId: string;
+    /** Pool principal text receiving the inflow. */
+    poolId: string;
+    /** Normalized EVM wallet address. */
+    walletAddress: string;
+    /** Deposit or repayment action for the inflow. */
+    action: SupplyAction;
+    /** Supported ETH stablecoin asset. */
+    asset: typeof Asset.USDC | typeof Asset.USDT;
+    /** ETH chain discriminator. */
+    chain: typeof Chain.ETH;
+    /** Requested amount serialized in token base units. */
+    amount: string;
+    /** ERC-20 token contract address. */
+    tokenAddress: string;
+    /** Contract address that must be approved as spender. */
+    spenderAddress: string;
+    /** Deposit helper contract address. */
+    depositContractAddress: string;
+    /** Current token balance serialized in base units. */
+    balance: string;
+    /** Current allowance serialized in base units. */
+    allowance: string;
+    /** Whether an approval transaction is needed before deposit. */
+    requiresApproval: boolean;
+    /** Approval sequence the caller should perform. */
+    approvalStrategy: EvmSupplyApprovalStrategy;
+}
+
+type WalletExecutionParams = {
+    signerChain: Chain;
+    signerWalletAdapter: WalletAdapter;
+};
+/** Borrow, withdraw, supply, inflow reporting, and fee-estimation helpers. */
+declare class LendingModule {
+    readonly canisterContext: CanisterContext;
+    readonly apiClient: ApiClient | undefined;
+    readonly evmReadClient: EvmReadClient | undefined;
+    constructor(canisterContext: CanisterContext, apiClient: ApiClient | undefined, evmReadClient: EvmReadClient | undefined);
+    /**
+     * Prepares a withdraw action that can be signed and submitted later.
+     *
+     * Use this when you need explicit control over signing and submission.
+     *
+     * @param request - Profile, pool, amount (pool asset base units), outflow address, and signer wallet.
+     * @returns A signable {@link WithdrawAction} with `submit` wired to the canister.
+     */
+    prepareWithdraw(request: CreateWithdrawRequest): Promise<WithdrawAction>;
+    private submitWithdraw;
+    /**
+     * Creates a withdraw outflow using the provided wallet adapter.
+     *
+     * This is the convenience form of `prepareWithdraw(...)` plus execution.
+     *
+     * @param params - Withdraw request fields plus `signerChain` and `signerWalletAdapter`.
+     * @returns The canister {@link OutflowDetails} for the completed withdraw.
+     */
+    withdraw(params: CreateWithdrawRequest & WalletExecutionParams): Promise<WithdrawOutflowDetails>;
+    /**
+     * Prepares a borrow action that can be signed and submitted later.
+     *
+     * Use this when you need explicit control over signing and submission.
+     *
+     * @param request - Profile, pool, amount (borrow asset base units), outflow address, and signer wallet.
+     * @returns A signable {@link BorrowAction} with `submit` wired to the canister.
+     */
+    prepareBorrow(request: CreateBorrowRequest): Promise<BorrowAction>;
+    private submitBorrow;
+    /**
+     * Creates a borrow outflow using the provided wallet adapter.
+     *
+     * This is the convenience form of `prepareBorrow(...)` plus execution.
+     *
+     * @param params - Borrow request fields plus `signerChain` and `signerWalletAdapter`.
+     * @returns The lending canister receipt as {@link OutflowDetails}.
+     *
+     * @remarks
+     * `id` is always present. `txid` may be missing on the first response; the SDK does not
+     * poll for it. Use history or app-level polling if you need the chain transaction id.
+     */
+    borrow(params: CreateBorrowRequest & WalletExecutionParams): Promise<BorrowOutflowDetails>;
+    /**
+     * Resolves a supply target for a deposit or repayment and optionally broadcasts it.
+     *
+     * Transfer mode can return manual broadcast instructions when wallet fields are
+     * omitted. Contract-interaction mode always requires `walletAdapter`, `account`,
+     * and `amount` because it must prepare and submit approval/deposit calls.
+     *
+     * The SDK does not poll for inflow status. When a `txid` is returned, it is the
+     * caller's responsibility to track confirmation state using their own polling.
+     *
+     * @returns A {@link SupplyFlow} receipt with `type`, `target`, `submit`, and
+     *   an optional `txid` present when the SDK broadcast for you.
+     */
+    supply(request: SupplyFlowRequest): Promise<SupplyFlow>;
+    /**
+     * Fetches ERC-20 supply planning data with the configured EVM read client.
+     *
+     * Requires `evmRpcUrl` or `evmPublicClient` on the client. Used internally by
+     * contract-interaction `supply`.
+     *
+     * @param request - Profile, pool, wallet, amount (token base units), and action.
+     * @returns Locally computed {@link EvmSupplyContext} for approvals and deposit.
+     */
+    getEvmSupplyContext(request: GetEvmSupplyContextRequest): Promise<EvmSupplyContext>;
+    private getEvmSupplyContextForPool;
+    /**
+     * Returns the read-only deposit address for an ETH stablecoin inflow target.
+     *
+     * This is a query call that does not create or mutate state. Use it when you
+     * need the deposit address without hitting the authorization-gated update path.
+     *
+     * @param request - Profile, pool, asset, and supply action.
+     * @returns The EVM deposit address for the derived account.
+     */
+    getDepositAddress(request: {
+        profileId: string;
+        poolId: string;
+        asset: string;
+        action: SupplyAction;
+    }): Promise<string>;
+    /**
+     * Estimates the network/deposit fee for an inflow target.
+     *
+     * ETH stablecoin deposit-address estimates are served by the deposit-address
+     * canister. BTC estimates are not exposed by this SDK yet and return zero.
+     *
+     * @param request - Asset and chain pair to estimate for.
+     * @returns Total fee estimate in the asset's base units.
+     */
+    estimateInflowFee(request: EstimateInflowFeeRequest): Promise<InflowFeeEstimate>;
+    private sendAndSubmitNativeSupplyInflow;
+    private submitSupplyFlowInflow;
+    private executeContractSupply;
+    private sendNativeSupplyTransaction;
+    private submitInflowWithRetry;
+    /**
+     * Submits an inflow transaction id for faster indexing.
+     *
+     * Uses the Liquidium SDK API.
+     *
+     * @param request - Broadcast `txid` plus optional `chain` and inflow `type`.
+     * @returns Acknowledgement including the submitted `txid`.
+     */
+    submitInflow(request: SubmitInflowRequest): Promise<SubmitInflowResponse>;
+    /**
+     * Returns whether borrowing is currently disabled by the protocol.
+     *
+     * @returns `true` when the lending canister reports borrowing disabled.
+     */
+    isBorrowingDisabled(): Promise<boolean>;
+    private requireApi;
+    private requireEvmReadClient;
+    private getPoolById;
+    private sendEthContractTransaction;
+    private waitForExpectedAllowance;
+}
+
+/** Current protocol metadata and rate state for a lending pool. */
+interface Pool {
+    /** Pool canister principal text. */
+    id: string;
+    /** Asset supplied to and borrowed from the pool. */
+    asset: MarketAsset;
+    /** Chain associated with the pool asset. */
+    chain: MarketChain;
+    /** Number of base-unit decimals for pool amounts. */
+    decimals: bigint;
+    /** Whether new pool activity is currently frozen. */
+    frozen: boolean;
+    /** Total supplied amount in base units. */
+    totalSupply: bigint;
+    /** Total borrowed amount in base units. */
+    totalDebt: bigint;
+    /** Currently available liquidity in base units. */
+    availableLiquidity: bigint;
+    /** Optional supply cap in base units. */
+    supplyCap?: bigint;
+    /** Optional borrow cap in base units. */
+    borrowCap?: bigint;
+    /** Maximum loan-to-value ratio, scaled by `rateDecimals`. */
+    maxLtv: bigint;
+    /** Liquidation threshold, scaled by `rateDecimals`. */
+    liquidationThreshold: bigint;
+    /** Liquidation bonus, scaled by `rateDecimals`. */
+    liquidationBonus: bigint;
+    /** Protocol liquidation fee, scaled by `rateDecimals`. */
+    protocolLiquidationFee: bigint;
+    /** Reserve factor, scaled by `rateDecimals`. */
+    reserveFactor: bigint;
+    /** Decimal scale used by rate and risk-ratio fields. */
+    rateDecimals: bigint;
+    /** Current supply APR, scaled by `rateDecimals`. */
+    lendingRate: bigint;
+    /** Current borrow APR, scaled by `rateDecimals`. */
+    borrowingRate: bigint;
+    /** Current pool utilization, scaled by `rateDecimals`. */
+    utilizationRate: bigint;
+    /** Base borrow rate, scaled by `rateDecimals`. */
+    baseRate: bigint;
+    /** Optimal utilization point, scaled by `rateDecimals`. */
+    optimalUtilizationRate: bigint;
+    /** Rate slope before optimal utilization, scaled by `rateDecimals`. */
+    rateSlopeBefore: bigint;
+    /** Rate slope after optimal utilization, scaled by `rateDecimals`. */
+    rateSlopeAfter: bigint;
+    /** Current lending index. */
+    lendingIndex: bigint;
+    /** Current borrow index. */
+    borrowIndex: bigint;
+    /** Whether borrowing the same asset as collateral is allowed. */
+    sameAssetBorrowing: boolean;
+    /** Last pool update timestamp when available. */
+    lastUpdated?: bigint;
+}
+/** USD price map keyed by market asset symbol. */
+type AssetPrices = Record<string, number>;
+/** Asset and chain pair used to find a unique pool. */
+interface FindPoolQuery {
+    /** Asset symbol to match. */
+    asset: MarketAsset;
+    /** Chain name to match. */
+    chain: MarketChain;
+}
+/** Current borrow, lend, and utilization rates for a pool. */
+interface PoolRate {
+    /** Decimal scale used by rate fields. */
+    rateDecimals: bigint;
+    /** Borrow APR scaled by `rateDecimals`. */
+    borrowRate: bigint;
+    /** Lend APR scaled by `rateDecimals`. */
+    lendRate: bigint;
+    /** Utilization rate scaled by `rateDecimals`. */
+    utilizationRate: bigint;
+}
+
+/** Pool metadata, prices, and current rate helpers. */
+declare class MarketModule {
+    readonly canisterContext: CanisterContext;
+    readonly apiClient: ApiClient | undefined;
+    constructor(canisterContext: CanisterContext, apiClient: ApiClient | undefined);
+    /**
+     * Lists all pools with their current rates.
+     *
+     * @returns All configured lending pools enriched with their current rate data.
+     */
+    listPools(): Promise<Pool[]>;
+    /**
+     * Returns the latest asset prices reported by the protocol.
+     *
+     * @returns The latest protocol price map keyed by market asset symbol.
+     */
+    getAssetPrices(): Promise<AssetPrices>;
+    /**
+     * Resolves a single pool for the given asset and chain pair.
+     *
+     * @param query - The market asset and chain pair to match.
+     * @returns The single pool that matches the requested asset and chain.
+     */
+    findPool(query: FindPoolQuery): Promise<Pool>;
+    /**
+     * Returns the full pool record for the given asset and chain pair.
+     *
+     * Convenience wrapper over {@link MarketModule.findPool}. `listPools()` already
+     * enriches each pool with its current rate data, so no extra canister call is made.
+     *
+     * @param query - The market asset and chain pair to match.
+     * @returns The matching pool enriched with current rate data.
+     */
+    getReserveData(query: FindPoolQuery): Promise<Pool>;
+    /**
+     * Returns the current borrow, lend, and utilization rates for a pool.
+     *
+     * @param poolId - The pool principal text.
+     * @returns The borrow, lend, and utilization rates for the requested pool.
+     */
+    getPoolRate(poolId: string): Promise<PoolRate>;
+}
+
+/** Current profile position in one lending pool. */
+interface Position {
+    /** Pool principal text. */
+    poolId: string;
+    /** Pool asset symbol. */
+    asset: MarketAsset;
+    /** Supplied principal in base units. */
+    deposited: bigint;
+    /** Decimal scale for supplied amounts. */
+    depositedDecimals: bigint;
+    /** Borrowed principal in base units. */
+    borrowed: bigint;
+    /** Decimal scale for borrowed amounts. */
+    borrowedDecimals: bigint;
+    /** Accrued supply interest in base units. */
+    earnedInterest: bigint;
+    /** Accrued borrow interest in base units. */
+    debtInterest: bigint;
+    /** Protocol timestamp of the last position update. */
+    lastUpdate: bigint;
+}
+/** Aggregate borrowing capacity for a profile. */
+interface BorrowingPower {
+    /** Weighted maximum LTV, scaled by protocol rate decimals. */
+    weightedMaxLtv: bigint;
+    /** Maximum borrowable USD value, scaled by `maxBorrowableUsdDecimals`. */
+    maxBorrowableUsd: bigint;
+    /** Decimal scale for `maxBorrowableUsd`. */
+    maxBorrowableUsdDecimals: bigint;
+}
+/** Aggregate debt, collateral, and liquidation stats for a profile. */
+interface UserStats {
+    /** Total debt value in USD-scaled units. */
+    debt: bigint;
+    /** Decimal scale for `debt`. */
+    debtDecimals: bigint;
+    /** Total collateral value in USD-scaled units. */
+    collateral: bigint;
+    /** Decimal scale for `collateral`. */
+    collateralDecimals: bigint;
+    /** Weighted liquidation threshold, scaled by protocol rate decimals. */
+    weightedLiquidationThreshold: bigint;
+    /** Current borrowing capacity. */
+    borrowingPower: BorrowingPower;
+}
+/** Health factor and supporting aggregate stats for a profile. */
+interface HealthFactor {
+    /** Current health factor, scaled by protocol rate decimals. */
+    healthFactor: bigint;
+    /** Aggregate stats used to derive the health factor. */
+    userStats: UserStats;
+}
+/** Derived profile-level position summary for dashboards. */
+interface UserPositionSummary {
+    /** Total collateral USD value. */
+    totalCollateralUsd: bigint;
+    /** Total debt USD value. */
+    totalDebtUsd: bigint;
+    /** Available borrow capacity in USD-scaled units. */
+    availableBorrowsUsd: bigint;
+    /** Collateral minus debt in USD-scaled units. */
+    netWorthUsd: bigint;
+    /** Decimal scale for USD fields. */
+    usdDecimals: bigint;
+    /** Current LTV in basis points. */
+    currentLtvBps: bigint;
+    /** Weighted maximum LTV in basis points. */
+    weightedMaxLtvBps: bigint;
+    /** Weighted liquidation threshold in basis points. */
+    weightedLiquidationThresholdBps: bigint;
+    /** Current health factor. */
+    healthFactor: bigint;
+}
+/** Position joined with pool metadata and current USD valuation. */
+interface UserReserve {
+    /** Position data for the pool. */
+    position: Position;
+    /** Pool metadata and rate data. */
+    pool: Pool;
+    /** Current USD price for the reserve asset. */
+    priceUsd: number;
+    /** Supplied value in USD-scaled units. */
+    suppliedUsd: bigint;
+    /** Borrowed value in USD-scaled units. */
+    borrowedUsd: bigint;
+    /** Decimal scale for USD fields. */
+    usdDecimals: bigint;
+}
+/** Full repayment amount for a position, including any requested buffer. */
+interface MaxRepayAmount {
+    /** Amount to repay in the borrowed asset's base units. */
+    amount: bigint;
+    /** Decimal scale for `amount`. */
+    decimals: bigint;
+}
+
+/** Profile position, health factor, and reserve valuation helpers. */
+declare class PositionsModule {
+    readonly canisterContext: CanisterContext;
+    readonly market: MarketModule;
+    constructor(canisterContext: CanisterContext, market: MarketModule);
+    /**
+     * Returns a single position for a profile and pool.
+     *
+     * @param profileId - The Liquidium profile principal text.
+     * @param poolId - The pool principal text.
+     * @returns The position for the requested profile and pool, or `null` when no position exists.
+     */
+    getPosition(profileId: string, poolId: string): Promise<Position | null>;
+    /**
+     * Lists all positions for a profile.
+     *
+     * @param profileId - The Liquidium profile principal text.
+     * @returns All positions currently associated with the requested profile.
+     */
+    listPositions(profileId: string): Promise<Position[]>;
+    /**
+     * Returns the current health factor for a profile.
+     *
+     * @param profileId - The Liquidium profile principal text.
+     * @returns The current health factor for the requested profile.
+     */
+    getHealthFactor(profileId: string): Promise<HealthFactor>;
+    /**
+     * Returns aggregate borrowing and collateral stats for a profile.
+     *
+     * @param profileId - The Liquidium profile principal text.
+     * @returns Aggregate debt, collateral, and borrowing power metrics for the requested profile.
+     */
+    getUserStats(profileId: string): Promise<UserStats>;
+    /**
+     * Returns an aggregate summary of a profile's position.
+     *
+     * Single canister round-trip (`get_health_factor`). Derived fields:
+     * `availableBorrowsUsd = max(0, maxBorrowableUsd - debt)`,
+     * `netWorthUsd = collateral - debt` (may be negative if underwater),
+     * `currentLtvBps = debt * 10_000 / collateral` (0 when collateral is 0).
+     *
+     * @param profileId - The Liquidium profile principal text.
+     * @returns Derived position summary for the requested profile.
+     */
+    getUserPositionSummary(profileId: string): Promise<UserPositionSummary>;
+    /**
+     * Returns the per-reserve breakdown of a profile's supplies and borrows,
+     * joined with pool metadata, rates, and current USD prices.
+     *
+     * USD values are scaled to {@link USD_VALUE_SCALE_DECIMALS} (27).
+     *
+     * @param profileId - The Liquidium profile principal text.
+     * @returns Per-reserve position rows joined with pool metadata and USD values.
+     */
+    getUserReserves(profileId: string): Promise<UserReserve[]>;
+    /**
+     * Returns the full repayment amount for a position, with a small buffer to
+     * account for interest that accrues between quote and submit.
+     *
+     * @param profileId - The Liquidium profile principal text.
+     * @param poolId - The pool principal text.
+     * @param bufferBps - Optional buffer in basis points (default 10 = 0.1%).
+     * @returns Buffered repayment amount in the borrowed asset's base units.
+     */
+    getMaxRepayAmount(profileId: string, poolId: string, bufferBps?: bigint): Promise<MaxRepayAmount>;
+}
+
+/** Builds calldata for an ERC-20 `transfer(recipient, amount)` transaction. */
+declare function createTransferErc20Transaction(params: {
+    tokenAddress: string;
+    recipientAddress: string;
+    amount: bigint;
+}): {
+    to: string;
+    data: string;
+};
+
+/** Asset symbols supported by the instant-loans canister. */
+type InstantLoanAsset = "BTC" | "SOL" | "USDC" | "USDT";
+/** External chain account used for borrow delivery or collateral refunds. */
+interface ExternalAccount {
+    /**
+     * Account kind discriminator.
+     *
+     * Use `External` for addresses outside the IC, such as BTC, Solana, or EVM
+     * addresses. Instant-loan creation currently accepts external destinations.
+     */
+    type: "External";
+    /**
+     * Optional chain metadata for display and caller-side validation.
+     *
+     * The instant-loan API only sends `address` to the canister. Include `chain`
+     * when your UI needs to remember which network the address belongs to.
+     */
+    chain?: Chain | MarketChain;
+    /**
+     * Destination address on the external chain.
+     *
+     * For `borrowDestination`, this receives the borrowed asset. For
+     * `refundDestination`, this receives collateral refunds or withdrawals.
+     */
+    address: string;
+}
+/** IC principal account returned when a canister-native destination is used. */
+interface NativeAccount {
+    /** Account kind discriminator. */
+    type: "Native";
+    /** Principal text for the canister-native account. */
+    principal: string;
+}
+/** Borrow destination or refund account associated with an instant loan. */
+type InstantLoanAccount = ExternalAccount | NativeAccount;
+/**
+ * Parameters for creating an accountless instant loan.
+ *
+ * Use market data from `client.market.listPools()` to choose the two pool ids,
+ * and use `client.quote.calculateLtv(...)` before creation to validate the
+ * amount pair and choose `ltvMaxBps`.
+ *
+ * Amount fields are in each asset's smallest/base units. For example, BTC uses
+ * satoshis and ERC-20 assets use token base units according to the selected
+ * pool decimals.
+ */
+interface CreateInstantLoanRequest {
+    /**
+     * Principal text of the pool that receives the user's collateral deposit.
+     *
+     * This should be the `id` of the collateral `Pool` selected from
+     * `client.market.listPools()`. The pool asset must match `collateralAsset`.
+     */
+    collateralPoolId: string;
+    /**
+     * Principal text of the pool that funds the borrow.
+     *
+     * This should be the `id` of the borrow `Pool` selected from
+     * `client.market.listPools()`. The pool asset must match `borrowAsset`.
+     */
+    borrowPoolId: string;
+    /**
+     * Asset the user will deposit as collateral.
+     *
+     * Must match the asset for `collateralPoolId`; for example, use `"BTC"` with
+     * a BTC collateral pool.
+     */
+    collateralAsset: InstantLoanAsset;
+    /**
+     * Asset the user wants to borrow from the borrow pool.
+     *
+     * Must match the asset for `borrowPoolId`; for example, use `"USDC"` with a
+     * USDC borrow pool.
+     */
+    borrowAsset: InstantLoanAsset;
+    /**
+     * Amount the user is expected to deposit as collateral, in base units.
+     *
+     * This is used to validate LTV and initialize the loan record. For BTC, pass
+     * satoshis. For token assets, convert the UI amount using the selected pool's
+     * `decimals` value.
+     */
+    collateralAmount: bigint;
+    /**
+     * Amount to borrow, in the borrow asset's base units.
+     *
+     * For USDC/USDT, convert the UI amount using the selected borrow pool's
+     * `decimals` value before passing it here.
+     */
+    borrowAmount: bigint;
+    /**
+     * Maximum allowed loan-to-value ratio in basis points.
+     *
+     * `6_000n` means 60%. Use `client.quote.calculateLtv(...)` to calculate the
+     * implied LTV for the selected amounts and pass the policy value your app is
+     * willing to accept. Creation is rejected if the requested borrow would exceed
+     * this limit.
+     */
+    ltvMaxBps: bigint;
+    /**
+     * Seconds allowed for the user to send collateral after loan creation.
+     *
+     * If the collateral deposit is not detected before this window expires, the
+     * instant-loan flow can time out. Internally this is sent to the canister as
+     * `ltv_timer_s`.
+     */
+    depositWindowSeconds: bigint;
+    /**
+     * External destination that receives the borrowed asset after the loan starts.
+     *
+     * Pass either an address string or `{ type: "External", address }`. This is
+     * usually the user's wallet address on the borrow asset's chain, such as an
+     * EVM address for ETH USDC/USDT outflows.
+     */
+    borrowDestination: string | ExternalAccount;
+    /**
+     * External destination that receives collateral refunds or withdrawals.
+     *
+     * Pass either an address string or `{ type: "External", address }`. This
+     * should be an address on the collateral asset's chain, such as a BTC address
+     * when `collateralAsset` is `"BTC"`.
+     */
+    refundDestination: string | ExternalAccount;
+}
+/** Lookup request for loading canonical instant-loan state. */
+type InstantLoanGetRequest = {
+    loanId: bigint;
+} | {
+    ref: string;
+};
+/** Page request for direct instant-loan canister event queries. */
+interface InstantLoanListEventsRequest {
+    /** Event id to start from. */
+    start: bigint;
+    /** Maximum number of events to return. */
+    limit: bigint;
+}
+/** Active instant-loans canister config. */
+interface InstantLoanConfig {
+    /** Principal text of the lending canister used by instant loans. */
+    lendingCanisterId: string;
+}
+/** Authentication metadata for warmed instant-loan profiles. */
+interface InstantLoanAuthorization {
+    type: "EthSignature";
+    derivationIndex: Uint8Array;
+    publicKey: Uint8Array;
+    address: string;
+}
+/** Warmed profile available for a future instant loan. */
+interface InstantLoanWarmedProfile {
+    id: bigint;
+    authorization: InstantLoanAuthorization;
+    createdAt: bigint;
+    profileId: string;
+}
+/** Direct canister event returned by the instant-loans query API. */
+interface InstantLoanEvent {
+    id: bigint;
+    schemaVersion: number;
+    timestamp: bigint;
+    eventType: InstantLoanEventType;
+}
+/** Instant-loan leg used when stuck funds are withdrawn. */
+type InstantLoanLeg = "Lend" | "Borrow";
+/** Direct canister event payload returned by instant-loans event queries. */
+type InstantLoanEventType = {
+    type: "LoanCreated";
+    loanId: bigint;
+    borrowDestination: InstantLoanAccount;
+    collateralAsset: InstantLoanAsset;
+    borrowAmount: bigint;
+    collateralPoolId: string;
+    refundDestination: InstantLoanAccount;
+    ltvMaxBps: bigint;
+    depositWindowSeconds: bigint;
+    profileId: string;
+    borrowPoolId: string;
+    borrowAsset: InstantLoanAsset;
+} | {
+    type: "FullLendWithdrawalRequested";
+    loanId: bigint;
+    account: InstantLoanAccount;
+    poolId: string;
+} | {
+    type: "BorrowRequested";
+    loanId: bigint;
+    account: InstantLoanAccount;
+    poolId: string;
+    amount: bigint;
+} | {
+    type: "DepositTimerExceeded";
+    loanId: bigint;
+} | {
+    type: "StuckFundsWithdrawalRequested";
+    leg: InstantLoanLeg;
+    loanId: bigint;
+    account: InstantLoanAccount;
+    poolId: string;
+    amount: bigint;
+} | {
+    type: "ProfileWarmed";
+    derivationIndex: Uint8Array;
+    warmedProfileId: bigint;
+    ethAddress: string;
+    profileId: string;
+} | {
+    type: "RepayComplete";
+    loanId: bigint;
+    profileId: string;
+} | {
+    type: "DepositTimerStarted";
+    loanId: bigint;
+    timestamp: bigint;
+};
+/** Current amount to send to the repayment target to close the debt. */
+interface InstantLoanRepayment {
+    /** Full amount to send to the repayment target, including fee and interest buffer. */
+    amount: bigint;
+    /** Decimal scale for `amount`. */
+    decimals: bigint;
+    /** Current debt in base units, before fee and interest buffer. */
+    debtAmount: bigint;
+    /** Additional interest buffer in base units. */
+    interestBufferAmount: bigint;
+    /** Seconds of interest accrual included in `interestBufferAmount`. */
+    interestBufferSeconds: bigint;
+    /** Inflow fee amount in base units added to the repayment transfer. Falls back to the protocol minimum when live estimation is unavailable. */
+    inflowFeeAmount: bigint;
+    /** Whether `inflowFeeAmount` came from a live fee estimate. */
+    inflowFeeEstimateAvailable: boolean;
+    /** Asset to repay. */
+    asset: MarketAsset;
+    /** Chain used for repayment. */
+    chain: MarketChain;
+    /** Address or ICRC account where the repayment should be sent. */
+    target: SupplyTarget;
+}
+/** Current lending position backing the instant loan. */
+interface InstantLoanPositionSummary {
+    /** Current collateral amount in the collateral asset's base units. */
+    collateralAmount: bigint;
+    /** Decimal scale for `collateralAmount`. */
+    collateralDecimals: bigint;
+    /** Earned interest on the collateral side in base units. */
+    collateralInterestAmount: bigint;
+    /** Borrowed principal in the borrow asset's base units. */
+    borrowedAmount: bigint;
+    /** Decimal scale for borrowed/debt amounts. */
+    borrowedDecimals: bigint;
+    /** Accrued borrow interest in base units. */
+    debtInterestAmount: bigint;
+    /** Borrowed principal plus accrued interest in base units, before repayment buffer. */
+    totalDebtAmount: bigint;
+}
+/** Simplified lifecycle status for consumer UIs. */
+declare const InstantLoanStatus: {
+    readonly awaitingDeposit: "awaiting_deposit";
+    readonly depositDetected: "deposit_detected";
+    readonly active: "active";
+    readonly settling: "settling";
+    readonly closed: "closed";
+};
+type InstantLoanStatus = (typeof InstantLoanStatus)[keyof typeof InstantLoanStatus];
+/** Hydrated instant-loan state plus generated deposit and repayment targets. */
+interface InstantLoan {
+    /** Canister-assigned loan id. */
+    loanId: bigint;
+    /** Short user-facing reference derived from `loanId`. */
+    ref: string;
+    /** Simplified lifecycle status for display and flow control. */
+    status: InstantLoanStatus;
+    /** Generated lending profile principal used by the instant loan. */
+    profileId: string;
+    /** Maximum loan-to-value ratio in basis points. */
+    ltvMaxBps: bigint;
+    /** Seconds allowed for the collateral deposit before timeout. */
+    depositWindowSeconds: bigint;
+    /** Collateral-side pool, asset, chain, and current or requested collateral amount. */
+    collateral: {
+        poolId: string;
+        asset: MarketAsset;
+        chain: MarketChain;
+        amount: bigint;
+    };
+    /** Borrow-side pool, asset, chain, requested amount, and destination. */
+    borrow: {
+        poolId: string;
+        asset: MarketAsset;
+        chain: MarketChain;
+        amount: bigint;
+        destination: InstantLoanAccount;
+    };
+    /** Destination used for collateral refunds or withdrawals. */
+    refundDestination: InstantLoanAccount;
+    /** Address or ICRC account where the user deposits collateral. */
+    depositTarget: SupplyTarget;
+    /** Address or ICRC account where the user repays debt. */
+    repayTarget: SupplyTarget;
+    /** Current actionable repayment quote. */
+    repayment: InstantLoanRepayment;
+    /** Current lending position state for the generated profile. */
+    position: InstantLoanPositionSummary;
+}
+/**
+ * Discovery result returned by address lookup.
+ *
+ * Candidates are intentionally lightweight; call `instantLoans.get(...)` with
+ * `loanId` or `ref` to load canonical canister state and transfer targets.
+ */
+interface InstantLoanCandidate {
+    /** Canister-assigned loan id. */
+    loanId: bigint;
+    /** Short user-facing reference derived from `loanId`. */
+    ref: string;
+    /** Generated lending profile principal used by the instant loan. */
+    profileId: string;
+    /** API-observed creation time, if provided by the indexer. */
+    createdAt?: Date;
+    /** Principal text of the collateral pool. */
+    collateralPoolId: string;
+    /** Principal text of the borrow pool. */
+    borrowPoolId: string;
+    /** Collateral asset symbol. */
+    collateralAsset: MarketAsset;
+    /** Borrow asset symbol. */
+    borrowAsset: MarketAsset;
+    /** Collateral amount hint in base units. */
+    collateralAmountHint: bigint;
+}
+
+/** Accountless instant-loan creation, lookup, recovery, and canister query helpers. */
+declare class InstantLoansModule {
+    readonly canisterContext: CanisterContext;
+    readonly apiClient: ApiClient | undefined;
+    readonly lending: LendingModule;
+    readonly positions: PositionsModule;
+    constructor(canisterContext: CanisterContext, apiClient: ApiClient | undefined, lending: LendingModule, positions: PositionsModule);
+    /**
+     * Creates a profileless instant loan and returns canonical canister state plus
+     * deposit/repay targets for the generated lending profile.
+     *
+     * Choose `collateralPoolId` and `borrowPoolId` from
+     * `client.market.listPools()`, convert UI amounts to base units with the
+     * selected pool decimals, and call `client.quote.calculateLtv(...)` before
+     * creation to block invalid LTV input.
+     *
+     * `borrowDestination` receives the borrowed asset after the loan starts.
+     * `refundDestination` receives collateral refunds or withdrawals. Use
+     * `depositWindowSeconds` for the user-facing collateral deposit timeout; the
+     * SDK maps it to the canister's internal `ltv_timer_s` field.
+     *
+     * @param request - Pool ids, assets, base-unit amounts, LTV limit, timeout, and destinations.
+     * @returns Hydrated loan state plus generated deposit and repayment targets.
+     */
+    create(request: CreateInstantLoanRequest): Promise<InstantLoan>;
+    /**
+     * Resolves canonical canister state by loan id or short reference.
+     *
+     * References are decoded locally, then the corresponding loan id is loaded
+     * from the instant-loans canister.
+     *
+     * @param request - Canister loan id or short public reference.
+     * @returns Hydrated loan state plus generated deposit and repayment targets.
+     */
+    get(request: InstantLoanGetRequest): Promise<InstantLoan>;
+    /**
+     * Returns the active instant-loans canister config via direct query.
+     *
+     * @returns Active canister configuration.
+     */
+    getConfig(): Promise<InstantLoanConfig>;
+    /**
+     * Returns a single canister event by id via direct query.
+     *
+     * @param eventId - Event id to load.
+     * @returns The event when found, otherwise `null`.
+     */
+    getEvent(eventId: bigint): Promise<InstantLoanEvent | null>;
+    /**
+     * Returns a page of canister events via direct query.
+     *
+     * @param request - Start event id and maximum number of events to return.
+     * @returns Canister events in ascending id order.
+     */
+    listEvents(request: InstantLoanListEventsRequest): Promise<InstantLoanEvent[]>;
+    /**
+     * Returns principals authorized for protected update callbacks.
+     *
+     * @returns Principal text values on the canister access list.
+     */
+    listAccessList(): Promise<string[]>;
+    /**
+     * Returns the current size of the warmed-profile pool via direct query.
+     *
+     * @returns Number of warmed profiles available on the canister.
+     */
+    countWarmedProfiles(): Promise<bigint>;
+    /**
+     * Returns warmed profiles currently available for future instant loans.
+     *
+     * @returns Warmed profile records available for assignment.
+     */
+    listWarmedProfiles(): Promise<InstantLoanWarmedProfile[]>;
+    /**
+     * Finds candidate loans associated with an address through the Liquidium SDK
+     * API. Returns discovery candidates only; call `get(...)` to hydrate canister state.
+     *
+     * Candidates are useful for recovery flows where the user knows a borrow or
+     * refund address but not the loan reference.
+     *
+     * @param address - Borrow or refund address to search for.
+     * @returns Lightweight loan candidates associated with the address.
+     */
+    findByAddress(address: string): Promise<InstantLoanCandidate[]>;
+    private mapLoanRecord;
+    private mapLoanWire;
+    private hydrateLoan;
+    private estimateRepaymentInflowFee;
+    private requireApi;
+    private validateInstantLoanLtvPolicy;
+    private calculateInstantLoanLtv;
+}
+
+/**
+ * Converts a canister loan id into a short user-facing reference.
+ *
+ * @param id - Canister loan id in the supported public-reference range.
+ * @returns Fixed-length public reference string.
+ */
+declare function publicIdFromInt(id: bigint): string;
+/**
+ * Decodes a short user-facing reference back into the canister loan id.
+ *
+ * @param ref - Fixed-length public reference string.
+ * @returns Canister loan id represented by the reference.
+ */
+declare function intFromPublicId(ref: string): bigint;
+
+/** Input for calculating required collateral from a target LTV. */
+interface QuoteRequest {
+    /** Requested borrow amount in borrow asset base units. */
+    borrowAmount: bigint;
+    /** Pool principal text for the borrow side. */
+    borrowPoolId: string;
+    /** Pool principal text for the collateral side. */
+    collateralPoolId: string;
+    /** Target loan-to-value ratio in basis points. */
+    targetLtvBps: bigint;
+}
+/** Input for calculating LTV from explicit borrow and collateral amounts. */
+interface CalculateLtvRequest {
+    /** Requested borrow amount in borrow asset base units. */
+    borrowAmount: bigint;
+    /** Pool principal text for the borrow side. */
+    borrowPoolId: string;
+    /** Collateral amount in collateral asset base units. */
+    collateralAmount: bigint;
+    /** Pool principal text for the collateral side. */
+    collateralPoolId: string;
+}
+/** Validation error produced by quote helpers. */
+interface QuoteValidationError {
+    /** Stable machine-readable validation code. */
+    code: QuoteValidationErrorCode;
+    /** Human-readable validation message. */
+    message: string;
+}
+/** Stable validation codes produced by quote helpers. */
+declare enum QuoteValidationErrorCode {
+    INVALID_LTV = "INVALID_LTV",
+    LTV_EXCEEDS_MAX = "LTV_EXCEEDS_MAX",
+    SAME_ASSET_NOT_ALLOWED = "SAME_ASSET_NOT_ALLOWED",
+    BORROW_AMOUNT_TOO_LOW = "BORROW_AMOUNT_TOO_LOW",
+    PRICE_NOT_AVAILABLE = "PRICE_NOT_AVAILABLE",
+    POOL_NOT_FOUND = "POOL_NOT_FOUND",
+    UNKNOWN = "UNKNOWN"
+}
+/** Non-blocking warning produced by quote helpers. */
+interface QuoteWarning {
+    /** Stable machine-readable warning code. */
+    code: QuoteWarningCode;
+    /** Human-readable warning message. */
+    message: string;
+}
+/** Stable warning codes produced by quote helpers. */
+declare enum QuoteWarningCode {
+    HIGH_LTV = "HIGH_LTV",
+    SAME_ASSET_BORROWING = "SAME_ASSET_BORROWING"
+}
+/** Quote result for a requested borrow amount and target LTV. */
+interface QuoteResult {
+    /** Requested borrow amount in borrow asset base units. */
+    borrowAmount: bigint;
+    /** Borrow value in internal USD units. */
+    borrowUsd: bigint;
+    /** Required collateral amount in collateral asset base units. */
+    requiredCollateralAmount: bigint;
+    /** Required collateral value in internal USD units. */
+    requiredCollateralUsd: bigint;
+    /** Maximum allowed LTV in basis points for the collateral pool. */
+    maxAllowedLtvBps: bigint;
+    /** Requested target LTV in basis points. */
+    targetLtvBps: bigint;
+    /** Pool principal text for the borrow side. */
+    borrowPoolId: string;
+    /** Pool principal text for the collateral side. */
+    collateralPoolId: string;
+    /** Borrow asset symbol. */
+    borrowAsset: string;
+    /** Collateral asset symbol. */
+    collateralAsset: string;
+    /** Blocking validation errors. Empty when the quote is usable. */
+    validationErrors: QuoteValidationError[];
+    /** Non-blocking quote warnings. */
+    warnings: QuoteWarning[];
+}
+/** LTV calculation result for explicit borrow and collateral amounts. */
+interface LtvCalculation {
+    /** Requested borrow amount in borrow asset base units. */
+    borrowAmount: bigint;
+    /** Collateral amount in collateral asset base units. */
+    collateralAmount: bigint;
+    /** Borrow value in internal USD units. */
+    borrowUsd: bigint;
+    /** Collateral value in internal USD units. */
+    collateralUsd: bigint;
+    /** Computed LTV in basis points. */
+    ltvBps: bigint;
+    /** Maximum allowed LTV in basis points for the collateral pool. */
+    maxAllowedLtvBps: bigint;
+    /** Pool principal text for the borrow side. */
+    borrowPoolId: string;
+    /** Pool principal text for the collateral side. */
+    collateralPoolId: string;
+    /** Borrow asset symbol. */
+    borrowAsset: string;
+    /** Collateral asset symbol. */
+    collateralAsset: string;
+    /** Blocking validation errors. Empty when the calculation is usable. */
+    validationErrors: QuoteValidationError[];
+}
+
+/** Pure quote helpers for LTV and required-collateral calculations. */
+declare class QuoteModule {
+    /**
+     * Calculates current LTV from caller-supplied borrow and collateral amounts.
+     *
+     * Amount fields are base units. USD fields are scaled to 8 decimal places.
+     *
+     * @param request - Borrow and collateral pool ids plus base-unit amounts.
+     * @param pools - Available pools, usually from `client.market.listPools()`.
+     * @param prices - USD price map, usually from `client.market.getAssetPrices()`.
+     * @returns LTV calculation plus validation errors when inputs are unusable.
+     */
+    calculateLtv(request: CalculateLtvRequest, pools: Pool[], prices: AssetPrices): LtvCalculation;
+    /**
+     * Calculates a loan quote based on borrow amount, LTV, and pool selections.
+     *
+     * All arithmetic is performed in bigint. `requiredCollateralAmount` and
+     * `requiredCollateralUsd` are rounded UP so the caller never under-collateralizes
+     * due to integer truncation. `borrowUsd` is floored for display.
+     *
+     * @param request - Quote request parameters.
+     * @param pools - All available pools (use MarketModule.listPools() to fetch).
+     * @param prices - Asset prices in USD (use MarketModule.getAssetPrices() to fetch).
+     * @returns Quote result with required collateral and validation state.
+     */
+    getQuote(request: QuoteRequest, pools: Pool[], prices: AssetPrices): QuoteResult;
+}
+
+/**
+ * Root client for Liquidium protocol integration (canister + optional HTTP API).
+ *
+ * Construct with `new LiquidiumClient(config)`.
+ */
+declare class LiquidiumClient {
+    /** Profile lifecycle: create, resolve, linked wallets. */
+    readonly accounts: AccountsModule;
+    /** Borrow, withdraw, supply, inflow reporting and tracking. */
+    readonly lending: LendingModule;
+    /** Per-pool positions, health, aggregate stats. */
+    readonly positions: PositionsModule;
+    /** Pool list, prices, pool rate lookups. */
+    readonly market: MarketModule;
+    /** Receipt-oriented activity status and activity lists. */
+    readonly activities: ActivitiesModule;
+    /** Pool and user history through the Liquidium SDK API. */
+    readonly history: HistoryModule;
+    /** Accountless instant loans backed by generated deposit/repay targets. */
+    readonly instantLoans: InstantLoansModule;
+    /** Pure quote helpers from market inputs. */
+    readonly quote: QuoteModule;
+    private readonly canisterContext;
+    private readonly apiClient;
+    private readonly evmReadClient;
+    /**
+     * Creates a Liquidium SDK client.
+     *
+     * @param config - Runtime transport, canister, API, identity, and EVM read options.
+     */
+    constructor(config?: LiquidiumClientConfig);
+}
+
+/**
+ * Stable string codes for {@link LiquidiumError}. Use for branching in application code.
+ */
+declare const LiquidiumErrorCode: {
+    readonly INVALID_TARGET_PRINCIPAL: "INVALID_TARGET_PRINCIPAL";
+    readonly INSUFFICIENT_COLLATERAL: "INSUFFICIENT_COLLATERAL";
+    readonly SIGNATURE_EXPIRY_TOO_FAR_IN_FUTURE: "SIGNATURE_EXPIRY_TOO_FAR_IN_FUTURE";
+    readonly MAX_LTV_EXCEEDED: "MAX_LTV_EXCEEDED";
+    readonly SIGNATURE_EXPIRED: "SIGNATURE_EXPIRED";
+    readonly ACCOUNT_ALREADY_LINKED: "ACCOUNT_ALREADY_LINKED";
+    readonly ACCOUNT_NOT_FOUND: "ACCOUNT_NOT_FOUND";
+    readonly CANNOT_REMOVE_SOLE_ACCOUNT: "CANNOT_REMOVE_SOLE_ACCOUNT";
+    readonly PROFILE_NOT_FOUND: "PROFILE_NOT_FOUND";
+    readonly PROFILE_ALREADY_EXISTS: "PROFILE_ALREADY_EXISTS";
+    readonly SIGNATURE_ERROR: "SIGNATURE_ERROR";
+    readonly POOL_NOT_FOUND: "POOL_NOT_FOUND";
+    readonly POOL_FROZEN: "POOL_FROZEN";
+    readonly POSITION_NOT_FOUND: "POSITION_NOT_FOUND";
+    readonly BORROW_CAP_EXCEEDED: "BORROW_CAP_EXCEEDED";
+    readonly SUPPLY_CAP_EXCEEDED: "SUPPLY_CAP_EXCEEDED";
+    readonly INSUFFICIENT_FUNDS: "INSUFFICIENT_FUNDS";
+    readonly HEALTH_FACTOR_TOO_LOW: "HEALTH_FACTOR_TOO_LOW";
+    readonly TRANSFER_FAILED: "TRANSFER_FAILED";
+    readonly LIQUIDATION_NOT_FOUND: "LIQUIDATION_NOT_FOUND";
+    readonly BORROWING_DISABLED: "BORROWING_DISABLED";
+    readonly NO_LIQUIDITY: "NO_LIQUIDITY";
+    readonly NOT_ALLOWED: "NOT_ALLOWED";
+    readonly INVALID_ETH_SIGNATURE: "INVALID_ETH_SIGNATURE";
+    readonly INVALID_BTC_SIGNATURE: "INVALID_BTC_SIGNATURE";
+    readonly INVALID_ETH_ADDRESS: "INVALID_ETH_ADDRESS";
+    readonly UNSUPPORTED_CHAIN: "UNSUPPORTED_CHAIN";
+    readonly WITHDRAW_TOO_LOW: "WITHDRAW_TOO_LOW";
+    readonly REPAYMENT_EXCEEDS_DEBT: "REPAYMENT_EXCEEDS_DEBT";
+    readonly INVALID_ADDRESS: "INVALID_ADDRESS";
+    readonly DEPOSIT_ADDRESS_ERROR: "DEPOSIT_ADDRESS_ERROR";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+    readonly REQUEST_TIMEOUT: "REQUEST_TIMEOUT";
+    readonly CANISTER_REJECTED: "CANISTER_REJECTED";
+    readonly INTERNAL: "INTERNAL";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+};
+type LiquidiumErrorCode = (typeof LiquidiumErrorCode)[keyof typeof LiquidiumErrorCode];
+/** Optional debug identifiers attached to mapped SDK errors. */
+interface LiquidiumErrorContext {
+    /** Backend trace id for support/debugging when available. */
+    traceId?: string;
+    /** SDK API request id for support/debugging when available. */
+    requestId?: string;
+}
+/**
+ * Typed error from the SDK or mapped protocol failures.
+ *
+ * Prefer checking `code` over parsing `message`.
+ */
+declare class LiquidiumError extends Error {
+    /** Machine-readable reason; compare to {@link LiquidiumErrorCode} values. */
+    readonly code: LiquidiumErrorCode;
+    /** Original error when the SDK wraps an underlying failure. */
+    readonly cause?: unknown;
+    /** Backend trace id for support/debugging when available. */
+    readonly traceId?: string;
+    /** SDK API request id for support/debugging when available. */
+    readonly requestId?: string;
+    /**
+     * @param code - Error code from {@link LiquidiumErrorCode}.
+     * @param message - Human-readable detail (defaults to `code` when omitted).
+     * @param cause - Optional underlying error.
+     * @param context - Optional backend debug identifiers.
+     */
+    constructor(code: LiquidiumErrorCode, message?: string, cause?: unknown, context?: LiquidiumErrorContext);
+}
+
+/** Ethereum mainnet USDC contract address. */
+declare const USDC_CONTRACT_ADDRESS = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
+/** Ethereum mainnet USDT contract address. */
+declare const USDT_CONTRACT_ADDRESS = "0xdac17f958d2ee523a2206206994597c13d831ec7";
+/** Ethereum mainnet ckETH minter ERC-20 deposit helper contract address. */
+declare const CK_ETH_DEPOSIT_CONTRACT_ADDRESS = "0x18901044688D3756C35Ed2b36D93e6a5B8e00E68";
+
+/** Fixed-point scale used by protocol rate values. */
+declare const RATE_SCALE = 1000000000000000000000000000n;
+/** Number of decimal places represented by {@link RATE_SCALE}. */
+declare const RATE_DECIMALS: bigint;
+
+/**
+ * Wallet wiring for {@link executeWith}.
+ *
+ * `chain` and `account` override values embedded on the action when present;
+ * message signing uses `options.account ?? action.account`.
+ */
+interface ExecuteWithOptions {
+    /** Must expose the methods required by the action's `executionKind`. */
+    walletAdapter: WalletAdapter;
+    /** Required for `sign-message` actions; forwarded to the adapter and submit payload. */
+    chain?: Chain;
+    /** Optional signing/sending account override. */
+    account?: string;
+}
+/**
+ * Returns an async function that runs a {@link WalletAction} end-to-end.
+ *
+ * - `sign-message`: needs `walletAdapter.signMessage` and `options.chain`.
+ * - `sign-psbt`: needs `walletAdapter.signPsbt`.
+ * - `send-eth-transaction`: needs `walletAdapter.sendEthTransaction`.
+ *
+ * @param options - Adapter and optional chain/account overrides.
+ * @returns A function that accepts a `WalletAction` and resolves with its submit result.
+ */
+declare function executeWith(options: ExecuteWithOptions): <TResult>(action: WalletAction<TResult>) => Promise<TResult>;
+
+export { type ActivitiesRequest, type Activity, ActivityDirection, ActivityFilter, ActivityKind, ActivityStatus, type ApySample, Asset, type AssetPrices, type BorrowAction, type BorrowApyHistoryRequest, type BorrowOutflowDetails, type BorrowSubmitSignatureInfo, type BorrowingPower, CK_ETH_DEPOSIT_CONTRACT_ADDRESS, type CalculateLtvRequest, type CanisterIds, Chain, type ContractInteractionSupplyFlowRequest, type CreateAccountAction, type CreateAccountData, type CreateAccountRequest, type CreateBorrowData, type CreateBorrowRequest, type CreateInstantLoanRequest, type CreateWithdrawData, type CreateWithdrawRequest, Environment, type EstimateInflowFeeRequest, type EthTransactionRequest, type EvmReadClient, EvmSupplyApprovalStrategy, type EvmSupplyContext, type ExecuteWithOptions, type ExternalAccount, type GetActivityStatusRequest, type GetActivityStatusResponse, type GetEvmSupplyContextRequest, type HealthFactor, type HistoryEntry, type IcrcAccountSupplyTarget, type InflowActivity, type InflowActivityKind, type InflowActivityStatus, type InflowFeeEstimate, InflowSubmitType, type InstantLoan, type InstantLoanAccount, type InstantLoanAsset, type InstantLoanCandidate, type InstantLoanGetRequest, InstantLoanStatus, LiquidiumClient, type LiquidiumClientConfig, LiquidiumError, LiquidiumErrorCode, type ListActivitiesRequest, type LtvCalculation, type MarketAsset, type MarketChain, type NativeAccount, type NativeAddressSupplyTarget, type OutflowActivity, type OutflowActivityKind, type OutflowActivityStatus, type OutflowDetails, type OutflowReceiver, OutflowType, type PaginatedResponse, type Pool, type PoolConfigHistoryEntry, type PoolConfigHistoryEntryApiItem, type PoolConfigHistoryResponse, type PoolHistoryEntry, type PoolHistoryEntryApiItem, type PoolHistoryRequest, type PoolHistoryResponse, type PoolRate, type Position, type QuoteRequest, type QuoteResult, type QuoteValidationError, QuoteValidationErrorCode, type QuoteWarning, QuoteWarningCode, RATE_DECIMALS, RATE_SCALE, type SendEthTransactionRequest, type SendEthTransactionWalletAction, type SignMessageRequest, type SignMessageWalletAction, type SignPsbtRequest, type SignPsbtWalletAction, type SignableAction, type SignatureInfo, type SubmitInflowRequest, type SubmitInflowResponse, SupplyAction, type SupplyFlow, type SupplyFlowRequest, SupplyPlanType, type SupplyTarget, TransferMode, type TransferSupplyFlowRequest, USDC_CONTRACT_ADDRESS, USDT_CONTRACT_ADDRESS, type UserHistoryEntry, type UserHistoryEntryApiItem, type UserHistoryResponse, UserHistoryStatus, type UserHistoryStatusApi, type UserHistoryType, type UserLiquidationHistoryEntry, type UserLiquidationHistoryFilters, type UserLiquidationHistoryType, type UserPositionSummary, type UserReserve, type UserStats, type UserTransactionHistoryEntry, type UserTransactionHistoryFilters, type UserTransactionHistoryType, type Wallet, type WalletAction, type WalletAdapter, WalletExecutionKind, type WithdrawAction, type WithdrawOutflowDetails, type WithdrawSubmitSignatureInfo, createTransferErc20Transaction, executeWith, intFromPublicId, publicIdFromInt };