@tcswap/helpers 4.5.15

package/dist/types/api/index.d.ts

@@ -0,0 +1,502 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+import * as thornode from "./thornode/endpoints";
+export * from "./memoless/types";
+export * from "./midgard/types";
+export * from "./thornode/types";
+export * from "./uswap/types";
+export declare const USwapApi: {
+    mayachainMidgard: {
+        getActions: (query?: import(".").ActionQuery) => Promise<import(".").PagedResponse<import(".").Action>>;
+        getBalance: (address: string) => Promise<import(".").Balance[]>;
+        getConstants: () => Promise<import(".").Constants>;
+        getEarningsHistory: (query?: import(".").HistoryQuery) => Promise<import(".").EarningsHistory>;
+        getHealth: () => Promise<import(".").HealthInfo>;
+        getLiquidityPosition: (address: string) => Promise<{
+            [x: string]: string | import("..").AssetValue | import("..").USwapNumber;
+            asset: import("..").AssetValue;
+            assetPending: import("..").AssetValue;
+            assetRegisteredAddress: string;
+            assetWithdrawn: import("..").AssetValue;
+            dateFirstAdded: string;
+            dateLastAdded: string;
+            poolShare: import("..").USwapNumber;
+        }[]>;
+        getLiquidityPositionRaw: (address: string) => Promise<import(".").MemberDetailsMayachain>;
+        getMembers: (pool?: string) => Promise<string[]>;
+        getMimir: () => Promise<Record<string, string>>;
+        getMimirVotes: () => Promise<import(".").MimirVote[]>;
+        getNameDetails: (name: string) => Promise<import(".").THORNameDetails>;
+        getNamesByAddress: (address: string) => Promise<string[]>;
+        getNamesByOwner: (address: string) => Promise<string[]>;
+        getNetworkInfo: () => Promise<import(".").NetworkInfo>;
+        getNode: (address: string) => Promise<import(".").Node>;
+        getNodes: () => Promise<import(".").Node[]>;
+        getPool: (asset: string) => Promise<import(".").Pool>;
+        getPoolDepthHistory: (asset: string, query?: import(".").HistoryQuery) => Promise<import(".").DepthHistory>;
+        getPoolStats: (asset: string, period?: string) => Promise<import(".").PoolStats>;
+        getPools: (status?: string) => Promise<import(".").Pool[]>;
+        getSaverDetails: (address: string, pool?: string) => Promise<import(".").SaverDetails[]>;
+        getSavers: (pool: string) => Promise<string[]>;
+        getSaversHistory: (pool?: string, query?: import(".").HistoryQuery) => Promise<import(".").SaversHistory>;
+        getStats: () => Promise<import(".").Stats>;
+        getSwapHistory: (pool?: string, query?: import(".").HistoryQuery) => Promise<import(".").SwapHistory>;
+        getTVLHistory: (query?: import(".").HistoryQuery) => Promise<import(".").TVLHistory>;
+    };
+    thorchainMidgard: {
+        getActions: (query?: import(".").ActionQuery) => Promise<import(".").PagedResponse<import(".").Action>>;
+        getBalance: (address: string) => Promise<import(".").Balance[]>;
+        getConstants: () => Promise<import(".").Constants>;
+        getEarningsHistory: (query?: import(".").HistoryQuery) => Promise<import(".").EarningsHistory>;
+        getHealth: () => Promise<import(".").HealthInfo>;
+        getLiquidityPosition: (address: string) => Promise<{
+            [x: string]: string | import("..").AssetValue | import("..").USwapNumber;
+            asset: import("..").AssetValue;
+            assetPending: import("..").AssetValue;
+            assetRegisteredAddress: string;
+            assetWithdrawn: import("..").AssetValue;
+            dateFirstAdded: string;
+            dateLastAdded: string;
+            poolShare: import("..").USwapNumber;
+        }[]>;
+        getLiquidityPositionRaw: (address: string) => Promise<import(".").MemberDetailsThorchain>;
+        getMembers: (pool?: string) => Promise<string[]>;
+        getMimir: () => Promise<Record<string, string>>;
+        getMimirVotes: () => Promise<import(".").MimirVote[]>;
+        getNameDetails: (name: string) => Promise<import(".").THORNameDetails>;
+        getNamesByAddress: (address: string) => Promise<string[]>;
+        getNamesByOwner: (address: string) => Promise<string[]>;
+        getNetworkInfo: () => Promise<import(".").NetworkInfo>;
+        getNode: (address: string) => Promise<import(".").Node>;
+        getNodes: () => Promise<import(".").Node[]>;
+        getPool: (asset: string) => Promise<import(".").Pool>;
+        getPoolDepthHistory: (asset: string, query?: import(".").HistoryQuery) => Promise<import(".").DepthHistory>;
+        getPoolStats: (asset: string, period?: string) => Promise<import(".").PoolStats>;
+        getPools: (status?: string) => Promise<import(".").Pool[]>;
+        getSaverDetails: (address: string, pool?: string) => Promise<import(".").SaverDetails[]>;
+        getSavers: (pool: string) => Promise<string[]>;
+        getSaversHistory: (pool?: string, query?: import(".").HistoryQuery) => Promise<import(".").SaversHistory>;
+        getStats: () => Promise<import(".").Stats>;
+        getSwapHistory: (pool?: string, query?: import(".").HistoryQuery) => Promise<import(".").SwapHistory>;
+        getTVLHistory: (query?: import(".").HistoryQuery) => Promise<import(".").TVLHistory>;
+    };
+    thornode: typeof thornode;
+    getMemolessAssets(options?: import("..").RequestOptions): Promise<{
+        assets: {
+            asset: string;
+            balanceRune: number;
+            decimals: number;
+            isToken: boolean;
+            priceUSD: number;
+            status: string;
+        }[];
+        success: boolean;
+        error?: {
+            code: string;
+            details: string;
+            message: string;
+        } | undefined;
+    }>;
+    registerMemoless(json: import(".").RegistrationRequest, options?: import("..").RequestOptions): Promise<{
+        asset: string;
+        decimals: number;
+        height: string;
+        internal_api_id: string;
+        memo: string;
+        minimum_amount_to_send: string;
+        reference: string;
+        reference_length: number;
+        registered_by: string;
+        registration_hash: string;
+        success: boolean;
+        txHash: string;
+        suggested_in_asset_amount?: string | undefined;
+    }>;
+    preflightMemoless(json: import(".").PreflightRequest, options?: import("..").RequestOptions): Promise<{
+        data: {
+            blocks_remaining: number;
+            current_uses: number;
+            max_uses: number;
+            seconds_remaining: number;
+            time_remaining: string;
+            inbound_address?: string | undefined;
+            memo?: string | undefined;
+            qr_code?: string | undefined;
+            qr_code_data_url?: string | undefined;
+        };
+        message: string;
+        success: boolean;
+        error?: {
+            code: string;
+            message: string;
+        } | undefined;
+    }>;
+    getTrackerDetails(json: import(".").TrackingRequest, options?: import("..").RequestOptions): Promise<import(".").TransactionDTO>;
+    getSwapQuote(json: import(".").QuoteRequest, options?: import("..").RequestOptions): Promise<{
+        routes: {
+            buyAsset: string;
+            expectedBuyAmount: string;
+            fees: {
+                amount: string;
+                asset: string;
+                chain: string;
+                protocol: import("..").ProviderName;
+                type: import("..").FeeTypeEnum;
+            }[];
+            providers: import("..").ProviderName[];
+            sellAmount: string;
+            sellAsset: string;
+            destinationAddress?: string | undefined;
+            estimatedTime?: {
+                total: number;
+                inbound?: number | undefined;
+                outbound?: number | undefined;
+                swap?: number | undefined;
+            } | undefined;
+            expectedBuyAmountMaxSlippage?: string | undefined;
+            expiration?: string | undefined;
+            inboundAddress?: string | undefined;
+            legs?: {
+                buyAmount: string;
+                buyAmountMaxSlippage: string;
+                buyAsset: string;
+                provider: import("..").ProviderName;
+                sellAmount: string;
+                sellAsset: string;
+                fees?: {
+                    amount: string;
+                    asset: string;
+                    chain: string;
+                    protocol: import("..").ProviderName;
+                    type: import("..").FeeTypeEnum;
+                }[] | undefined;
+            }[] | undefined;
+            memo?: string | undefined;
+            meta?: {
+                assets?: {
+                    asset: string;
+                    image: string;
+                    price: number;
+                }[] | undefined;
+                maxStreamingQuantity?: number | undefined;
+                streamingInterval?: number | undefined;
+                tags?: import(".").PriorityLabel[] | undefined;
+                affiliate?: string | undefined;
+                affiliateFee?: string | undefined;
+                approvalAddress?: string | undefined;
+                chainflip?: {
+                    destinationAddress: string;
+                    buyAsset: {
+                        asset: string;
+                        chain: string;
+                    };
+                    sellAsset: {
+                        asset: string;
+                        chain: string;
+                    };
+                    affiliateFees?: {
+                        brokerAddress: string;
+                        feeBps: number;
+                    }[] | undefined;
+                    brokerCommissionBps?: number | undefined;
+                    channelMetadata?: {
+                        cfParameters?: string | undefined;
+                        gasBudget?: string | undefined;
+                        message?: string | undefined;
+                    } | undefined;
+                    dcaParameters?: {
+                        chunkInterval?: number | undefined;
+                        numberOfChunks?: number | undefined;
+                    } | undefined;
+                    maxBoostFeeBps?: number | undefined;
+                    refundParameters?: {
+                        minPrice?: string | undefined;
+                        refundAddress?: string | undefined;
+                        retryDuration?: number | undefined;
+                    } | undefined;
+                } | undefined;
+                garden?: {
+                    destinationAddress: string;
+                    buyAsset: string;
+                    sellAmount: string;
+                    sellAsset: string;
+                    slippage: number;
+                    sourceAddress: string;
+                    affiliateFees?: {
+                        feeBps: number;
+                        nearId: string;
+                    } | undefined;
+                } | undefined;
+                near?: {
+                    destinationAddress: string;
+                    buyAsset: string;
+                    sellAmount: string;
+                    sellAsset: string;
+                    slippage: number;
+                    sourceAddress: string;
+                    affiliateFees?: {
+                        feeBps: number;
+                        nearId: string;
+                    } | undefined;
+                } | undefined;
+                priceImpact?: number | undefined;
+                referrer?: string | undefined;
+                txType?: import(".").RouteQuoteTxType | undefined;
+            } | undefined;
+            refundAddress?: string | undefined;
+            sourceAddress?: string | undefined;
+            targetAddress?: string | undefined;
+            tx?: string | {
+                data: string;
+                from: string;
+                to: string;
+                value: string;
+            } | {
+                accountNumber: number;
+                chainId: import("@tcswap/types").ChainId;
+                fee: {
+                    amount: {
+                        amount: string;
+                        denom: string;
+                    }[];
+                    gas: string;
+                };
+                memo: string;
+                msgs: {
+                    typeUrl: string;
+                    value: unknown;
+                }[];
+                sequence: number;
+            } | undefined;
+            txType?: import(".").RouteQuoteTxType | undefined;
+            warnings?: {
+                code: import("..").WarningCodeEnum;
+                display: string;
+                tooltip?: string | undefined;
+            }[] | undefined;
+        }[];
+        error?: string | undefined;
+        providerErrors?: {
+            errorCode?: import("..").ErrorCode | undefined;
+            message?: string | undefined;
+            provider?: import("..").ProviderName | undefined;
+        }[] | undefined;
+    }>;
+    getRouteWithTx(json: {
+        routeId: string;
+        sourceAddress: string;
+        destinationAddress: string;
+    }): Promise<{
+        buyAsset: string;
+        expectedBuyAmount: string;
+        fees: {
+            amount: string;
+            asset: string;
+            chain: string;
+            protocol: import("..").ProviderName;
+            type: import("..").FeeTypeEnum;
+        }[];
+        providers: import("..").ProviderName[];
+        sellAmount: string;
+        sellAsset: string;
+        destinationAddress?: string | undefined;
+        estimatedTime?: {
+            total: number;
+            inbound?: number | undefined;
+            outbound?: number | undefined;
+            swap?: number | undefined;
+        } | undefined;
+        expectedBuyAmountMaxSlippage?: string | undefined;
+        expiration?: string | undefined;
+        inboundAddress?: string | undefined;
+        legs?: {
+            buyAmount: string;
+            buyAmountMaxSlippage: string;
+            buyAsset: string;
+            provider: import("..").ProviderName;
+            sellAmount: string;
+            sellAsset: string;
+            fees?: {
+                amount: string;
+                asset: string;
+                chain: string;
+                protocol: import("..").ProviderName;
+                type: import("..").FeeTypeEnum;
+            }[] | undefined;
+        }[] | undefined;
+        memo?: string | undefined;
+        meta?: {
+            assets?: {
+                asset: string;
+                image: string;
+                price: number;
+            }[] | undefined;
+            maxStreamingQuantity?: number | undefined;
+            streamingInterval?: number | undefined;
+            tags?: import(".").PriorityLabel[] | undefined;
+            affiliate?: string | undefined;
+            affiliateFee?: string | undefined;
+            approvalAddress?: string | undefined;
+            chainflip?: {
+                destinationAddress: string;
+                buyAsset: {
+                    asset: string;
+                    chain: string;
+                };
+                sellAsset: {
+                    asset: string;
+                    chain: string;
+                };
+                affiliateFees?: {
+                    brokerAddress: string;
+                    feeBps: number;
+                }[] | undefined;
+                brokerCommissionBps?: number | undefined;
+                channelMetadata?: {
+                    cfParameters?: string | undefined;
+                    gasBudget?: string | undefined;
+                    message?: string | undefined;
+                } | undefined;
+                dcaParameters?: {
+                    chunkInterval?: number | undefined;
+                    numberOfChunks?: number | undefined;
+                } | undefined;
+                maxBoostFeeBps?: number | undefined;
+                refundParameters?: {
+                    minPrice?: string | undefined;
+                    refundAddress?: string | undefined;
+                    retryDuration?: number | undefined;
+                } | undefined;
+            } | undefined;
+            garden?: {
+                destinationAddress: string;
+                buyAsset: string;
+                sellAmount: string;
+                sellAsset: string;
+                slippage: number;
+                sourceAddress: string;
+                affiliateFees?: {
+                    feeBps: number;
+                    nearId: string;
+                } | undefined;
+            } | undefined;
+            near?: {
+                destinationAddress: string;
+                buyAsset: string;
+                sellAmount: string;
+                sellAsset: string;
+                slippage: number;
+                sourceAddress: string;
+                affiliateFees?: {
+                    feeBps: number;
+                    nearId: string;
+                } | undefined;
+            } | undefined;
+            priceImpact?: number | undefined;
+            referrer?: string | undefined;
+            txType?: import(".").RouteQuoteTxType | undefined;
+        } | undefined;
+        refundAddress?: string | undefined;
+        sourceAddress?: string | undefined;
+        targetAddress?: string | undefined;
+        tx?: string | {
+            data: string;
+            from: string;
+            to: string;
+            value: string;
+        } | {
+            accountNumber: number;
+            chainId: import("@tcswap/types").ChainId;
+            fee: {
+                amount: {
+                    amount: string;
+                    denom: string;
+                }[];
+                gas: string;
+            };
+            memo: string;
+            msgs: {
+                typeUrl: string;
+                value: unknown;
+            }[];
+            sequence: number;
+        } | undefined;
+        txType?: import(".").RouteQuoteTxType | undefined;
+        warnings?: {
+            code: import("..").WarningCodeEnum;
+            display: string;
+            tooltip?: string | undefined;
+        }[] | undefined;
+    }>;
+    getChainBalance<T extends import("@tcswap/types").Chain>({ chain, address, scamFilter, }: {
+        chain: T;
+        address: string;
+        scamFilter?: boolean;
+    }): Promise<{
+        chain: import("@tcswap/types").Chain;
+        decimal: number;
+        identifier: string;
+        symbol: string;
+        ticker: string;
+        value: string;
+    }[]>;
+    getTokenListProviders(): Promise<import(".").TokenListProvidersResponse>;
+    getTokenList(provider: import("..").ProviderName): Promise<import(".").TokensResponseV2>;
+    getPrice(body: import(".").PriceRequest): Promise<{
+        cg?: {
+            id: string;
+            market_cap: number;
+            name: string;
+            price_change_24h_usd: number;
+            price_change_percentage_24h_usd: number;
+            sparkline_in_7d: number[];
+            timestamp: string;
+            total_volume: number;
+        } | undefined;
+        identifier?: string | undefined;
+        price_usd?: number | undefined;
+        provider?: string | undefined;
+        timestamp?: number | undefined;
+    }[]>;
+    getGasRate(): Promise<(import("zod/v4").ZodSafeParseSuccess<{
+        chainId: import("@tcswap/types").ChainId;
+        createdAt: Date;
+        id: number;
+        unit: string;
+        value: string;
+    } | {
+        chainId: import("@tcswap/types").ChainId;
+        createdAt: Date;
+        id: number;
+        unit: string;
+        value: string;
+    }[]> & any[]) | import("zod/v4").ZodSafeParseSuccess<{
+        chainId: import("@tcswap/types").ChainId;
+        createdAt: Date;
+        id: number;
+        unit: string;
+        value: string;
+    } | {
+        chainId: import("@tcswap/types").ChainId;
+        createdAt: Date;
+        id: number;
+        unit: string;
+        value: string;
+    }[]>[]>;
+    getChainflipDepositChannel(body: import(".").BrokerDepositChannelParams): Promise<{
+        channelId: string;
+        depositAddress: string;
+    }>;
+    getNearDepositChannel(body: import(".").NearDepositChannelParams): Promise<{
+        buyAsset: string;
+        buyAssetAmount: string;
+        buyAssetAmountMaxSlippage: string;
+        depositAddress: string;
+        depositAmount: string;
+        depositAsset: string;
+        tx: unknown;
+        deadline?: string | undefined;
+    }>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/types/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAGjD,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAE9B,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC4jF,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADn/E,CAAC"}

package/dist/types/api/memoless/endpoints.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+import { type RequestOptions } from "@tcswap/helpers";
+import { type PreflightRequest, type RegistrationRequest } from "./types";
+export declare function getMemolessAssets(options?: RequestOptions): Promise<{
+    assets: {
+        asset: string;
+        balanceRune: number;
+        decimals: number;
+        isToken: boolean;
+        priceUSD: number;
+        status: string;
+    }[];
+    success: boolean;
+    error?: {
+        code: string;
+        details: string;
+        message: string;
+    } | undefined;
+}>;
+export declare function registerMemoless(json: RegistrationRequest, options?: RequestOptions): Promise<{
+    asset: string;
+    decimals: number;
+    height: string;
+    internal_api_id: string;
+    memo: string;
+    minimum_amount_to_send: string;
+    reference: string;
+    reference_length: number;
+    registered_by: string;
+    registration_hash: string;
+    success: boolean;
+    txHash: string;
+    suggested_in_asset_amount?: string | undefined;
+}>;
+export declare function preflightMemoless(json: PreflightRequest, options?: RequestOptions): Promise<{
+    data: {
+        blocks_remaining: number;
+        current_uses: number;
+        max_uses: number;
+        seconds_remaining: number;
+        time_remaining: string;
+        inbound_address?: string | undefined;
+        memo?: string | undefined;
+        qr_code?: string | undefined;
+        qr_code_data_url?: string | undefined;
+    };
+    message: string;
+    success: boolean;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+}>;
+//# sourceMappingURL=endpoints.d.ts.map

package/dist/types/api/memoless/endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoints.d.ts","sourceRoot":"","sources":["../../../../src/api/memoless/endpoints.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAiB,KAAK,cAAc,EAA2B,MAAM,iBAAiB,CAAC;AAC9F,OAAO,EAEL,KAAK,gBAAgB,EAGrB,KAAK,mBAAmB,EAGzB,MAAM,SAAS,CAAC;AASjB,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,cAAc;;;;;;;;;;;;;;;GAEzD;AAED,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,cAAc;;;;;;;;;;;;;;GAczF;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,cAAc;;;;;;;;;;;;;;;;;;GAcvF"}

package/dist/types/api/memoless/types.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+import { coerce, z } from "zod/v4";
+export declare const MemolessAssetItem: z.ZodObject<{
+    asset: z.ZodString;
+    balanceRune: z.ZodNumber;
+    decimals: coerce.ZodCoercedNumber<unknown>;
+    isToken: z.ZodBoolean;
+    priceUSD: z.ZodNumber;
+    status: z.ZodString;
+}, z.core.$strip>;
+export declare const MemolessAssetsSchema: z.ZodObject<{
+    assets: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        balanceRune: z.ZodNumber;
+        decimals: coerce.ZodCoercedNumber<unknown>;
+        isToken: z.ZodBoolean;
+        priceUSD: z.ZodNumber;
+        status: z.ZodString;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        details: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export type MemolessAsset = z.infer<typeof MemolessAssetItem>;
+export type MemolessAssetsResponse = z.infer<typeof MemolessAssetsSchema>;
+export declare const RegistrationRequestSchema: z.ZodObject<{
+    asset: z.ZodString;
+    memo: z.ZodString;
+    requested_in_asset_amount: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodNumber]>;
+}, z.core.$strip>;
+export type RegistrationRequest = z.infer<typeof RegistrationRequestSchema>;
+export declare const RegistrationResponseSchema: z.ZodObject<{
+    asset: z.ZodString;
+    decimals: z.ZodNumber;
+    height: z.ZodString;
+    internal_api_id: z.ZodString;
+    memo: z.ZodString;
+    minimum_amount_to_send: z.ZodString;
+    reference: z.ZodString;
+    reference_length: z.ZodNumber;
+    registered_by: z.ZodString;
+    registration_hash: z.ZodString;
+    success: z.ZodBoolean;
+    suggested_in_asset_amount: z.ZodOptional<z.ZodString>;
+    txHash: z.ZodString;
+}, z.core.$strip>;
+export type RegistrationResponse = z.infer<typeof RegistrationResponseSchema>;
+export declare enum PreflightInputType {
+    asset = "asset",
+    usd = "usd"
+}
+export declare const PreflightRequestSchema: z.ZodObject<{
+    amount: z.ZodString;
+    asset: z.ZodOptional<z.ZodString>;
+    inputType: z.ZodOptional<z.ZodEnum<typeof PreflightInputType>>;
+    internal_api_id: z.ZodOptional<z.ZodString>;
+    reference: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PreflightRequest = z.infer<typeof PreflightRequestSchema>;
+export declare const PreflightResultSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        blocks_remaining: z.ZodNumber;
+        current_uses: z.ZodNumber;
+        inbound_address: z.ZodOptional<z.ZodString>;
+        max_uses: z.ZodNumber;
+        memo: z.ZodOptional<z.ZodString>;
+        qr_code: z.ZodOptional<z.ZodString>;
+        qr_code_data_url: z.ZodOptional<z.ZodString>;
+        seconds_remaining: z.ZodNumber;
+        time_remaining: z.ZodString;
+    }, z.core.$strip>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    message: z.ZodString;
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export type PreflightResult = z.infer<typeof PreflightResultSchema>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/api/memoless/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/api/memoless/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAS,MAAM,EAAoB,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE5D,eAAO,MAAM,iBAAiB;;;;;;;iBAO5B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;iBAI/B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC9D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAE1E,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;iBAcrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,oBAAY,kBAAkB;IAC5B,KAAK,UAAU;IACf,GAAG,QAAQ;CACZ;AAED,eAAO,MAAM,sBAAsB;;;;;;iBAMjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;iBAehC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}