pods-sdk 0.2.58

package/dist/hooks/useGroupedStrategies.d.ts

@@ -0,0 +1,4 @@
+import { UseGroupedStrategiesParams, GroupedStrategiesResult } from '../types/grouped-strategies';
+export declare const useGroupedStrategies: ({ positions, strategies, mostUsedSymbols, isLoading, }: UseGroupedStrategiesParams) => GroupedStrategiesResult;
+export default useGroupedStrategies;
+//# sourceMappingURL=useGroupedStrategies.d.ts.map

package/dist/hooks/useGroupedStrategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGroupedStrategies.d.ts","sourceRoot":"","sources":["../../src/hooks/useGroupedStrategies.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAiClG,eAAO,MAAM,oBAAoB,GAAI,wDAKlC,0BAA0B,KAAG,uBA6C/B,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/dist/hooks/useI18n.d.ts

@@ -0,0 +1,12 @@
+import { type DeframeLanguage, type TranslationKey, type TranslationVariables } from '../i18n';
+interface I18nResult {
+    language: DeframeLanguage;
+    locale: string;
+    t: (key: TranslationKey, vars?: TranslationVariables) => string;
+    formatNumber: (value: number, options?: Intl.NumberFormatOptions) => string;
+    formatDate: (value: string | Date, options?: Intl.DateTimeFormatOptions) => string;
+    formatDateTime: (value: string | Date, options?: Intl.DateTimeFormatOptions) => string;
+}
+export declare function useI18n(): I18nResult;
+export {};
+//# sourceMappingURL=useI18n.d.ts.map

package/dist/hooks/useI18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useI18n.d.ts","sourceRoot":"","sources":["../../src/hooks/useI18n.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EAC1B,MAAM,SAAS,CAAC;AAEjB,UAAU,UAAU;IAClB,QAAQ,EAAE,eAAe,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,oBAAoB,KAAK,MAAM,CAAC;IAChE,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,KAAK,MAAM,CAAC;IAC5E,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,qBAAqB,KAAK,MAAM,CAAC;IACnF,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,qBAAqB,KAAK,MAAM,CAAC;CACxF;AAED,wBAAgB,OAAO,IAAI,UAAU,CA2DpC"}

package/dist/hooks/useStrategyTokens.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Hook to fetch strategy token addresses from GET /strategies/tokens
+ * Returns a Set of token addresses for blacklisting in swap
+ *
+ * @returns React Query hook result with token addresses as a Set
+ *
+ * @example
+ * const { tokenAddresses, isLoading, error } = useStrategyTokens();
+ */
+export declare const useStrategyTokens: () => {
+    tokenAddresses: Set<string>;
+    isLoading: boolean;
+    error: Error | undefined;
+};
+//# sourceMappingURL=useStrategyTokens.d.ts.map

package/dist/hooks/useStrategyTokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStrategyTokens.d.ts","sourceRoot":"","sources":["../../src/hooks/useStrategyTokens.ts"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;;CAuB7B,CAAC"}

package/dist/hooks/useSwapFlowLogic.d.ts

@@ -0,0 +1,198 @@
+import React from 'react';
+import { z } from 'zod';
+import { IngestActionRequest } from '../api/actions.api';
+declare const swapSchema: z.ZodObject<{
+    amountHumanized: z.ZodOptional<z.ZodString>;
+    fromTokenAddress: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    toTokenAddress: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    fromChainId: z.ZodNumber;
+    toChainId: z.ZodNumber;
+    slippageBps: z.ZodNumber;
+}, z.core.$strip>;
+export type SwapFormValues = z.infer<typeof swapSchema>;
+type SwapSelectorSide = 'from' | 'to';
+export interface UseSwapFlowLogicProps {
+    initialFromTokenAddress?: string;
+    initialFromChainId?: number;
+    initialToTokenAddress?: string;
+    initialToChainId?: number;
+}
+export declare function useSwapFlowLogic(props: UseSwapFlowLogicProps): {
+    formMethods: import("react-hook-form").UseFormReturn<{
+        fromChainId: number;
+        toChainId: number;
+        slippageBps: number;
+        amountHumanized?: string | undefined;
+        fromTokenAddress?: string | undefined;
+        toTokenAddress?: string | undefined;
+    }, any, {
+        fromChainId: number;
+        toChainId: number;
+        slippageBps: number;
+        amountHumanized?: string | undefined;
+        fromTokenAddress?: string | undefined;
+        toTokenAddress?: string | undefined;
+    }>;
+    formRef: React.RefObject<HTMLFormElement | null>;
+    submitForm: () => void;
+    handleSubmit: import("react-hook-form").UseFormHandleSubmit<{
+        fromChainId: number;
+        toChainId: number;
+        slippageBps: number;
+        amountHumanized?: string | undefined;
+        fromTokenAddress?: string | undefined;
+        toTokenAddress?: string | undefined;
+    }, {
+        fromChainId: number;
+        toChainId: number;
+        slippageBps: number;
+        amountHumanized?: string | undefined;
+        fromTokenAddress?: string | undefined;
+        toTokenAddress?: string | undefined;
+    }>;
+    formValues: {
+        fromChainId: number;
+        toChainId: number;
+        slippageBps: number;
+        amountHumanized?: string | undefined;
+        fromTokenAddress?: string | undefined;
+        toTokenAddress?: string | undefined;
+    };
+    fromToken: import("../domain").TokenData | undefined;
+    toToken: import("../domain").TokenData | undefined;
+    fromTokenBalance: import("..").BalanceDomain | undefined;
+    toTokenBalance: import("..").BalanceDomain | undefined;
+    quoteOutputUI: string;
+    quoteOutputUSD: string;
+    amountInUsd: string;
+    slippageFormatted: string;
+    swapQuote: import("../types/api").SwapQuoteResponse;
+    swapBytecode: import("../types/api").SwapBytecodeResponse;
+    isTxProcessing: boolean;
+    isTxSuccess: boolean;
+    isSignatureError: boolean;
+    isTxError: boolean;
+    currentClientTxId: string | null;
+    isCrossChainSwap: boolean;
+    crossChainDestinationConfirmed: boolean;
+    isConfigOpen: boolean;
+    setIsConfigOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    handleAssetSelected: (side: SwapSelectorSide, token: {
+        address: string;
+        chainId: number;
+        decimals: number;
+    }) => void;
+    handleNetworkSelected: (side: SwapSelectorSide, chainId: string) => void;
+    handlePercentageClick: (basisPoints: number) => void;
+    handleSwitchSides: () => void;
+    handleFormSubmit: (values: SwapFormValues) => void;
+    handleQuoteExpire: () => void;
+    availableChainsForFromToken: number[];
+    availableChainsForToToken: number[];
+    onRouteChangeRequest: (params: {
+        route: string;
+        params?: Record<string, string>;
+    }) => void;
+    dispatch: import("@reduxjs/toolkit").ThunkDispatch<{
+        config: import("../state").ConfigState;
+        connection: import("../state").ConnectionState;
+        ui: import("../state/features/ui").UiState;
+        portfolio: import("../state").PortfolioState;
+        tx: import("@reduxjs/toolkit").EntityState<import("../state").TxInfo, string>;
+        strategies: import("../state/features/strategies/slice").StrategiesState;
+        history: import("../state/features/history").HistoryState;
+        strategiesApi: import("@reduxjs/toolkit/query").CombinedState<{
+            getStrategies: import("@reduxjs/toolkit/query").QueryDefinition<void | {
+                page?: number;
+                limit?: number;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Strategy" | "StrategyDetail" | "Bytecode", import("..").StrategiesResponse, "strategiesApi", unknown>;
+            getStrategyById: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Strategy" | "StrategyDetail" | "Bytecode", import("../types/api").StrategyWithoutWalletData, "strategiesApi", unknown>;
+            getStrategyWithWallet: import("@reduxjs/toolkit/query").QueryDefinition<{
+                id: string;
+                wallet: string;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Strategy" | "StrategyDetail" | "Bytecode", import("..").StrategyWithWalletData, "strategiesApi", unknown>;
+            getStrategyTokens: import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Strategy" | "StrategyDetail" | "Bytecode", Record<string, string>, "strategiesApi", unknown>;
+        }, "Strategy" | "StrategyDetail" | "Bytecode", "strategiesApi">;
+        portfolioApi: import("@reduxjs/toolkit/query").CombinedState<{
+            getWalletPositions: import("@reduxjs/toolkit/query").QueryDefinition<{
+                wallet: string;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Portfolio", import("..").WalletPositionsResponse, "portfolioApi", unknown>;
+        }, "Portfolio", "portfolioApi">;
+        balancesApi: import("@reduxjs/toolkit/query").CombinedState<{
+            getBalances: import("@reduxjs/toolkit/query").QueryDefinition<import("../api/balances.api").GetBalancesParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Balances", import("..").WalletBalancesDomain, "balancesApi", unknown>;
+        }, "Balances", "balancesApi">;
+        bytecodeApi: import("@reduxjs/toolkit/query").CombinedState<{
+            getStrategyBytecodeDirect: import("@reduxjs/toolkit/query").QueryDefinition<{
+                id: string;
+            } & import("..").GetBytecodeParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Bytecode", import("..").BytecodeResponse, "bytecodeApi", unknown>;
+            getStrategyBytecodeSameChain: import("@reduxjs/toolkit/query").QueryDefinition<{
+                id: string;
+            } & import("..").GetBytecodeParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Bytecode", import("..").BytecodeResponse, "bytecodeApi", unknown>;
+            getStrategyBytecodeCrossChain: import("@reduxjs/toolkit/query").QueryDefinition<{
+                id: string;
+            } & import("..").GetBytecodeParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Bytecode", import("..").BytecodeResponse, "bytecodeApi", unknown>;
+        }, "Bytecode", "bytecodeApi">;
+        swapApi: import("@reduxjs/toolkit/query").CombinedState<{
+            getSwapQuote: import("@reduxjs/toolkit/query").QueryDefinition<import("../api/swap.api").GetSwapQuoteParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Swap", import("../types/api").SwapQuoteResponse, "swapApi", unknown>;
+            getSwapBytecode: import("@reduxjs/toolkit/query").QueryDefinition<import("../api/swap.api").GetSwapBytecodeParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Swap", import("../types/api").SwapBytecodeResponse, "swapApi", unknown>;
+        }, "Swap", "swapApi">;
+        actionsApi: import("@reduxjs/toolkit/query").CombinedState<{
+            ingestAction: import("@reduxjs/toolkit/query").MutationDefinition<IngestActionRequest, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, never, import("../api/actions.api").IngestActionResponse, "actionsApi", unknown>;
+            getActionById: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, never, import("../api/actions.api").ActionResponse, "actionsApi", unknown>;
+        }, never, "actionsApi">;
+        tokensApi: import("@reduxjs/toolkit/query").CombinedState<{
+            getTokenByAddress: import("@reduxjs/toolkit/query").QueryDefinition<{
+                address: string;
+                chainId: number;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Token" | "TokenGroups", import("../api/tokens.api").TokenWithPrice | null, "tokensApi", unknown>;
+            getTokensByAddresses: import("@reduxjs/toolkit/query").QueryDefinition<import("../api/tokens.api").GetTokensByAddressesParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Token" | "TokenGroups", import("../api/tokens.api").TokenWithPrice[], "tokensApi", unknown>;
+            getTokens: import("@reduxjs/toolkit/query").QueryDefinition<import("../api/tokens.api").GetTokensParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Token" | "TokenGroups", import("../api/tokens.api").TokensResponse, "tokensApi", unknown>;
+            getTokenGroups: import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, "Token" | "TokenGroups", import("../types/tokengroups").TokenGroupsData, "tokensApi", unknown>;
+        }, "Token" | "TokenGroups", "tokensApi">;
+        historyApi: import("@reduxjs/toolkit/query").CombinedState<{
+            getHistory: import("@reduxjs/toolkit/query").QueryDefinition<{
+                wallet: string;
+                page?: number;
+                limit?: number;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError & {
+                code?: string;
+            }>, never, import("../api/history.api").HistoryResponse, "historyApi", unknown>;
+        }, never, "historyApi">;
+    }, undefined, import("@reduxjs/toolkit").UnknownAction> & import("@reduxjs/toolkit").Dispatch<import("@reduxjs/toolkit").UnknownAction>;
+};
+export {};
+//# sourceMappingURL=useSwapFlowLogic.d.ts.map

package/dist/hooks/useSwapFlowLogic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSwapFlowLogic.d.ts","sourceRoot":"","sources":["../../src/hooks/useSwapFlowLogic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB,OAAO,EAAE,mBAAmB,EAAsD,MAAM,oBAAoB,CAAC;AAe7G,QAAA,MAAM,UAAU;;;;;;;iBAOd,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAExD,KAAK,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAAC;AAEtC,MAAM,WAAW,qBAAqB;IACpC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAMD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAmLxB,gBAAgB,SAAS;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE;kCAa7E,gBAAgB,WAAW,MAAM;yCAoB1B,MAAM;;+BAqFhB,cAAc;;;;;;cAzJlC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwahB"}

package/dist/hooks/useTokenGroups.d.ts

@@ -0,0 +1,14 @@
+import { TokenGroup } from '../types/tokengroups';
+interface UseTokenGroupsResult {
+    tokenGroups: TokenGroup[];
+    mostUsedSymbols: string[];
+    isLoading: boolean;
+    isError: boolean;
+}
+/**
+ * Hook to fetch and access token groups for token prioritization.
+ * Resolves token ObjectIds to symbols for use in sorting.
+ */
+export declare const useTokenGroups: () => UseTokenGroupsResult;
+export {};
+//# sourceMappingURL=useTokenGroups.d.ts.map

package/dist/hooks/useTokenGroups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTokenGroups.d.ts","sourceRoot":"","sources":["../../src/hooks/useTokenGroups.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAGlD,UAAU,oBAAoB;IAC5B,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAO,oBA4BjC,CAAC"}

package/dist/i18n/index.d.ts

@@ -0,0 +1,13 @@
+import { DEFAULT_LANGUAGE, LANGUAGE_TO_LOCALE, MESSAGES_BY_LANGUAGE, type DeframeLanguage, type DeframeLocale, type TranslationKey } from './messages';
+export type TranslationVariables = Record<string, string | number | null | undefined>;
+export type TranslationOverrides = Partial<Record<DeframeLanguage, Partial<Record<TranslationKey, string>>>>;
+export interface TranslateOptions {
+    language?: DeframeLanguage;
+    overrides?: TranslationOverrides;
+    vars?: TranslationVariables;
+}
+export declare function resolveLocale(language?: DeframeLanguage): DeframeLocale;
+export declare function translate(key: TranslationKey, options?: TranslateOptions): string;
+export type { DeframeLanguage, DeframeLocale, TranslationKey };
+export { DEFAULT_LANGUAGE, LANGUAGE_TO_LOCALE, MESSAGES_BY_LANGUAGE };
+//# sourceMappingURL=index.d.ts.map

package/dist/i18n/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/i18n/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;AAEtF,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACxC,MAAM,CAAC,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC,CACjE,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,SAAS,CAAC,EAAE,oBAAoB,CAAC;IACjC,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B;AAYD,wBAAgB,aAAa,CAAC,QAAQ,CAAC,EAAE,eAAe,GAAG,aAAa,CAEvE;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAMjF;AAED,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,cAAc,EAAE,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/i18n/messages.d.ts

@@ -0,0 +1,307 @@
+export type DeframeLanguage = 'PT' | 'EN';
+export type DeframeLocale = 'pt-BR' | 'en-US';
+export declare const DEFAULT_LANGUAGE: DeframeLanguage;
+export declare const LANGUAGE_TO_LOCALE: Record<DeframeLanguage, DeframeLocale>;
+export declare const ptMessages: {
+    readonly 'common.back': "Voltar";
+    readonly 'common.close': "Fechar";
+    readonly 'common.retry': "Tentar novamente";
+    readonly 'common.load_more': "Carregar mais";
+    readonly 'common.view_all': "Ver todas";
+    readonly 'common.details': "Detalhes";
+    readonly 'common.transaction_details': "Detalhes da transação";
+    readonly 'common.status': "Status";
+    readonly 'common.date': "Data";
+    readonly 'common.transaction': "Transação";
+    readonly 'common.transaction_id': "ID da transação";
+    readonly 'common.search': "Buscar";
+    readonly 'common.search_try_another_term': "Tente outro termo de busca";
+    readonly 'common.error': "Erro";
+    readonly 'common.loading': "Carregando";
+    readonly 'common.loading_tokens': "Carregando tokens";
+    readonly 'common.searching_tokens': "Buscando tokens";
+    readonly 'common.processing': "Processando";
+    readonly 'common.success': "Sucesso!";
+    readonly 'common.not_available': "Indisponível";
+    readonly 'common.expand': "Expandir";
+    readonly 'common.collapse': "Recolher";
+    readonly 'common.max': "Max";
+    readonly 'common.explore_more': "Explorar mais";
+    readonly 'common.activity_history': "Histórico de atividades";
+    readonly 'common.select_token': "Selecionar token";
+    readonly 'common.select_network': "Selecionar rede";
+    readonly 'common.cancel': "Cancelar";
+    readonly 'common.completed': "Completo";
+    readonly 'common.failed': "Falhou";
+    readonly 'common.awaiting': "Aguardando";
+    readonly 'common.processing_ellipsis': "Processando...";
+    readonly 'common.not_started': "Não iniciado...";
+    readonly 'common.confirming': "Confirmando";
+    readonly 'common.estimated_time': "Tempo estimado";
+    readonly 'common.view_on_explorer': "Ver no Explorer";
+    readonly 'common.view_history': "Ver histórico";
+    readonly 'common.apy': "APY";
+    readonly 'common.seconds_short': "s";
+    readonly 'widget.earn.tab.overview': "Visão Geral";
+    readonly 'widget.earn.tab.explore': "Explorar";
+    readonly 'widget.earn.tab.history': "Histórico";
+    readonly 'widget.earn.total_invested': "Total investido";
+    readonly 'widget.earn.earnings': "Ganhos";
+    readonly 'widget.earn.total_return': "Total de retorno";
+    readonly 'widget.earn.where_you_invest': "Onde você já investe";
+    readonly 'widget.earn.best_performance': "Melhores performances";
+    readonly 'widget.earn.all_strategies': "Todas as estratégias";
+    readonly 'widget.earn.recent_transactions': "Transações recentes";
+    readonly 'widget.earn.investment_info': "Informações do Investimento";
+    readonly 'widget.earn.past_activities': "Atividades passadas";
+    readonly 'widget.earn.your_investments': "Seus Investimentos";
+    readonly 'widget.earn.overview_description': "Visão geral dos seus investimentos";
+    readonly 'widget.earn.absolute_yield': "Rendimento absoluto";
+    readonly 'widget.earn.avg_annual_returns': "Retornos anuais médios";
+    readonly 'widget.earn.last_investment': "Último investimento";
+    readonly 'widget.earn.explore_strategies': "Explore as estratégias";
+    readonly 'widget.earn.avg_apy': "APY médio";
+    readonly 'widget.swap.title': "Trocar ativos";
+    readonly 'widget.swap.subtitle': "Selecione tokens, redes e um valor para iniciar a troca";
+    readonly 'widget.swap.history_aria': "Histórico";
+    readonly 'widget.swap.history_not_available_title': "Histórico não disponível";
+    readonly 'widget.swap.history_not_available_description': "Este SwapWidget não possui uma tela de histórico/overview. Você pode voltar para a troca ou usar o histórico do app host.";
+    readonly 'widget.swap.back_to_swap': "Voltar para a troca";
+    readonly 'widget.swap.switch_tokens_aria': "Trocar tokens";
+    readonly 'widget.swap.amount_to_swap_aria': "Valor para troca";
+    readonly 'empty.history.title': "Nenhuma transação ainda";
+    readonly 'empty.history.description': "Assim que você começar a movimentar fundos, seu histórico de transações aparecerá aqui.";
+    readonly 'empty.search.title': "Nenhum resultado";
+    readonly 'actionsheet.choose_network': "Escolha uma rede";
+    readonly 'actionsheet.choose_asset': "Escolha um ativo";
+    readonly 'actionsheet.choose_withdraw_asset': "Escolha como quer sacar";
+    readonly 'actionsheet.search_by_name': "Pesquisar por nome";
+    readonly 'actionsheet.withdraw_receive_currency': "Selecione a moeda que você quer receber";
+    readonly 'history.deposit': "Depósito {{symbol}}";
+    readonly 'history.withdraw': "Retirada {{symbol}}";
+    readonly 'history.swap': "Swap {{symbolIn}} → {{symbolOut}}";
+    readonly 'history.swap_short': "Troca";
+    readonly 'history.investment': "Investimento";
+    readonly 'history.on_network': "Na rede {{network}}";
+    readonly 'history.transaction_not_found': "Transação não encontrada";
+    readonly 'history.details_unavailable': "Detalhes indisponíveis";
+    readonly 'history.you_sent': "Você enviou";
+    readonly 'history.you_received': "Você recebeu";
+    readonly 'history.currency': "Moeda";
+    readonly 'history.total_amount': "Valor total";
+    readonly 'history.operation_cost': "Custo de operação";
+    readonly 'history.operation_cost_sponsored': "Patrocinado pela Cryptocontrol";
+    readonly 'history.protocol': "Protocolo";
+    readonly 'history.view_on_explorer': "Ver no explorer";
+    readonly 'history.status_success': "Sucesso";
+    readonly 'history.status_failed': "Falhou";
+    readonly 'history.status_pending': "Pendente";
+    readonly 'history.investment_deposit': "Investimento - Depósito";
+    readonly 'history.investment_withdraw': "Investimento - Retirada";
+    readonly 'history.route': "Rota";
+    readonly 'history.network': "Rede";
+    readonly 'strategy.not_found': "Estratégia não encontrada";
+    readonly 'strategy.creation_date': "Data de criação";
+    readonly 'strategy.risk': "Risco";
+    readonly 'strategy.volatility': "Volatilidade";
+    readonly 'strategy.liquidity': "Liquidez";
+    readonly 'strategy.liquidity_immediate': "Imediato";
+    readonly 'strategy.info': "Informações da Estratégia";
+    readonly 'strategy.deposit': "Depósito";
+    readonly 'strategy.withdraw': "Sacar";
+    readonly 'strategy.withdraw_title': "Sacar";
+    readonly 'strategy.deposit_title': "Depósito";
+    readonly 'strategy.crosschain_withdraw_not_supported': "Saques entre redes ainda não são suportados";
+    readonly 'strategy.crosschain_deposit_not_supported': "Depósitos entre redes ainda não são suportados";
+    readonly 'strategy.transaction_error': "Erro na transação";
+    readonly 'strategy.yield': "Rendimento {{assetName}}";
+    readonly 'strategy.choose_amount_before_withdraw': "Escolha o valor e confirme os detalhes antes de sacar";
+    readonly 'strategy.choose_amount_before_deposit': "Escolha o valor e confirme os detalhes antes de depositar";
+    readonly 'strategy.deposit_completed': "Depósito concluído {{txHash}}";
+    readonly 'strategy.withdraw_from_vault': "Sacar do Cofre";
+    readonly 'strategy.pay_on': "Pagar em";
+    readonly 'strategy.receive_on': "Receber em";
+    readonly 'strategy.total_available': "Total disponível";
+    readonly 'strategy.no_balance_swap_prompt': "Ops, parece que você não tem saldo nesse token, gostaria de fazer um swap?";
+    readonly 'strategy.go_to_swap': "Ir para Swap";
+    readonly 'strategy.withdraw_completed': "Saque concluído {{txHash}}";
+    readonly 'strategy.you_will_burn': "Você vai queimar";
+    readonly 'strategy.shares': "ações";
+    readonly 'strategy.you_will_receive_estimated': "Receberá (estimado):";
+    readonly 'strategy.total_fees': "Taxas totais";
+    readonly 'strategy.estimated_time': "Tempo estimado";
+    readonly 'badge.low_risk': "Baixo Risco";
+    readonly 'badge.medium_risk': "Médio Risco";
+    readonly 'badge.high_risk': "Alto Risco";
+    readonly 'tx_screen.confirm_withdraw': "Confirmar saque";
+    readonly 'tx_screen.confirm_deposit': "Confirmar depósito";
+    readonly 'tx_screen.withdraw_in_progress': "Saque em andamento";
+    readonly 'tx_screen.deposit_in_progress': "Depósito em andamento";
+    readonly 'tx_screen.swap_in_progress': "Troca em andamento";
+    readonly 'tx_screen.details': "Detalhes";
+    readonly 'tx_screen.amount': "Valor";
+    readonly 'tx_screen.deposit_processing_description_prefix': "Você já pode ver este investimento no";
+    readonly 'tx_screen.withdraw_processing_description_prefix': "Você já pode acompanhar esta transação. Confira o";
+    readonly 'tx_screen.withdraw_processing_description_suffix': "para detalhes";
+    readonly 'tx_screen.swap_processing_description_prefix': "Você pode acompanhar esta transação no";
+    readonly 'tx_screen.deposit_success_description_prefix': "Você depositou";
+    readonly 'tx_screen.deposit_success_description_suffix': "e agora você pode ver este investimento";
+    readonly 'tx_screen.deposit_success_description_link': "na sua conta.";
+    readonly 'tx_screen.withdraw_success_description_prefix': "Você sacou";
+    readonly 'tx_screen.withdraw_success_description_suffix': "os fundos foram entregues para sua";
+    readonly 'tx_screen.withdraw_success_description_link': "carteira.";
+    readonly 'tx_screen.swap_success_description_prefix': "Você trocou";
+    readonly 'tx_screen.swap_success_description_middle': "por";
+    readonly 'tx_screen.swap_success_description_suffix': "e agora você pode ver esta transação";
+    readonly 'tx_screen.swap_success_description_link': "na sua carteira.";
+    readonly 'tx_screen.start_new_swap': "Iniciar nova troca";
+    readonly 'tx_screen.crosschain_finalizing_title': "Finalizando troca cross-chain";
+    readonly 'tx_screen.crosschain_waiting_destination_title': "Aguardando confirmação na rede de destino";
+    readonly 'tx_screen.crosschain_confirming_origin_title': "Confirmando transação na rede de origem";
+    readonly 'tx_screen.crosschain_finalizing_description': "A última confirmação está sendo processada. Isso pode levar alguns instantes.";
+    readonly 'tx_screen.crosschain_confirmed_origin_description': "A transação foi confirmada em {{origin}}. Agora estamos aguardando a confirmação em {{destination}}.";
+    readonly 'tx_screen.crosschain_confirming_origin_description': "Estamos confirmando sua transação em {{origin}}.";
+    readonly 'tx_screen.crosschain_view_history': "Ver histórico";
+    readonly 'tx_step.approve_token': "Aprovar {{symbol}}";
+    readonly 'tx_step.sending_funds': "Enviando fundos";
+    readonly 'tx_step.deposit_to_vault': "Depositar no Cofre";
+    readonly 'tx_step.withdraw_completed': "Retirada concluída";
+    readonly 'tx_step.bridge_transaction': "Transação ponte";
+    readonly 'tx_step.complete_swap': "Completar troca";
+    readonly 'tx_step.signature_pending': "Assinatura pendente";
+    readonly 'tx_step.failed_on_blockchain': "Falhou na blockchain";
+    readonly 'tx_step.confirm_on_chain': "Confirmar em {{chain}}";
+    readonly 'tx_step.process_bridge': "Processar ponte";
+    readonly 'tx_detail.bridge': "Ponte";
+    readonly 'tx_detail.sender': "Remetente";
+    readonly 'tx_detail.from_network': "Da rede";
+    readonly 'tx_detail.to_network': "Para rede";
+    readonly 'tx_detail.from_token': "Token de origem";
+    readonly 'tx_detail.input_amount': "Valor de entrada";
+    readonly 'tx_detail.estimated_output': "Saída estimada";
+    readonly 'tx_detail.minimum_output': "Saída mínima";
+    readonly 'swap.settings': "Configurações";
+    readonly 'swap.exchange_rate': "Taxa de câmbio";
+    readonly 'swap.blockchain_costs': "Custos da blockchain";
+    readonly 'swap.network_gas': "Gas da rede";
+    readonly 'swap.protocol_fee': "Taxa do protocolo";
+    readonly 'swap.quote_error': "Falha ao buscar cotação. Por favor, tente novamente.";
+    readonly 'swap.bytecode_error': "Falha ao preparar a transação. Por favor, tente novamente.";
+    readonly 'swap.searching_quote': "Buscando";
+    readonly 'swap.loading_quote': "Carregando cotação...";
+    readonly 'swap.quote_id': "Quote ID";
+    readonly 'swap.slippage': "Slippage";
+    readonly 'swap.eta': "ETA";
+    readonly 'swap.eta_cross_chain': "5 minutos";
+    readonly 'swap.eta_same_chain': "5 segundos";
+    readonly 'swap.balance': "Saldo";
+    readonly 'swap.processing_transaction': "Processando transação";
+    readonly 'swap.preparing_transaction': "Preparando transação";
+    readonly 'swap.preparing_swap': "Preparando troca";
+    readonly 'swap.to_label': "Para";
+    readonly 'swap.slippage_tolerance': "Tolerância de slippage";
+    readonly 'swap.slippage_max_variation': "máx. {{slippage}} de variação";
+    readonly 'search.placeholder_strategies_assets': "Pesquisar estratégias ou ativos";
+    readonly 'error.generic.title': "Algo está errado do nosso lado";
+    readonly 'error.generic.description': "Estamos com problemas para carregar os dados de Earn agora. Nossa equipe está trabalhando nisso — verifique status.deframe.com para atualizações.";
+    readonly 'error.generic.description_prefix': "Estamos com problemas para carregar os dados de Earn agora. Nossa equipe está trabalhando nisso — verifique";
+    readonly 'error.generic.description_suffix': "para atualizações.";
+    readonly 'validation.PROCESSING': "Processando";
+    readonly 'validation.NO_WALLET': "Conectar carteira";
+    readonly 'validation.NO_STRATEGY': "Selecionar estratégia";
+    readonly 'validation.NO_TOKEN': "Selecionar ativo";
+    readonly 'validation.NO_CHAIN': "Selecionar rede";
+    readonly 'validation.NO_AMOUNT': "Inserir valor";
+    readonly 'validation.AMOUNT_BELOW_MINIMUM': "Valor mínimo {{amount}}";
+    readonly 'validation.INVALID_AMOUNT': "Valor inválido";
+    readonly 'validation.INVALID_TOKEN': "Endereço do token inválido";
+    readonly 'validation.INVALID_TO_TOKEN': "Selecione um ativo de destino";
+    readonly 'validation.INVALID_FROM_TOKEN': "Token de origem inválido";
+    readonly 'validation.INVALID_CHAIN': "Chain ID inválido";
+    readonly 'validation.CHAIN_MISMATCH': "Trocar para a rede correta";
+    readonly 'validation.INSUFFICIENT_BALANCE': "Saldo insuficiente";
+    readonly 'validation.QUOTE_ERROR': "Erro ao obter cotação";
+    readonly 'validation.FETCHING_QUOTE': "Buscando quote";
+    readonly 'validation.NO_QUOTE': "Calculando";
+    readonly 'validation.VALID_DEPOSIT': "Depósito";
+    readonly 'validation.VALID_WITHDRAW': "Sacar";
+    readonly 'validation.VALID_SWAP': "Trocar";
+    readonly 'tx_status.BUILDING_BYTECODE': "Construindo transação";
+    readonly 'tx_status.BYTECODE_READY': "Bytecode preparado";
+    readonly 'tx_status.BYTECODE_SENT_HOST': "Enviado para o aplicativo pai";
+    readonly 'tx_status.HOST_ACK': "Aplicativo pai confirmou";
+    readonly 'tx_status.WAITING_HOST_SIGNATURE': "Aguardando assinatura da carteira";
+    readonly 'tx_status.TX_SUBMITTED': "Enviado para a rede";
+    readonly 'tx_status.CONFIRMED': "Confirmado na blockchain";
+    readonly 'tx_status.FINALIZED': "Finalizado";
+    readonly 'tx_status.SIGNATURE_DECLINED': "Assinatura recusada";
+    readonly 'tx_status.SIGNATURE_ERROR': "Erro na assinatura";
+    readonly 'tx_status.TX_DROPPED': "Transação descartada";
+    readonly 'tx_status.ONCHAIN_REVERTED': "Revertido na blockchain";
+    readonly 'tx_status.TIMEOUT': "Tempo esgotado";
+    readonly 'tx_status.SIGNED': "Assinado";
+    readonly 'tx_status.WAITING_HOST_PROPAGATION': "Aguardando propagação do host";
+    readonly 'tx_status.TX_REPLACED': "Transação substituída";
+    readonly 'tx_error.UNKNOWN.title': "Transação falhou";
+    readonly 'tx_error.UNKNOWN.description': "Um erro inesperado ocorreu. Por favor, tente novamente.";
+    readonly 'tx_error.NETWORK_ERROR.title': "Erro de rede";
+    readonly 'tx_error.NETWORK_ERROR.description': "Ocorreu um erro de rede. Por favor, verifique sua conexão e tente novamente.";
+    readonly 'tx_error.TIMEOUT.title': "Tempo esgotado";
+    readonly 'tx_error.TIMEOUT.description': "A transação demorou muito para confirmar. Por favor, tente novamente.";
+    readonly 'tx_error.USER_REJECTED.title': "Assinatura recusada";
+    readonly 'tx_error.USER_REJECTED.description': "Você recusou a transação na sua carteira. Por favor, tente novamente para prosseguir.";
+    readonly 'tx_error.SIGNATURE_DECLINED.title': "Assinatura recusada";
+    readonly 'tx_error.SIGNATURE_DECLINED.description': "Você recusou a transação na sua carteira. Por favor, tente novamente para prosseguir.";
+    readonly 'tx_error.SIGNATURE_NOT_COMPLETED.title': "Assinatura não concluída";
+    readonly 'tx_error.SIGNATURE_NOT_COMPLETED.description': "Você não confirmou a transação na sua carteira. Por favor, tente novamente para prosseguir.";
+    readonly 'tx_error.CHAIN_MISMATCH.title': "Rede incorreta";
+    readonly 'tx_error.CHAIN_MISMATCH.description': "Por favor, mude para a rede correta na sua carteira e tente novamente.";
+    readonly 'tx_error.CHAIN_MISMATCH.description_with_chain': "Por favor, mude para a rede {{chainName}} na sua carteira e tente novamente.";
+    readonly 'tx_error.WALLET_DISCONNECTED.title': "Carteira não conectada";
+    readonly 'tx_error.WALLET_DISCONNECTED.description': "Por favor, conecte sua carteira e tente novamente.";
+    readonly 'tx_error.INSUFFICIENT_FUNDS.title': "Fundos insuficientes";
+    readonly 'tx_error.INSUFFICIENT_FUNDS.description': "Você não tem saldo suficiente para completar esta transação.";
+    readonly 'tx_error.TX_DROPPED.title': "Transação descartada";
+    readonly 'tx_error.TX_DROPPED.description': "A transação foi descartada do mempool. Isso pode acontecer devido a congestionamento da rede ou se foi substituída.";
+    readonly 'tx_error.ONCHAIN_REVERTED.title': "Transação revertida";
+    readonly 'tx_error.ONCHAIN_REVERTED.description': "A transação foi revertida na cadeia. Isso pode ser devido a gás insuficiente, slippage ou condições do contrato.";
+    readonly 'tx_error.TX_REPLACED.title': "Transação substituída";
+    readonly 'tx_error.TX_REPLACED.description': "A transação foi substituída por uma nova. Por favor, verifique o status da última transação.";
+    readonly 'tx_error.RPC_ERROR.title': "Erro de transação";
+    readonly 'tx_error.RPC_ERROR.description': "Ocorreu um erro na transação. Por favor, tente novamente.";
+    readonly 'tx_error.QUOTE_FAILED.title': "Cotação falhou";
+    readonly 'tx_error.QUOTE_FAILED.description': "Não foi possível obter uma cotação para esta transação. Por favor, tente novamente ou ajuste o valor.";
+    readonly 'tx_error.BACKEND_UNAVAILABLE.title': "Serviço indisponível";
+    readonly 'tx_error.BACKEND_UNAVAILABLE.description': "O serviço está temporariamente indisponível. Por favor, tente novamente em alguns instantes.";
+    readonly 'tx_error.HTTP_400.title': "Requisição inválida";
+    readonly 'tx_error.HTTP_400.description': "Os dados enviados são inválidos. Por favor, verifique os valores e tente novamente.";
+    readonly 'tx_error.HTTP_401.title': "Não autorizado";
+    readonly 'tx_error.HTTP_401.description': "Sua sessão expirou. Por favor, reconecte sua carteira e tente novamente.";
+    readonly 'tx_error.HTTP_403.title': "Acesso negado";
+    readonly 'tx_error.HTTP_403.description': "Você não tem permissão para realizar esta ação.";
+    readonly 'tx_error.HTTP_404.title': "Recurso não encontrado";
+    readonly 'tx_error.HTTP_404.description': "O recurso solicitado não foi encontrado. Por favor, tente novamente.";
+    readonly 'tx_error.HTTP_422.title': "Não foi possível processar";
+    readonly 'tx_error.HTTP_422.description': "O valor mínimo precisa ser 2 dólares. Por favor, tente novamente.";
+    readonly 'tx_error.HTTP_429.title': "Muitas requisições";
+    readonly 'tx_error.HTTP_429.description': "Você fez muitas requisições. Por favor, aguarde um momento e tente novamente.";
+    readonly 'tx_error.HTTP_500.title': "Erro no servidor";
+    readonly 'tx_error.HTTP_500.description': "Ocorreu um erro interno no servidor. Nossa equipe foi notificada. Por favor, tente novamente em alguns instantes.";
+    readonly 'tx_error.HTTP_502.title': "Serviço indisponível";
+    readonly 'tx_error.HTTP_502.description': "O servidor está temporariamente indisponível. Por favor, tente novamente em alguns instantes.";
+    readonly 'tx_error.HTTP_503.title': "Serviço em manutenção";
+    readonly 'tx_error.HTTP_503.description': "O serviço está em manutenção. Por favor, tente novamente em alguns instantes.";
+    readonly 'tx_error.HTTP_504.title': "Tempo de resposta esgotado";
+    readonly 'tx_error.HTTP_504.description': "O servidor demorou muito para responder. Por favor, tente novamente.";
+    readonly 'strategy_category.all': "Todas";
+    readonly 'strategy_category.stablecoin': "Stablecoins";
+    readonly 'strategy_category.staking': "Crypto";
+    readonly 'strategy_category.btc': "BTC";
+    readonly 'strategy_category.rwa': "RWA";
+};
+export type TranslationKey = keyof typeof ptMessages;
+export declare const enMessages: {
+    [K in TranslationKey]: string;
+};
+export declare const MESSAGES_BY_LANGUAGE: Record<DeframeLanguage, Record<TranslationKey, string>>;
+//# sourceMappingURL=messages.d.ts.map

package/dist/i18n/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/i18n/messages.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG,IAAI,GAAG,IAAI,CAAC;AAE1C,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,OAAO,CAAC;AAE9C,eAAO,MAAM,gBAAgB,EAAE,eAAsB,CAAC;AAEtD,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAGrE,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyTb,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,UAAU,CAAC;AAErD,eAAO,MAAM,UAAU,EAAE;KAAG,CAAC,IAAI,cAAc,GAAG,MAAM;CAyTvD,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAGxF,CAAC"}

package/dist/pages/SwapFlow/SwapFormContext.d.ts

@@ -0,0 +1,6 @@
+export interface SwapFormContextValue {
+    submitForm: () => void;
+}
+export declare const SwapFormContext: import("react").Context<SwapFormContextValue | null>;
+export declare const useSwapFormContext: () => SwapFormContextValue;
+//# sourceMappingURL=SwapFormContext.d.ts.map

package/dist/pages/SwapFlow/SwapFormContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwapFormContext.d.ts","sourceRoot":"","sources":["../../../src/pages/SwapFlow/SwapFormContext.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,eAAO,MAAM,eAAe,sDAAmD,CAAC;AAEhF,eAAO,MAAM,kBAAkB,4BAM9B,CAAC"}

package/dist/pages/SwapFlow/SwapHistoryScreen.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const SwapHistoryScreen: React.FC;
+export default SwapHistoryScreen;
+//# sourceMappingURL=SwapHistoryScreen.d.ts.map