@pear-protocol/symmio-client 0.1.11 → 0.2.0

package/dist/react/index.d.ts

@@ -2,7 +2,7 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as viem from 'viem';
 import { Address, Hex, PublicClient, WalletClient } from 'viem';
 import * as _pear_protocol_symm_core from '@pear-protocol/symm-core';
-import { SymmSDK, OpenBasketPositionRequest, ClosePositionRequest, CancelOpenRequest, UpdatePositionRequest, SetTpslRequest, CancelTpslRequest, GetSymmHedgerMarketsRequest, MarketItem } from '@pear-protocol/symm-core';
+import { SymmSDK, CloseOrderRequest, OpenBasketPositionRequest, ClosePositionRequest, CancelOpenRequest, UpdatePositionRequest, SetTpslRequest, CancelTpslRequest, GetTpslOrdersRequest, UpsertTriggerConfigRequest, GetSymmHedgerMarketsRequest, MarketItem } from '@pear-protocol/symm-core';
 import * as _tanstack_react_query from '@tanstack/react-query';
 import * as _tanstack_query_core from '@tanstack/query-core';
 import * as node_modules__pear_protocol_symm_core_dist_types from 'node_modules/@pear-protocol/symm-core/dist/types';
@@ -539,6 +539,39 @@ declare function useSymmAccounts(userAddress?: Address, options?: {
     }, unknown>;
 };
 
+declare function useSymmAccountsApi(params: {
+    userAddress?: Address;
+    chainId?: number;
+    query?: SymmQueryConfig;
+}): {
+    accounts: node_modules__pear_protocol_symm_core_dist_types.AccountInfo[];
+    total: number;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<node_modules__pear_protocol_symm_core_dist_types.AccountsListResponse, Error>>;
+};
+
+declare function useSymmAccountsLength(params: {
+    userAddress?: Address;
+    chainId?: number;
+    query?: SymmQueryConfig;
+}): {
+    chains: node_modules__pear_protocol_symm_core_dist_types.ChainAccountLength[];
+    total: number;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<node_modules__pear_protocol_symm_core_dist_types.AccountsLengthResponse, Error>>;
+};
+
+declare function useSymmAccountsWithPositions(params: {
+    userAddress?: Address;
+    chainId?: number;
+    query?: SymmQueryConfig;
+}): {
+    accounts: node_modules__pear_protocol_symm_core_dist_types.AccountWithPositions[];
+    total: number;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<node_modules__pear_protocol_symm_core_dist_types.AccountsWithPositionsResponse, Error>>;
+};
+
 declare function useSymmApproval(params: {
     owner?: Address;
     amount: bigint;
@@ -553,6 +586,19 @@ declare function useSymmApproval(params: {
     approve: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, bigint, unknown>;
 };
 
+declare function useSymmCancelClose(): {
+    cancelClose: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_shared.ApiResponse<unknown>, Error, {
+        quoteId: string;
+        authToken?: string;
+        accountAddress?: Address;
+        overrideChainId?: number;
+    }, unknown>;
+};
+
+declare function useSymmCloseOrder(): {
+    closeOrder: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_core.CloseOrderResponse, Error, CloseOrderRequest, unknown>;
+};
+
 declare function useSymmDeposit(): {
     deposit: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, {
         account: Address;
@@ -713,9 +759,9 @@ declare function useSymmTradeHistory(params: {
     chainId?: number;
     query?: SymmQueryConfig;
 }): {
-    trades: _pear_protocol_symm_shared.ApiResponse<unknown> | null;
+    trades: _pear_protocol_symm_core.PositionsListResponse | null;
     isLoading: boolean;
-    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_shared.ApiResponse<unknown>, Error>>;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.PositionsListResponse, Error>>;
 };
 
 declare function useSymmTpsl(): {
@@ -723,6 +769,22 @@ declare function useSymmTpsl(): {
     cancelTpsl: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_shared.ApiResponse<unknown>, Error, CancelTpslRequest, unknown>;
 };
 
+type UseSymmTpslOrdersParams = {
+    accountAddress?: Address;
+    mainAddress?: Address;
+    positionId?: string;
+    type?: GetTpslOrdersRequest['type'];
+    status?: GetTpslOrdersRequest['status'];
+    chainId?: number;
+    query?: SymmQueryConfig;
+};
+declare function useSymmTpslOrders(params: UseSymmTpslOrdersParams): {
+    tpslOrders: _pear_protocol_symm_core.TpslOrder[];
+    total: number;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.TpslListResponse, Error>>;
+};
+
 declare function useSymmTwap(params: {
     accountAddress?: Address;
     mainAddress?: Address;
@@ -734,6 +796,34 @@ declare function useSymmTwap(params: {
     cancelTwap: _tanstack_react_query.UseMutationResult<node_modules__pear_protocol_symm_core_dist_types.TwapOrderResponse, Error, string, unknown>;
 };
 
+declare function useSymmTriggerConfig(params: {
+    orderId?: string;
+    query?: SymmQueryConfig;
+}): {
+    triggerConfig: Record<string, unknown> | null;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.GetTriggerConfigResponse, Error>>;
+    setTriggerConfig: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_core.GetTriggerConfigResponse, Error, UpsertTriggerConfigRequest, unknown>;
+    clearTriggerConfig: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_core.GetTriggerConfigResponse, Error, void, unknown>;
+};
+
+declare function useSymmTriggerOrders(params: {
+    accountAddress?: Address;
+    mainAddress?: Address;
+    chainId?: number;
+    status?: string;
+    limit?: number;
+    offset?: number;
+    query?: SymmQueryConfig;
+}): {
+    orders: _pear_protocol_symm_core.TriggerOrderItem[];
+    total: number;
+    limit: number;
+    offset: number;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.TriggerOrdersListResponse, Error>>;
+};
+
 declare function useSymmMarkets(params?: {
     chainId?: number;
     searchText?: string;
@@ -744,6 +834,45 @@ declare function useSymmMarkets(params?: {
     refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.MarketsResponse, Error>>;
 };
 
+declare function useSymmHedgerMarketById(params: {
+    id?: number;
+    chainId?: number;
+    query?: SymmQueryConfig;
+}): {
+    market: _pear_protocol_symm_core.MarketItem | null;
+    markets: _pear_protocol_symm_core.MarketItem[];
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.HedgerMarketsListResponse, Error>>;
+};
+
+declare function useSymmHedgerMarketBySymbol(params: {
+    symbol?: string;
+    chainId?: number;
+    query?: SymmQueryConfig;
+}): {
+    market: _pear_protocol_symm_core.MarketItem | null;
+    markets: _pear_protocol_symm_core.MarketItem[];
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.HedgerMarketsListResponse, Error>>;
+};
+
+declare function useSymmLockedParams(params: {
+    marketName?: string;
+    leverage?: number;
+    chainId?: number;
+    query?: SymmQueryConfig;
+}): {
+    lockedParams: {
+        cva: string;
+        lf: string;
+        partyAmm: string;
+        partyBmm: string;
+        leverage: number;
+    } | null;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<node_modules__pear_protocol_symm_core_dist_types.LockedParamsResponse, Error>>;
+};
+
 type UseSymmHedgerMarketsParams = GetSymmHedgerMarketsRequest & {
     /** @deprecated Use `query.enabled` instead. */
     enabled?: boolean;
@@ -773,6 +902,63 @@ declare function useSymmFunding(params?: {
     isLoading: boolean;
 };
 
+declare function useSymmFundingHistory(params: {
+    period: '7d' | '30d' | '90d' | '180d';
+    longSymbols?: string;
+    shortSymbols?: string;
+    interval?: '1h' | '4h' | '12h' | '1d';
+    weightMode?: 'equal_side' | 'notional';
+    includeContributions?: boolean;
+    chainId?: number;
+    query?: SymmQueryConfig;
+}): {
+    history: {
+        period: string;
+        interval: string;
+        periodStart: string;
+        periodEnd: string;
+        longSymbols: string[];
+        shortSymbols: string[];
+        weightMode: string;
+        series: Array<{
+            timestamp: string;
+            epochTimestamp: string;
+            netFundingRatePct: number;
+            cumulativeFundingRatePct: number;
+            missingSymbols?: string[];
+            contributions?: Array<{
+                symbol: string;
+                side: string;
+                weight: number;
+                fundingRate: number;
+                contributionPct: number;
+            }>;
+        }>;
+        summary: {
+            points: number;
+            latestNetFundingRatePct: number;
+            cumulativeFundingRatePct: number;
+            avgNetFundingRatePct: number;
+        };
+    } | null;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.FundingHistoryResponse, Error>>;
+};
+
+declare function useSymmFundingPayments(params: {
+    address?: Address;
+    positionId?: string;
+    chainId?: number;
+    limit?: number;
+    offset?: number;
+    query?: SymmQueryConfig;
+}): {
+    payments: node_modules__pear_protocol_symm_core_dist_types.FundingPayment[];
+    total: number;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.FundingPaymentsResponse, Error>>;
+};
+
 declare function useSymmPortfolio(params: {
     accountAddress?: Address;
     mainAddress?: Address;
@@ -799,6 +985,41 @@ declare function useSymmNotifications(params: {
     refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.NotificationsResponse, Error>>;
 };
 
+declare function useSymmPendingIds(params: {
+    accountAddress?: Address;
+    chainId?: number;
+    query?: SymmQueryConfig;
+}): {
+    pendingIds: number[];
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.PendingIdsResponse, Error>>;
+};
+
+declare function useSymmPendingInstantOpens(params: {
+    accountAddress?: Address;
+    authToken?: string;
+    chainId?: number;
+    query?: SymmQueryConfig;
+}): {
+    pendingOpens: _pear_protocol_symm_core.PendingInstantOpenItem[];
+    total: number;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.PendingInstantOpensResponse, Error>>;
+};
+
+declare function useSymmTwapOrder(params: {
+    orderId?: string;
+    query?: SymmQueryConfig;
+}): {
+    order: {
+        orderId: string;
+        status: string;
+        twapConfig?: Record<string, unknown>;
+    } | null;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<node_modules__pear_protocol_symm_core_dist_types.TwapOrderResponse, Error>>;
+};
+
 declare function useSymmWs(params: {
     accountAddress?: Address;
     chainId?: number;
@@ -931,6 +1152,9 @@ declare function useSymmPerformanceOverlays(selection: SymmChartSelection): {
 declare const symmKeys: {
     all: readonly ["symm"];
     accounts: (address?: Address, chainId?: number) => readonly ["symm", "accounts", `0x${string}` | undefined, number | undefined];
+    accountsApi: (address?: Address, chainId?: number) => readonly ["symm", "accountsApi", `0x${string}` | undefined, number | undefined];
+    accountsLength: (address?: Address, chainId?: number) => readonly ["symm", "accountsLength", `0x${string}` | undefined, number | undefined];
+    accountsWithPositions: (address?: Address, chainId?: number) => readonly ["symm", "accountsWithPositions", `0x${string}` | undefined, number | undefined];
     accountSummary: (address?: Address, chainId?: number) => readonly ["symm", "accountSummary", `0x${string}` | undefined, number | undefined];
     accountData: (address?: Address, chainId?: number) => readonly ["symm", "accountData", `0x${string}` | undefined, number | undefined];
     signature: (address?: Address, chainId?: number) => readonly ["symm", "signature", `0x${string}` | undefined, number | undefined];
@@ -940,18 +1164,85 @@ declare const symmKeys: {
     openOrders: (address?: Address, chainId?: number) => readonly ["symm", "openOrders", `0x${string}` | undefined, number | undefined];
     tradeHistory: (address?: Address, chainId?: number) => readonly ["symm", "tradeHistory", `0x${string}` | undefined, number | undefined];
     tpslOrders: (address?: Address, chainId?: number) => readonly ["symm", "tpslOrders", `0x${string}` | undefined, number | undefined];
+    tpslOrdersList: (params?: {
+        accountAddress?: Address;
+        mainAddress?: Address;
+        positionId?: string;
+        type?: string;
+        status?: string;
+        chainId?: number;
+    }) => readonly ["symm", "tpslOrders", {
+        accountAddress?: Address;
+        mainAddress?: Address;
+        positionId?: string;
+        type?: string;
+        status?: string;
+        chainId?: number;
+    } | undefined];
     twapOrders: (address?: Address, chainId?: number) => readonly ["symm", "twapOrders", `0x${string}` | undefined, number | undefined];
+    triggerOrders: (params?: {
+        accountAddress?: Address;
+        mainAddress?: Address;
+        status?: string;
+        limit?: number;
+        offset?: number;
+        chainId?: number;
+    }) => readonly ["symm", "triggerOrders", {
+        accountAddress?: Address;
+        mainAddress?: Address;
+        status?: string;
+        limit?: number;
+        offset?: number;
+        chainId?: number;
+    } | undefined];
+    triggerConfig: (orderId?: string) => readonly ["symm", "triggerConfig", string | undefined];
     markets: (chainId?: number, search?: string) => readonly ["symm", "markets", number | undefined, string | undefined];
+    hedgerMarketById: (id?: number, chainId?: number) => readonly ["symm", "hedgerMarketById", number | undefined, number | undefined];
+    hedgerMarketBySymbol: (symbol?: string, chainId?: number) => readonly ["symm", "hedgerMarketBySymbol", string | undefined, number | undefined];
+    lockedParams: (marketName?: string, leverage?: number, chainId?: number) => readonly ["symm", "lockedParams", string | undefined, number | undefined, number | undefined];
     hedgerMarkets: (request?: GetSymmHedgerMarketsRequest) => readonly ["symm", "hedgerMarkets", GetSymmHedgerMarketsRequest | undefined];
     fundingRates: (chainId?: number) => readonly ["symm", "fundingRates", number | undefined];
+    fundingPayments: (params?: {
+        address?: Address;
+        positionId?: string;
+        chainId?: number;
+        limit?: number;
+        offset?: number;
+    }) => readonly ["symm", "fundingPayments", {
+        address?: Address;
+        positionId?: string;
+        chainId?: number;
+        limit?: number;
+        offset?: number;
+    } | undefined];
+    fundingHistory: (params?: {
+        chainId?: number;
+        period?: string;
+        longSymbols?: string;
+        shortSymbols?: string;
+        interval?: string;
+        weightMode?: string;
+        includeContributions?: boolean;
+    }) => readonly ["symm", "fundingHistory", {
+        chainId?: number;
+        period?: string;
+        longSymbols?: string;
+        shortSymbols?: string;
+        interval?: string;
+        weightMode?: string;
+        includeContributions?: boolean;
+    } | undefined];
     portfolio: (address?: Address, chainId?: number) => readonly ["symm", "portfolio", `0x${string}` | undefined, number | undefined];
     notifications: (address?: Address, chainId?: number) => readonly ["symm", "notifications", `0x${string}` | undefined, number | undefined];
     unreadCount: (address?: Address, chainId?: number) => readonly ["symm", "unreadCount", `0x${string}` | undefined, number | undefined];
     availableMargin: (address?: Address, chainId?: number) => readonly ["symm", "availableMargin", `0x${string}` | undefined, number | undefined];
+    pendingIds: (address?: Address, chainId?: number) => readonly ["symm", "pendingIds", `0x${string}` | undefined, number | undefined];
+    pendingInstantOpens: (accountAddress?: Address, chainId?: number) => readonly ["symm", "pendingInstantOpens", `0x${string}` | undefined, number | undefined];
+    twapOrder: (orderId?: string) => readonly ["symm", "twapOrder", string | undefined];
     delegation: (account?: Address, target?: Address, selectors?: readonly Hex[], chainId?: number) => readonly ["symm", "delegation", `0x${string}` | undefined, `0x${string}` | undefined, readonly `0x${string}`[] | undefined, number | undefined];
     chartMetadata: (symbolsKey: string, positionKey: string) => readonly ["symm", "chartMetadata", string, string];
 };
 
 declare function getSymmErrorMessage(error: unknown): string;
 
-export { type SymmChartSelection, type SymmChartSelectionInput, type SymmChartTokenSelection, type SymmContextValue, type SymmDelegationState, type SymmInstantTradeActionArgs, type SymmInstantTradeRequest, type SymmPerformanceOverlay, SymmProvider, type SymmProviderProps, type SymmQueryConfig, type SymmTokenMetadata, type UseSymmChartCandlesReturn, type UseSymmDelegationParams, type UseSymmHedgerMarketsParams, type UseSymmTokenSelectionMetadataReturn, getSymmErrorMessage, symmKeys, useSymmAccountData, useSymmAccountSummary, useSymmAccounts, useSymmApproval, useSymmAuth, useSymmAvailableMargin, useSymmBalances, useSymmChartCandles, useSymmChartSelection, useSymmCollateral, useSymmContext, useSymmCoreClient, useSymmDelegation, useSymmDeposit, useSymmFunding, useSymmHedgerMarkets, useSymmInstantTrade, useSymmMarkets, useSymmNotifications, useSymmOpenOrders, useSymmPerformanceOverlays, useSymmPortfolio, useSymmPositions, useSymmSignature, useSymmTokenSelectionMetadata, useSymmTpsl, useSymmTrade, useSymmTradeHistory, useSymmTwap, useSymmWithdraw, useSymmWs, useSymmioClient };
+export { type SymmChartSelection, type SymmChartSelectionInput, type SymmChartTokenSelection, type SymmContextValue, type SymmDelegationState, type SymmInstantTradeActionArgs, type SymmInstantTradeRequest, type SymmPerformanceOverlay, SymmProvider, type SymmProviderProps, type SymmQueryConfig, type SymmTokenMetadata, type UseSymmChartCandlesReturn, type UseSymmDelegationParams, type UseSymmHedgerMarketsParams, type UseSymmTokenSelectionMetadataReturn, type UseSymmTpslOrdersParams, getSymmErrorMessage, symmKeys, useSymmAccountData, useSymmAccountSummary, useSymmAccounts, useSymmAccountsApi, useSymmAccountsLength, useSymmAccountsWithPositions, useSymmApproval, useSymmAuth, useSymmAvailableMargin, useSymmBalances, useSymmCancelClose, useSymmChartCandles, useSymmChartSelection, useSymmCloseOrder, useSymmCollateral, useSymmContext, useSymmCoreClient, useSymmDelegation, useSymmDeposit, useSymmFunding, useSymmFundingHistory, useSymmFundingPayments, useSymmHedgerMarketById, useSymmHedgerMarketBySymbol, useSymmHedgerMarkets, useSymmInstantTrade, useSymmLockedParams, useSymmMarkets, useSymmNotifications, useSymmOpenOrders, useSymmPendingIds, useSymmPendingInstantOpens, useSymmPerformanceOverlays, useSymmPortfolio, useSymmPositions, useSymmSignature, useSymmTokenSelectionMetadata, useSymmTpsl, useSymmTpslOrders, useSymmTrade, useSymmTradeHistory, useSymmTriggerConfig, useSymmTriggerOrders, useSymmTwap, useSymmTwapOrder, useSymmWithdraw, useSymmWs, useSymmioClient };