@helium/blockchain-api 0.1.2 → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,2382 @@
+import * as zod from 'zod';
+import { z } from 'zod';
+import * as zod_v4_core from 'zod/v4/core';
+
+/**
+ * Client configuration options.
+ */
+interface ClientOptions {
+    /** Base URL of the Helium API server (e.g., "https://api.helium.com") */
+    url: string;
+    /** Transport protocol: "rpc" (default) or "rest" */
+    transport?: "rpc" | "rest";
+}
+
+/**
+ * Complete API contract definition.
+ * Defines all routes, inputs, outputs, and errors for the Helium Blockchain API.
+ */
+declare const apiContract: {
+    readonly health: {
+        readonly check: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/health";
+            };
+            readonly output: zod.ZodObject<{
+                ok: zod.ZodBoolean;
+                error: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>;
+        };
+    };
+    readonly tokens: {
+        readonly getBalances: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/tokens/{walletAddress}";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                totalBalanceUsd: zod.ZodNumber;
+                solBalance: zod.ZodNumber;
+                solBalanceUsd: zod.ZodNumber;
+                tokens: zod.ZodArray<zod.ZodObject<{
+                    mint: zod.ZodString;
+                    address: zod.ZodString;
+                    balance: zod.ZodString;
+                    decimals: zod.ZodNumber;
+                    uiAmount: zod.ZodNumber;
+                    symbol: zod.ZodOptional<zod.ZodString>;
+                    name: zod.ZodOptional<zod.ZodString>;
+                    logoURI: zod.ZodOptional<zod.ZodString>;
+                    priceUsd: zod.ZodOptional<zod.ZodNumber>;
+                    balanceUsd: zod.ZodOptional<zod.ZodNumber>;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Wallet address is required";
+                };
+            };
+        };
+        readonly transfer: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/tokens/transfer";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+                mint: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                destination: zod.ZodString;
+                amount: zod.ZodString;
+                decimals: zod.ZodOptional<zod.ZodNumber>;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                transactionData: zod.ZodObject<{
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        serializedTransaction: zod.ZodString;
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                    parallel: zod.ZodBoolean;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid transfer parameters";
+                };
+                readonly INSUFFICIENT_FUNDS: {
+                    readonly message: "Insufficient balance for transfer";
+                };
+            };
+        };
+        readonly createHntAccount: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/tokens/hnt-account";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                transactionData: zod.ZodObject<{
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        serializedTransaction: zod.ZodString;
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                    parallel: zod.ZodBoolean;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid wallet address";
+                };
+            };
+        };
+    };
+    readonly hotspots: {
+        readonly getHotspots: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/hotspots/wallet/{walletAddress}";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+                type: zod.ZodOptional<zod.ZodEnum<{
+                    iot: "iot";
+                    mobile: "mobile";
+                    all: "all";
+                }>>;
+                page: zod.ZodDefault<zod.ZodCoercedNumber<unknown>>;
+                limit: zod.ZodDefault<zod.ZodCoercedNumber<unknown>>;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                hotspots: zod.ZodArray<zod.ZodObject<{
+                    address: zod.ZodString;
+                    entityKey: zod.ZodString;
+                    name: zod.ZodString;
+                    type: zod.ZodEnum<{
+                        iot: "iot";
+                        mobile: "mobile";
+                        all: "all";
+                    }>;
+                    deviceType: zod.ZodEnum<{
+                        "iot-gateway": "iot-gateway";
+                        wifiIndoor: "wifiIndoor";
+                        wifiOutdoor: "wifiOutdoor";
+                        wifiDataOnly: "wifiDataOnly";
+                        cbrs: "cbrs";
+                    }>;
+                    city: zod.ZodOptional<zod.ZodString>;
+                    state: zod.ZodOptional<zod.ZodString>;
+                    country: zod.ZodOptional<zod.ZodString>;
+                    asset: zod.ZodString;
+                    isOnline: zod.ZodOptional<zod.ZodBoolean>;
+                    owner: zod.ZodOptional<zod.ZodString>;
+                    shares: zod.ZodOptional<zod.ZodObject<{
+                        fixed: zod.ZodOptional<zod.ZodString>;
+                        percentage: zod.ZodOptional<zod.ZodNumber>;
+                    }, zod_v4_core.$strip>>;
+                    ownershipType: zod.ZodString;
+                }, zod_v4_core.$strip>>;
+                total: zod.ZodNumber;
+                page: zod.ZodNumber;
+                totalPages: zod.ZodNumber;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid wallet address";
+                };
+            };
+        };
+        readonly claimRewards: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/hotspots/claim-rewards";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                transactionData: zod.ZodObject<{
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        serializedTransaction: zod.ZodString;
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                    parallel: zod.ZodBoolean;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid wallet address";
+                };
+                readonly NO_REWARDS: {
+                    readonly message: "No rewards to claim";
+                };
+            };
+        };
+        readonly getPendingRewards: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/hotspots/pending-rewards/{walletAddress}";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                pending: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid wallet address";
+                };
+            };
+        };
+        readonly transferHotspot: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/hotspots/transfer";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+                hotspotPubkey: zod.ZodString;
+                recipient: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                transactionData: zod.ZodObject<{
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        serializedTransaction: zod.ZodString;
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                    parallel: zod.ZodBoolean;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid transfer parameters";
+                };
+                readonly NOT_OWNER: {
+                    readonly status: 403;
+                    readonly message: "You do not own this asset.";
+                    readonly data: zod.ZodObject<{
+                        owner: zod.ZodString;
+                        wallet: zod.ZodString;
+                    }, zod_v4_core.$strip>;
+                };
+                readonly INVALID_HOTSPOT: {
+                    readonly status: 400;
+                    readonly message: "The specified asset is not a valid Helium hotspot.";
+                };
+                readonly NOT_FOUND: {
+                    readonly status: 404;
+                    readonly message: "The requested resource was not found.";
+                };
+            };
+        };
+        readonly updateRewardsDestination: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/hotspots/update-rewards-destination";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+                hotspotPubkey: zod.ZodString;
+                destination: zod.ZodString;
+                lazyDistributors: zod.ZodArray<zod.ZodString>;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                transactionData: zod.ZodObject<{
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        serializedTransaction: zod.ZodString;
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                    parallel: zod.ZodBoolean;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid parameters";
+                };
+                readonly NOT_OWNER: {
+                    readonly status: 403;
+                    readonly message: "You do not own this asset.";
+                    readonly data: zod.ZodObject<{
+                        owner: zod.ZodString;
+                        wallet: zod.ZodString;
+                    }, zod_v4_core.$strip>;
+                };
+                readonly INVALID_HOTSPOT: {
+                    readonly status: 400;
+                    readonly message: "The specified asset is not a valid Helium hotspot.";
+                };
+                readonly NOT_FOUND: {
+                    readonly status: 404;
+                    readonly message: "The requested resource was not found.";
+                };
+            };
+        };
+        readonly getSplit: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/hotspots/split/{walletAddress}/{hotspotPubkey}";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+                hotspotPubkey: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+                hotspotPubkey: zod.ZodString;
+                splitAddress: zod.ZodString;
+                shares: zod.ZodArray<zod.ZodObject<{
+                    wallet: zod.ZodString;
+                    delegate: zod.ZodString;
+                    fixed: zod.ZodNumber;
+                    shares: zod.ZodNumber;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly NOT_FOUND: {
+                    readonly message: "Split not found";
+                };
+            };
+        };
+        readonly createSplit: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/hotspots/split";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+                hotspotPubkey: zod.ZodString;
+                rewardsSplit: zod.ZodArray<zod.ZodObject<{
+                    address: zod.ZodString;
+                    type: zod.ZodEnum<{
+                        fixed: "fixed";
+                        percentage: "percentage";
+                    }>;
+                    amount: zod.ZodNumber;
+                }, zod_v4_core.$strip>>;
+                schedule: zod.ZodObject<{
+                    frequency: zod.ZodEnum<{
+                        daily: "daily";
+                        weekly: "weekly";
+                        monthly: "monthly";
+                    }>;
+                    time: zod.ZodString;
+                    timezone: zod.ZodString;
+                    dayOfWeek: zod.ZodOptional<zod.ZodString>;
+                    dayOfMonth: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+                lazyDistributor: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                transactionData: zod.ZodObject<{
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        serializedTransaction: zod.ZodString;
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                    parallel: zod.ZodBoolean;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid split configuration";
+                };
+                readonly NOT_OWNER: {
+                    readonly status: 403;
+                    readonly message: "You do not own this asset.";
+                    readonly data: zod.ZodObject<{
+                        owner: zod.ZodString;
+                        wallet: zod.ZodString;
+                    }, zod_v4_core.$strip>;
+                };
+                readonly INVALID_HOTSPOT: {
+                    readonly status: 400;
+                    readonly message: "The specified asset is not a valid Helium hotspot.";
+                };
+                readonly NOT_FOUND: {
+                    readonly status: 404;
+                    readonly message: "The requested resource was not found.";
+                };
+            };
+        };
+        readonly deleteSplit: {
+            readonly route: {
+                readonly method: "DELETE";
+                readonly path: "/hotspots/split";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+                hotspotPubkey: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                transactionData: zod.ZodObject<{
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        serializedTransaction: zod.ZodString;
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                    parallel: zod.ZodBoolean;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly NOT_OWNER: {
+                    readonly status: 403;
+                    readonly message: "You do not own this asset.";
+                    readonly data: zod.ZodObject<{
+                        owner: zod.ZodString;
+                        wallet: zod.ZodString;
+                    }, zod_v4_core.$strip>;
+                };
+                readonly INVALID_HOTSPOT: {
+                    readonly status: 400;
+                    readonly message: "The specified asset is not a valid Helium hotspot.";
+                };
+                readonly NOT_FOUND: {
+                    readonly status: 404;
+                    readonly message: "The requested resource was not found.";
+                };
+            };
+        };
+    };
+    readonly swap: {
+        readonly getTokens: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/swap/tokens";
+            };
+            readonly input: zod.ZodObject<{
+                limit: zod.ZodDefault<zod.ZodCoercedNumber<unknown>>;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                tokens: zod.ZodArray<zod.ZodObject<{
+                    address: zod.ZodString;
+                    symbol: zod.ZodString;
+                    name: zod.ZodString;
+                    decimals: zod.ZodNumber;
+                    logoURI: zod.ZodOptional<zod.ZodString>;
+                    tags: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {};
+        };
+        readonly getQuote: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/swap/quote";
+            };
+            readonly input: zod.ZodObject<{
+                inputMint: zod.ZodString;
+                outputMint: zod.ZodString;
+                amount: zod.ZodString;
+                swapMode: zod.ZodDefault<zod.ZodEnum<{
+                    ExactIn: "ExactIn";
+                    ExactOut: "ExactOut";
+                }>>;
+                slippageBps: zod.ZodDefault<zod.ZodCoercedNumber<unknown>>;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                inputMint: zod.ZodString;
+                inAmount: zod.ZodString;
+                outputMint: zod.ZodString;
+                outAmount: zod.ZodString;
+                otherAmountThreshold: zod.ZodString;
+                swapMode: zod.ZodString;
+                slippageBps: zod.ZodNumber;
+                platformFee: zod.ZodOptional<zod.ZodUnknown>;
+                priceImpactPct: zod.ZodString;
+                routePlan: zod.ZodArray<zod.ZodUnknown>;
+                contextSlot: zod.ZodOptional<zod.ZodNumber>;
+                timeTaken: zod.ZodOptional<zod.ZodNumber>;
+            }, zod_v4_core.$loose>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid quote parameters";
+                };
+                readonly EXTERNAL_API_ERROR: {
+                    readonly message: "Jupiter API request failed";
+                };
+            };
+        };
+        readonly getInstructions: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/swap/instructions";
+            };
+            readonly input: zod.ZodObject<{
+                quoteResponse: zod.ZodObject<{
+                    inputMint: zod.ZodString;
+                    inAmount: zod.ZodString;
+                    outputMint: zod.ZodString;
+                    outAmount: zod.ZodString;
+                    otherAmountThreshold: zod.ZodString;
+                    swapMode: zod.ZodString;
+                    slippageBps: zod.ZodNumber;
+                    platformFee: zod.ZodOptional<zod.ZodUnknown>;
+                    priceImpactPct: zod.ZodString;
+                    routePlan: zod.ZodArray<zod.ZodUnknown>;
+                    contextSlot: zod.ZodOptional<zod.ZodNumber>;
+                    timeTaken: zod.ZodOptional<zod.ZodNumber>;
+                }, zod_v4_core.$loose>;
+                userPublicKey: zod.ZodString;
+                destinationTokenAccount: zod.ZodOptional<zod.ZodString>;
+                dynamicComputeUnitLimit: zod.ZodDefault<zod.ZodBoolean>;
+                prioritizationFeeLamports: zod.ZodOptional<zod.ZodObject<{
+                    priorityLevelWithMaxLamports: zod.ZodObject<{
+                        maxLamports: zod.ZodDefault<zod.ZodNumber>;
+                        priorityLevel: zod.ZodDefault<zod.ZodEnum<{
+                            low: "low";
+                            medium: "medium";
+                            high: "high";
+                        }>>;
+                    }, zod_v4_core.$strip>;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                transactions: zod.ZodArray<zod.ZodObject<{
+                    serializedTransaction: zod.ZodString;
+                    metadata: zod.ZodOptional<zod.ZodObject<{
+                        type: zod.ZodString;
+                        description: zod.ZodString;
+                    }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                }, zod_v4_core.$strip>>;
+                parallel: zod.ZodBoolean;
+                tag: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid instruction parameters";
+                };
+                readonly EXTERNAL_API_ERROR: {
+                    readonly message: "Jupiter API request failed";
+                };
+            };
+        };
+    };
+    readonly transactions: {
+        readonly submit: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/transactions";
+            };
+            readonly input: zod.ZodObject<{
+                transactions: zod.ZodArray<zod.ZodObject<{
+                    serializedTransaction: zod.ZodString;
+                    metadata: zod.ZodOptional<zod.ZodObject<{
+                        type: zod.ZodString;
+                        description: zod.ZodString;
+                    }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                }, zod_v4_core.$strip>>;
+                parallel: zod.ZodBoolean;
+                tag: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                batchId: zod.ZodString;
+                message: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly INSUFFICIENT_FUNDS: {
+                    readonly status: 400;
+                    readonly message: "Insufficient SOL balance to complete this transaction.";
+                    readonly data: zod.ZodObject<{
+                        required: zod.ZodNumber;
+                        available: zod.ZodNumber;
+                    }, zod_v4_core.$strip>;
+                };
+                readonly TRANSACTION_FAILED: {
+                    readonly status: 500;
+                    readonly message: "Transaction failed to execute.";
+                    readonly data: zod.ZodObject<{
+                        logs: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+                        signature: zod.ZodOptional<zod.ZodString>;
+                    }, zod_v4_core.$strip>;
+                };
+                readonly SIMULATION_FAILED: {
+                    readonly status: 400;
+                    readonly message: "Transaction simulation failed.";
+                    readonly data: zod.ZodObject<{
+                        logs: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+                        link: zod.ZodOptional<zod.ZodString>;
+                    }, zod_v4_core.$strip>;
+                };
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid transaction data";
+                };
+            };
+        };
+        readonly get: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/transactions/{id}";
+            };
+            readonly input: zod.ZodObject<{
+                id: zod.ZodString;
+                commitment: zod.ZodEnum<{
+                    confirmed: "confirmed";
+                    finalized: "finalized";
+                }>;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                batchId: zod.ZodString;
+                status: zod.ZodString;
+                submissionType: zod.ZodString;
+                parallel: zod.ZodBoolean;
+                transactions: zod.ZodArray<zod.ZodObject<{
+                    signature: zod.ZodString;
+                    status: zod.ZodString;
+                    transaction: zod.ZodOptional<zod.ZodUnknown>;
+                }, zod_v4_core.$strip>>;
+                jitoBundleId: zod.ZodOptional<zod.ZodString>;
+                jitoBundleStatus: zod.ZodOptional<zod.ZodUnknown>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly NOT_FOUND: {
+                    readonly message: "Transaction batch not found";
+                };
+            };
+        };
+        readonly resubmit: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/transactions/{id}/resubmit";
+            };
+            readonly input: zod.ZodObject<{
+                id: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                success: zod.ZodBoolean;
+                message: zod.ZodString;
+                error: zod.ZodOptional<zod.ZodString>;
+                newSignatures: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly NOT_FOUND: {
+                    readonly message: "Transaction batch not found";
+                };
+                readonly BAD_REQUEST: {
+                    readonly message: "Cannot resubmit this transaction";
+                };
+            };
+        };
+        readonly getByPayer: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/transactions/payer/{payer}";
+            };
+            readonly input: zod.ZodObject<{
+                payer: zod.ZodString;
+                page: zod.ZodDefault<zod.ZodCoercedNumber<unknown>>;
+                limit: zod.ZodDefault<zod.ZodCoercedNumber<unknown>>;
+                status: zod.ZodDefault<zod.ZodOptional<zod.ZodString>>;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                payer: zod.ZodString;
+                batches: zod.ZodArray<zod.ZodObject<{
+                    batchId: zod.ZodString;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                    status: zod.ZodString;
+                    submissionType: zod.ZodString;
+                    parallel: zod.ZodBoolean;
+                    createdAt: zod.ZodString;
+                    updatedAt: zod.ZodString;
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>>;
+                pagination: zod.ZodObject<{
+                    page: zod.ZodNumber;
+                    limit: zod.ZodNumber;
+                    total: zod.ZodNumber;
+                    totalPages: zod.ZodNumber;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid payer address";
+                };
+            };
+        };
+        readonly getByPayerAndTag: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/transactions/payer/{payer}/tag/{tag}";
+            };
+            readonly input: zod.ZodObject<{
+                payer: zod.ZodString;
+                tag: zod.ZodString;
+                page: zod.ZodDefault<zod.ZodCoercedNumber<unknown>>;
+                limit: zod.ZodDefault<zod.ZodCoercedNumber<unknown>>;
+                status: zod.ZodDefault<zod.ZodOptional<zod.ZodString>>;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                payer: zod.ZodString;
+                batches: zod.ZodArray<zod.ZodObject<{
+                    batchId: zod.ZodString;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                    status: zod.ZodString;
+                    submissionType: zod.ZodString;
+                    parallel: zod.ZodBoolean;
+                    createdAt: zod.ZodString;
+                    updatedAt: zod.ZodString;
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>>;
+                pagination: zod.ZodObject<{
+                    page: zod.ZodNumber;
+                    limit: zod.ZodNumber;
+                    total: zod.ZodNumber;
+                    totalPages: zod.ZodNumber;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid parameters";
+                };
+            };
+        };
+    };
+    readonly welcomePacks: {
+        readonly list: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/welcome-packs/{walletAddress}";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodArray<zod.ZodObject<{
+                address: zod.ZodString;
+                id: zod.ZodNumber;
+                owner: zod.ZodString;
+                asset: zod.ZodString;
+                lazyDistributor: zod.ZodString;
+                rewardsMint: zod.ZodString;
+                rentRefund: zod.ZodString;
+                solAmount: zod.ZodString;
+                rewardsSplit: zod.ZodArray<zod.ZodObject<{
+                    address: zod.ZodString;
+                    type: zod.ZodEnum<{
+                        fixed: "fixed";
+                        percentage: "percentage";
+                    }>;
+                    amount: zod.ZodNumber;
+                }, zod_v4_core.$strip>>;
+                rewardsSchedule: zod.ZodString;
+                assetReturnAddress: zod.ZodString;
+                bumpSeed: zod.ZodNumber;
+                uniqueId: zod.ZodString;
+                loading: zod.ZodOptional<zod.ZodBoolean>;
+                hotspot: zod.ZodNullable<zod.ZodObject<{
+                    address: zod.ZodString;
+                    entityKey: zod.ZodString;
+                    name: zod.ZodString;
+                    type: zod.ZodEnum<{
+                        iot: "iot";
+                        mobile: "mobile";
+                        all: "all";
+                    }>;
+                    deviceType: zod.ZodEnum<{
+                        "iot-gateway": "iot-gateway";
+                        wifiIndoor: "wifiIndoor";
+                        wifiOutdoor: "wifiOutdoor";
+                        wifiDataOnly: "wifiDataOnly";
+                        cbrs: "cbrs";
+                    }>;
+                    city: zod.ZodOptional<zod.ZodString>;
+                    state: zod.ZodOptional<zod.ZodString>;
+                    country: zod.ZodOptional<zod.ZodString>;
+                    asset: zod.ZodString;
+                    isOnline: zod.ZodOptional<zod.ZodBoolean>;
+                    owner: zod.ZodOptional<zod.ZodString>;
+                    shares: zod.ZodOptional<zod.ZodObject<{
+                        fixed: zod.ZodOptional<zod.ZodString>;
+                        percentage: zod.ZodOptional<zod.ZodNumber>;
+                    }, zod_v4_core.$strip>>;
+                    ownershipType: zod.ZodString;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid wallet address";
+                };
+            };
+        };
+        readonly create: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/welcome-packs";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+                assetId: zod.ZodString;
+                solAmount: zod.ZodNumber;
+                rentRefund: zod.ZodString;
+                assetReturnAddress: zod.ZodString;
+                rewardsSplit: zod.ZodArray<zod.ZodObject<{
+                    address: zod.ZodString;
+                    type: zod.ZodEnum<{
+                        fixed: "fixed";
+                        percentage: "percentage";
+                    }>;
+                    amount: zod.ZodNumber;
+                }, zod_v4_core.$strip>>;
+                schedule: zod.ZodObject<{
+                    frequency: zod.ZodEnum<{
+                        daily: "daily";
+                        weekly: "weekly";
+                        monthly: "monthly";
+                    }>;
+                    time: zod.ZodString;
+                    timezone: zod.ZodString;
+                    dayOfWeek: zod.ZodOptional<zod.ZodString>;
+                    dayOfMonth: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+                lazyDistributor: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                welcomePack: zod.ZodObject<{
+                    address: zod.ZodString;
+                    id: zod.ZodNumber;
+                    owner: zod.ZodString;
+                    asset: zod.ZodString;
+                    lazyDistributor: zod.ZodString;
+                    rewardsMint: zod.ZodString;
+                    rentRefund: zod.ZodString;
+                    solAmount: zod.ZodString;
+                    rewardsSplit: zod.ZodArray<zod.ZodObject<{
+                        address: zod.ZodString;
+                        type: zod.ZodEnum<{
+                            fixed: "fixed";
+                            percentage: "percentage";
+                        }>;
+                        amount: zod.ZodNumber;
+                    }, zod_v4_core.$strip>>;
+                    rewardsSchedule: zod.ZodString;
+                    assetReturnAddress: zod.ZodString;
+                    bumpSeed: zod.ZodNumber;
+                    uniqueId: zod.ZodString;
+                    loading: zod.ZodOptional<zod.ZodBoolean>;
+                    hotspot: zod.ZodNullable<zod.ZodObject<{
+                        address: zod.ZodString;
+                        entityKey: zod.ZodString;
+                        name: zod.ZodString;
+                        type: zod.ZodEnum<{
+                            iot: "iot";
+                            mobile: "mobile";
+                            all: "all";
+                        }>;
+                        deviceType: zod.ZodEnum<{
+                            "iot-gateway": "iot-gateway";
+                            wifiIndoor: "wifiIndoor";
+                            wifiOutdoor: "wifiOutdoor";
+                            wifiDataOnly: "wifiDataOnly";
+                            cbrs: "cbrs";
+                        }>;
+                        city: zod.ZodOptional<zod.ZodString>;
+                        state: zod.ZodOptional<zod.ZodString>;
+                        country: zod.ZodOptional<zod.ZodString>;
+                        asset: zod.ZodString;
+                        isOnline: zod.ZodOptional<zod.ZodBoolean>;
+                        owner: zod.ZodOptional<zod.ZodString>;
+                        shares: zod.ZodOptional<zod.ZodObject<{
+                            fixed: zod.ZodOptional<zod.ZodString>;
+                            percentage: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$strip>>;
+                        ownershipType: zod.ZodString;
+                    }, zod_v4_core.$strip>>;
+                }, zod_v4_core.$strip>;
+                transactionData: zod.ZodObject<{
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        serializedTransaction: zod.ZodString;
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                    parallel: zod.ZodBoolean;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid welcome pack configuration";
+                };
+                readonly UNAUTHORIZED: {
+                    readonly status: 401;
+                    readonly message: "Authentication required. Please sign in to continue.";
+                };
+                readonly FORBIDDEN: {
+                    readonly status: 403;
+                    readonly message: "You do not have permission to access this resource.";
+                };
+                readonly NOT_FOUND: {
+                    readonly status: 404;
+                    readonly message: "The requested resource was not found.";
+                };
+                readonly VALIDATION_ERROR: {
+                    readonly status: 400;
+                    readonly message: "Invalid input data provided.";
+                    readonly data: zod.ZodObject<{
+                        fields: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+                    }, zod_v4_core.$strip>;
+                };
+            };
+        };
+        readonly get: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/welcome-packs/{walletAddress}/{packId}";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+                packId: zod.ZodNumber;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                address: zod.ZodString;
+                id: zod.ZodNumber;
+                owner: zod.ZodString;
+                asset: zod.ZodString;
+                lazyDistributor: zod.ZodString;
+                rewardsMint: zod.ZodString;
+                rentRefund: zod.ZodString;
+                solAmount: zod.ZodString;
+                rewardsSplit: zod.ZodArray<zod.ZodObject<{
+                    address: zod.ZodString;
+                    type: zod.ZodEnum<{
+                        fixed: "fixed";
+                        percentage: "percentage";
+                    }>;
+                    amount: zod.ZodNumber;
+                }, zod_v4_core.$strip>>;
+                rewardsSchedule: zod.ZodString;
+                assetReturnAddress: zod.ZodString;
+                bumpSeed: zod.ZodNumber;
+                uniqueId: zod.ZodString;
+                loading: zod.ZodOptional<zod.ZodBoolean>;
+                hotspot: zod.ZodNullable<zod.ZodObject<{
+                    address: zod.ZodString;
+                    entityKey: zod.ZodString;
+                    name: zod.ZodString;
+                    type: zod.ZodEnum<{
+                        iot: "iot";
+                        mobile: "mobile";
+                        all: "all";
+                    }>;
+                    deviceType: zod.ZodEnum<{
+                        "iot-gateway": "iot-gateway";
+                        wifiIndoor: "wifiIndoor";
+                        wifiOutdoor: "wifiOutdoor";
+                        wifiDataOnly: "wifiDataOnly";
+                        cbrs: "cbrs";
+                    }>;
+                    city: zod.ZodOptional<zod.ZodString>;
+                    state: zod.ZodOptional<zod.ZodString>;
+                    country: zod.ZodOptional<zod.ZodString>;
+                    asset: zod.ZodString;
+                    isOnline: zod.ZodOptional<zod.ZodBoolean>;
+                    owner: zod.ZodOptional<zod.ZodString>;
+                    shares: zod.ZodOptional<zod.ZodObject<{
+                        fixed: zod.ZodOptional<zod.ZodString>;
+                        percentage: zod.ZodOptional<zod.ZodNumber>;
+                    }, zod_v4_core.$strip>>;
+                    ownershipType: zod.ZodString;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly NOT_FOUND: {
+                    readonly message: "Welcome pack not found";
+                };
+            };
+        };
+        readonly delete: {
+            readonly route: {
+                readonly method: "DELETE";
+                readonly path: "/welcome-packs/{walletAddress}/{packId}";
+            };
+            readonly input: zod.ZodObject<{
+                walletAddress: zod.ZodString;
+                packId: zod.ZodNumber;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                transactionData: zod.ZodObject<{
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        serializedTransaction: zod.ZodString;
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                    parallel: zod.ZodBoolean;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly NOT_FOUND: {
+                    readonly message: "Welcome pack not found";
+                };
+                readonly UNAUTHORIZED: {
+                    readonly status: 401;
+                    readonly message: "Authentication required. Please sign in to continue.";
+                };
+                readonly FORBIDDEN: {
+                    readonly status: 403;
+                    readonly message: "You do not have permission to access this resource.";
+                };
+                readonly VALIDATION_ERROR: {
+                    readonly status: 400;
+                    readonly message: "Invalid input data provided.";
+                    readonly data: zod.ZodObject<{
+                        fields: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+                    }, zod_v4_core.$strip>;
+                };
+            };
+        };
+        readonly getByAddress: {
+            readonly route: {
+                readonly method: "GET";
+                readonly path: "/welcome-packs/address/{packAddress}";
+            };
+            readonly input: zod.ZodObject<{
+                packAddress: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                address: zod.ZodString;
+                id: zod.ZodNumber;
+                owner: zod.ZodString;
+                asset: zod.ZodString;
+                lazyDistributor: zod.ZodString;
+                rewardsMint: zod.ZodString;
+                rentRefund: zod.ZodString;
+                solAmount: zod.ZodString;
+                rewardsSplit: zod.ZodArray<zod.ZodObject<{
+                    address: zod.ZodString;
+                    type: zod.ZodEnum<{
+                        fixed: "fixed";
+                        percentage: "percentage";
+                    }>;
+                    amount: zod.ZodNumber;
+                }, zod_v4_core.$strip>>;
+                rewardsSchedule: zod.ZodString;
+                assetReturnAddress: zod.ZodString;
+                bumpSeed: zod.ZodNumber;
+                uniqueId: zod.ZodString;
+                loading: zod.ZodOptional<zod.ZodBoolean>;
+                hotspot: zod.ZodNullable<zod.ZodObject<{
+                    address: zod.ZodString;
+                    entityKey: zod.ZodString;
+                    name: zod.ZodString;
+                    type: zod.ZodEnum<{
+                        iot: "iot";
+                        mobile: "mobile";
+                        all: "all";
+                    }>;
+                    deviceType: zod.ZodEnum<{
+                        "iot-gateway": "iot-gateway";
+                        wifiIndoor: "wifiIndoor";
+                        wifiOutdoor: "wifiOutdoor";
+                        wifiDataOnly: "wifiDataOnly";
+                        cbrs: "cbrs";
+                    }>;
+                    city: zod.ZodOptional<zod.ZodString>;
+                    state: zod.ZodOptional<zod.ZodString>;
+                    country: zod.ZodOptional<zod.ZodString>;
+                    asset: zod.ZodString;
+                    isOnline: zod.ZodOptional<zod.ZodBoolean>;
+                    owner: zod.ZodOptional<zod.ZodString>;
+                    shares: zod.ZodOptional<zod.ZodObject<{
+                        fixed: zod.ZodOptional<zod.ZodString>;
+                        percentage: zod.ZodOptional<zod.ZodNumber>;
+                    }, zod_v4_core.$strip>>;
+                    ownershipType: zod.ZodString;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly NOT_FOUND: {
+                    readonly message: "Welcome pack not found";
+                };
+            };
+        };
+        readonly claim: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/welcome-packs/claim";
+            };
+            readonly input: zod.ZodObject<{
+                packAddress: zod.ZodString;
+                walletAddress: zod.ZodString;
+                signature: zod.ZodString;
+                expirationTs: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                transactionData: zod.ZodObject<{
+                    transactions: zod.ZodArray<zod.ZodObject<{
+                        serializedTransaction: zod.ZodString;
+                        metadata: zod.ZodOptional<zod.ZodObject<{
+                            type: zod.ZodString;
+                            description: zod.ZodString;
+                        }, zod_v4_core.$catchall<zod.ZodUnknown>>>;
+                    }, zod_v4_core.$strip>>;
+                    parallel: zod.ZodBoolean;
+                    tag: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strip>;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly BAD_REQUEST: {
+                    readonly message: "Invalid claim parameters";
+                };
+                readonly EXPIRED: {
+                    readonly message: "Claim link has expired";
+                };
+                readonly UNAUTHORIZED: {
+                    readonly status: 401;
+                    readonly message: "Authentication required. Please sign in to continue.";
+                };
+                readonly FORBIDDEN: {
+                    readonly status: 403;
+                    readonly message: "You do not have permission to access this resource.";
+                };
+                readonly NOT_FOUND: {
+                    readonly status: 404;
+                    readonly message: "The requested resource was not found.";
+                };
+                readonly VALIDATION_ERROR: {
+                    readonly status: 400;
+                    readonly message: "Invalid input data provided.";
+                    readonly data: zod.ZodObject<{
+                        fields: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+                    }, zod_v4_core.$strip>;
+                };
+            };
+        };
+        readonly invite: {
+            readonly route: {
+                readonly method: "POST";
+                readonly path: "/welcome-packs/invite";
+            };
+            readonly input: zod.ZodObject<{
+                packAddress: zod.ZodString;
+                walletAddress: zod.ZodString;
+                expirationDays: zod.ZodDefault<zod.ZodNumber>;
+            }, zod_v4_core.$strip>;
+            readonly output: zod.ZodObject<{
+                message: zod.ZodString;
+                expirationTs: zod.ZodNumber;
+            }, zod_v4_core.$strip>;
+            readonly errors: {
+                readonly NOT_FOUND: {
+                    readonly message: "Welcome pack not found";
+                };
+                readonly UNAUTHORIZED: {
+                    readonly status: 401;
+                    readonly message: "Authentication required. Please sign in to continue.";
+                };
+                readonly FORBIDDEN: {
+                    readonly status: 403;
+                    readonly message: "You do not have permission to access this resource.";
+                };
+                readonly VALIDATION_ERROR: {
+                    readonly status: 400;
+                    readonly message: "Invalid input data provided.";
+                    readonly data: zod.ZodObject<{
+                        fields: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+                    }, zod_v4_core.$strip>;
+                };
+            };
+        };
+    };
+};
+type APIContract = typeof apiContract;
+
+/**
+ * Utility types to infer client interface from contract definitions.
+ * This provides full type safety derived from Zod schemas.
+ */
+type ContractProcedureWithInput = {
+    input: z.ZodTypeAny;
+    output: z.ZodTypeAny;
+};
+type ContractProcedureWithoutInput = {
+    output: z.ZodTypeAny;
+};
+type ContractProcedure = ContractProcedureWithInput | ContractProcedureWithoutInput;
+type InferProcedure<T> = T extends ContractProcedureWithInput ? (input: z.input<T["input"]>) => Promise<z.output<T["output"]>> : T extends ContractProcedureWithoutInput ? () => Promise<z.output<T["output"]>> : never;
+type InferRouter<T> = {
+    [K in keyof T]: T[K] extends ContractProcedure ? InferProcedure<T[K]> : T[K] extends Record<string, ContractProcedure> ? {
+        [P in keyof T[K]]: InferProcedure<T[K][P]>;
+    } : never;
+};
+/**
+ * Fully typed API client interface inferred from contract definitions.
+ * Types automatically stay in sync with schema changes.
+ */
+type APIRouter = InferRouter<typeof apiContract>;
+/**
+ * Create a typed client for the Helium Blockchain API.
+ *
+ * All consumer-facing endpoints are public and don't require authentication.
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from '@helium/blockchain-api';
+ *
+ * const client = createClient({ url: 'https://api.helium.com' });
+ *
+ * const balances = await client.tokens.getBalances({ walletAddress: '...' });
+ * const hotspots = await client.hotspots.getHotspots({ walletAddress: '...' });
+ * const quote = await client.swap.getQuote({ inputMint: '...', outputMint: '...', amount: 1000 });
+ * ```
+ */
+declare function createClient(options: ClientOptions): APIRouter;
+
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends (...args: infer A) => infer R ? (...args: A) => R | Promise<Awaited<R>> : T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/**
+ * Mock implementation overrides for testing.
+ */
+type MockImplementation = DeepPartial<APIRouter>;
+/**
+ * Create a mock client for testing purposes.
+ * Provides typed mock implementations that can be used in unit tests.
+ *
+ * @example
+ * ```typescript
+ * const mockClient = createMockClient({
+ *   tokens: {
+ *     getBalances: async () => ({
+ *       totalBalanceUsd: 100,
+ *       solBalance: 1,
+ *       solBalanceUsd: 50,
+ *       tokens: [{ mint: 'HNT...', balance: '1000000', ... }]
+ *     })
+ *   },
+ *   health: {
+ *     check: async () => ({ ok: true })
+ *   }
+ * });
+ *
+ * const result = await mockClient.tokens.getBalances({ walletAddress: '...' });
+ * expect(result.totalBalanceUsd).toBe(100);
+ * ```
+ */
+declare function createMockClient(mocks?: MockImplementation): APIRouter;
+
+interface OpenAPIInfo {
+    title: string;
+    version: string;
+    description?: string;
+}
+interface OpenAPISpec {
+    openapi: string;
+    info: OpenAPIInfo;
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    paths: Record<string, unknown>;
+    components: {
+        schemas: Record<string, unknown>;
+    };
+}
+/**
+ * Generate an OpenAPI 3.0 specification from the API contract.
+ *
+ * @example
+ * ```typescript
+ * const spec = generateOpenAPISpec({
+ *   title: 'Helium Blockchain API',
+ *   version: '1.0.0',
+ *   servers: [{ url: 'https://api.helium.com' }]
+ * });
+ *
+ * // Write to file
+ * fs.writeFileSync('openapi.json', JSON.stringify(spec, null, 2));
+ * ```
+ */
+declare function generateOpenAPISpec(options: {
+    info?: Partial<OpenAPIInfo>;
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+}): OpenAPISpec;
+/**
+ * Get the API contract for inspection or custom processing.
+ */
+declare function getAPIContract(): APIContract;
+
+/**
+ * Metadata associated with a transaction for tracking and display purposes.
+ */
+declare const TransactionMetadataSchema: z.ZodObject<{
+    type: z.ZodString;
+    description: z.ZodString;
+}, z.core.$catchall<z.ZodUnknown>>;
+/**
+ * A single transaction item with serialized data and optional metadata.
+ */
+declare const TransactionItemSchema: z.ZodObject<{
+    serializedTransaction: z.ZodString;
+    metadata: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strip>;
+/**
+ * Transaction data returned by procedures that create transactions.
+ * Contains serialized transactions ready for signing and submission.
+ */
+declare const TransactionDataSchema: z.ZodObject<{
+    transactions: z.ZodArray<z.ZodObject<{
+        serializedTransaction: z.ZodString;
+        metadata: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+    parallel: z.ZodBoolean;
+    tag: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Request schema for submitting a batch of transactions.
+ */
+declare const TransactionBatchRequestSchema: z.ZodObject<{
+    transactions: z.ZodArray<z.ZodObject<{
+        serializedTransaction: z.ZodString;
+        metadata: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+    parallel: z.ZodBoolean;
+    tag: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Response schema for transaction batch submission.
+ */
+declare const TransactionBatchResponseSchema: z.ZodObject<{
+    batchId: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Standard error response schema.
+ */
+declare const ErrorResponseSchema: z.ZodObject<{
+    error: z.ZodString;
+    details: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Solana wallet address validation.
+ */
+declare const WalletAddressSchema: z.ZodString;
+/**
+ * Solana public key validation (base58 encoded).
+ */
+declare const PublicKeySchema: z.ZodString;
+/**
+ * Standard pagination input schema.
+ */
+declare const PaginationInputSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/**
+ * Standard pagination output schema.
+ */
+declare const PaginationOutputSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    page: z.ZodNumber;
+    totalPages: z.ZodNumber;
+}, z.core.$strip>;
+type TransactionMetadata = z.infer<typeof TransactionMetadataSchema>;
+type TransactionItem = z.infer<typeof TransactionItemSchema>;
+type TransactionData = z.infer<typeof TransactionDataSchema>;
+type TransactionBatchRequest = z.infer<typeof TransactionBatchRequestSchema>;
+type TransactionBatchResponse = z.infer<typeof TransactionBatchResponseSchema>;
+type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+
+declare const HealthResponseSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type HealthResponse = z.infer<typeof HealthResponseSchema>;
+
+declare const GetBalancesInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+}, z.core.$strip>;
+declare const TransferInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    mint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    destination: z.ZodString;
+    amount: z.ZodString;
+    decimals: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const CreateHntAccountInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+}, z.core.$strip>;
+declare const TokenAccountSchema: z.ZodObject<{
+    mint: z.ZodString;
+    address: z.ZodString;
+    balance: z.ZodString;
+    decimals: z.ZodNumber;
+    uiAmount: z.ZodNumber;
+    symbol: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    logoURI: z.ZodOptional<z.ZodString>;
+    priceUsd: z.ZodOptional<z.ZodNumber>;
+    balanceUsd: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const TokenBalanceDataSchema: z.ZodObject<{
+    totalBalanceUsd: z.ZodNumber;
+    solBalance: z.ZodNumber;
+    solBalanceUsd: z.ZodNumber;
+    tokens: z.ZodArray<z.ZodObject<{
+        mint: z.ZodString;
+        address: z.ZodString;
+        balance: z.ZodString;
+        decimals: z.ZodNumber;
+        uiAmount: z.ZodNumber;
+        symbol: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        logoURI: z.ZodOptional<z.ZodString>;
+        priceUsd: z.ZodOptional<z.ZodNumber>;
+        balanceUsd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const TransferOutputSchema: z.ZodObject<{
+    transactionData: z.ZodObject<{
+        transactions: z.ZodArray<z.ZodObject<{
+            serializedTransaction: z.ZodString;
+            metadata: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        parallel: z.ZodBoolean;
+        tag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const CreateHntAccountOutputSchema: z.ZodObject<{
+    transactionData: z.ZodObject<{
+        transactions: z.ZodArray<z.ZodObject<{
+            serializedTransaction: z.ZodString;
+            metadata: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        parallel: z.ZodBoolean;
+        tag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type GetBalancesInput = z.infer<typeof GetBalancesInputSchema>;
+type TransferInput = z.infer<typeof TransferInputSchema>;
+type CreateHntAccountInput = z.infer<typeof CreateHntAccountInputSchema>;
+type TokenAccount = z.infer<typeof TokenAccountSchema>;
+type TokenBalanceData = z.infer<typeof TokenBalanceDataSchema>;
+type TransferOutput = z.infer<typeof TransferOutputSchema>;
+type CreateHntAccountOutput = z.infer<typeof CreateHntAccountOutputSchema>;
+
+declare const HotspotTypeSchema: z.ZodEnum<{
+    iot: "iot";
+    mobile: "mobile";
+    all: "all";
+}>;
+declare const DeviceTypeSchema: z.ZodEnum<{
+    "iot-gateway": "iot-gateway";
+    wifiIndoor: "wifiIndoor";
+    wifiOutdoor: "wifiOutdoor";
+    wifiDataOnly: "wifiDataOnly";
+    cbrs: "cbrs";
+}>;
+declare const OwnershipTypeSchema: z.ZodEnum<{
+    all: "all";
+    owner: "owner";
+    direct: "direct";
+    fanout: "fanout";
+}>;
+declare const HotspotSharesSchema: z.ZodObject<{
+    fixed: z.ZodOptional<z.ZodString>;
+    percentage: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const HotspotSchema: z.ZodObject<{
+    address: z.ZodString;
+    entityKey: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        iot: "iot";
+        mobile: "mobile";
+        all: "all";
+    }>;
+    deviceType: z.ZodEnum<{
+        "iot-gateway": "iot-gateway";
+        wifiIndoor: "wifiIndoor";
+        wifiOutdoor: "wifiOutdoor";
+        wifiDataOnly: "wifiDataOnly";
+        cbrs: "cbrs";
+    }>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    country: z.ZodOptional<z.ZodString>;
+    asset: z.ZodString;
+    isOnline: z.ZodOptional<z.ZodBoolean>;
+    owner: z.ZodOptional<z.ZodString>;
+    shares: z.ZodOptional<z.ZodObject<{
+        fixed: z.ZodOptional<z.ZodString>;
+        percentage: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    ownershipType: z.ZodString;
+}, z.core.$strip>;
+declare const GetHotspotsInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    type: z.ZodOptional<z.ZodEnum<{
+        iot: "iot";
+        mobile: "mobile";
+        all: "all";
+    }>>;
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const ClaimRewardsInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+}, z.core.$strip>;
+declare const GetPendingRewardsInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+}, z.core.$strip>;
+declare const TransferHotspotInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    hotspotPubkey: z.ZodString;
+    recipient: z.ZodString;
+}, z.core.$strip>;
+declare const UpdateRewardsDestinationInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    hotspotPubkey: z.ZodString;
+    destination: z.ZodString;
+    lazyDistributors: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const GetSplitInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    hotspotPubkey: z.ZodString;
+}, z.core.$strip>;
+declare const RewardSplitInputSchema: z.ZodObject<{
+    address: z.ZodString;
+    type: z.ZodEnum<{
+        fixed: "fixed";
+        percentage: "percentage";
+    }>;
+    amount: z.ZodNumber;
+}, z.core.$strip>;
+declare const ScheduleInputSchema: z.ZodObject<{
+    frequency: z.ZodEnum<{
+        daily: "daily";
+        weekly: "weekly";
+        monthly: "monthly";
+    }>;
+    time: z.ZodString;
+    timezone: z.ZodString;
+    dayOfWeek: z.ZodOptional<z.ZodString>;
+    dayOfMonth: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const CreateSplitInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    hotspotPubkey: z.ZodString;
+    rewardsSplit: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        type: z.ZodEnum<{
+            fixed: "fixed";
+            percentage: "percentage";
+        }>;
+        amount: z.ZodNumber;
+    }, z.core.$strip>>;
+    schedule: z.ZodObject<{
+        frequency: z.ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+        }>;
+        time: z.ZodString;
+        timezone: z.ZodString;
+        dayOfWeek: z.ZodOptional<z.ZodString>;
+        dayOfMonth: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    lazyDistributor: z.ZodString;
+}, z.core.$strip>;
+declare const DeleteSplitInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    hotspotPubkey: z.ZodString;
+}, z.core.$strip>;
+declare const HotspotsDataSchema: z.ZodObject<{
+    hotspots: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        entityKey: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            iot: "iot";
+            mobile: "mobile";
+            all: "all";
+        }>;
+        deviceType: z.ZodEnum<{
+            "iot-gateway": "iot-gateway";
+            wifiIndoor: "wifiIndoor";
+            wifiOutdoor: "wifiOutdoor";
+            wifiDataOnly: "wifiDataOnly";
+            cbrs: "cbrs";
+        }>;
+        city: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        country: z.ZodOptional<z.ZodString>;
+        asset: z.ZodString;
+        isOnline: z.ZodOptional<z.ZodBoolean>;
+        owner: z.ZodOptional<z.ZodString>;
+        shares: z.ZodOptional<z.ZodObject<{
+            fixed: z.ZodOptional<z.ZodString>;
+            percentage: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        ownershipType: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    page: z.ZodNumber;
+    totalPages: z.ZodNumber;
+}, z.core.$strip>;
+declare const ClaimRewardsOutputSchema: z.ZodObject<{
+    transactionData: z.ZodObject<{
+        transactions: z.ZodArray<z.ZodObject<{
+            serializedTransaction: z.ZodString;
+            metadata: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        parallel: z.ZodBoolean;
+        tag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const TransferHotspotOutputSchema: z.ZodObject<{
+    transactionData: z.ZodObject<{
+        transactions: z.ZodArray<z.ZodObject<{
+            serializedTransaction: z.ZodString;
+            metadata: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        parallel: z.ZodBoolean;
+        tag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const UpdateRewardsDestinationOutputSchema: z.ZodObject<{
+    transactionData: z.ZodObject<{
+        transactions: z.ZodArray<z.ZodObject<{
+            serializedTransaction: z.ZodString;
+            metadata: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        parallel: z.ZodBoolean;
+        tag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const SplitShareSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    delegate: z.ZodString;
+    fixed: z.ZodNumber;
+    shares: z.ZodNumber;
+}, z.core.$strip>;
+declare const SplitResponseSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    hotspotPubkey: z.ZodString;
+    splitAddress: z.ZodString;
+    shares: z.ZodArray<z.ZodObject<{
+        wallet: z.ZodString;
+        delegate: z.ZodString;
+        fixed: z.ZodNumber;
+        shares: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const CreateSplitOutputSchema: z.ZodObject<{
+    transactionData: z.ZodObject<{
+        transactions: z.ZodArray<z.ZodObject<{
+            serializedTransaction: z.ZodString;
+            metadata: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        parallel: z.ZodBoolean;
+        tag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const DeleteSplitOutputSchema: z.ZodObject<{
+    transactionData: z.ZodObject<{
+        transactions: z.ZodArray<z.ZodObject<{
+            serializedTransaction: z.ZodString;
+            metadata: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        parallel: z.ZodBoolean;
+        tag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const PendingRewardsOutputSchema: z.ZodObject<{
+    pending: z.ZodString;
+}, z.core.$strip>;
+type HotspotType = z.infer<typeof HotspotTypeSchema>;
+type DeviceType = z.infer<typeof DeviceTypeSchema>;
+type OwnershipType = z.infer<typeof OwnershipTypeSchema>;
+type Hotspot = z.infer<typeof HotspotSchema>;
+type HotspotsData = z.infer<typeof HotspotsDataSchema>;
+type GetHotspotsInput = z.infer<typeof GetHotspotsInputSchema>;
+type ClaimRewardsInput = z.infer<typeof ClaimRewardsInputSchema>;
+type GetPendingRewardsInput = z.infer<typeof GetPendingRewardsInputSchema>;
+type TransferHotspotInput = z.infer<typeof TransferHotspotInputSchema>;
+type UpdateRewardsDestinationInput = z.infer<typeof UpdateRewardsDestinationInputSchema>;
+type GetSplitInput = z.infer<typeof GetSplitInputSchema>;
+type CreateSplitInput = z.infer<typeof CreateSplitInputSchema>;
+type DeleteSplitInput = z.infer<typeof DeleteSplitInputSchema>;
+type RewardSplitInput = z.infer<typeof RewardSplitInputSchema>;
+type ScheduleInput = z.infer<typeof ScheduleInputSchema>;
+type SplitShare = z.infer<typeof SplitShareSchema>;
+type SplitResponse = z.infer<typeof SplitResponseSchema>;
+type PendingRewardsOutput = z.infer<typeof PendingRewardsOutputSchema>;
+
+declare const GetTokensInputSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const GetQuoteInputSchema: z.ZodObject<{
+    inputMint: z.ZodString;
+    outputMint: z.ZodString;
+    amount: z.ZodString;
+    swapMode: z.ZodDefault<z.ZodEnum<{
+        ExactIn: "ExactIn";
+        ExactOut: "ExactOut";
+    }>>;
+    slippageBps: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const QuoteResponseSchema: z.ZodObject<{
+    inputMint: z.ZodString;
+    inAmount: z.ZodString;
+    outputMint: z.ZodString;
+    outAmount: z.ZodString;
+    otherAmountThreshold: z.ZodString;
+    swapMode: z.ZodString;
+    slippageBps: z.ZodNumber;
+    platformFee: z.ZodOptional<z.ZodUnknown>;
+    priceImpactPct: z.ZodString;
+    routePlan: z.ZodArray<z.ZodUnknown>;
+    contextSlot: z.ZodOptional<z.ZodNumber>;
+    timeTaken: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+declare const GetInstructionsInputSchema: z.ZodObject<{
+    quoteResponse: z.ZodObject<{
+        inputMint: z.ZodString;
+        inAmount: z.ZodString;
+        outputMint: z.ZodString;
+        outAmount: z.ZodString;
+        otherAmountThreshold: z.ZodString;
+        swapMode: z.ZodString;
+        slippageBps: z.ZodNumber;
+        platformFee: z.ZodOptional<z.ZodUnknown>;
+        priceImpactPct: z.ZodString;
+        routePlan: z.ZodArray<z.ZodUnknown>;
+        contextSlot: z.ZodOptional<z.ZodNumber>;
+        timeTaken: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>;
+    userPublicKey: z.ZodString;
+    destinationTokenAccount: z.ZodOptional<z.ZodString>;
+    dynamicComputeUnitLimit: z.ZodDefault<z.ZodBoolean>;
+    prioritizationFeeLamports: z.ZodOptional<z.ZodObject<{
+        priorityLevelWithMaxLamports: z.ZodObject<{
+            maxLamports: z.ZodDefault<z.ZodNumber>;
+            priorityLevel: z.ZodDefault<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const TokenSchema: z.ZodObject<{
+    address: z.ZodString;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    logoURI: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const TokenListOutputSchema: z.ZodObject<{
+    tokens: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        symbol: z.ZodString;
+        name: z.ZodString;
+        decimals: z.ZodNumber;
+        logoURI: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const SwapTransactionDataSchema: z.ZodObject<{
+    transactions: z.ZodArray<z.ZodObject<{
+        serializedTransaction: z.ZodString;
+        metadata: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+    parallel: z.ZodBoolean;
+    tag: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GetTokensInput = z.infer<typeof GetTokensInputSchema>;
+type GetQuoteInput = z.infer<typeof GetQuoteInputSchema>;
+type GetInstructionsInput = z.infer<typeof GetInstructionsInputSchema>;
+type QuoteResponse = z.infer<typeof QuoteResponseSchema>;
+type Token = z.infer<typeof TokenSchema>;
+type TokenListOutput = z.infer<typeof TokenListOutputSchema>;
+
+declare const SubmitInputSchema: z.ZodObject<{
+    transactions: z.ZodArray<z.ZodObject<{
+        serializedTransaction: z.ZodString;
+        metadata: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+    parallel: z.ZodBoolean;
+    tag: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const GetInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    commitment: z.ZodEnum<{
+        confirmed: "confirmed";
+        finalized: "finalized";
+    }>;
+}, z.core.$strip>;
+declare const ResubmitInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+declare const GetByPayerInputSchema: z.ZodObject<{
+    payer: z.ZodString;
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    status: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+declare const GetByPayerAndTagInputSchema: z.ZodObject<{
+    payer: z.ZodString;
+    tag: z.ZodString;
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    status: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+declare const SubmitOutputSchema: z.ZodObject<{
+    batchId: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const TransactionStatusSchema: z.ZodObject<{
+    signature: z.ZodString;
+    status: z.ZodString;
+    transaction: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const BatchStatusOutputSchema: z.ZodObject<{
+    batchId: z.ZodString;
+    status: z.ZodString;
+    submissionType: z.ZodString;
+    parallel: z.ZodBoolean;
+    transactions: z.ZodArray<z.ZodObject<{
+        signature: z.ZodString;
+        status: z.ZodString;
+        transaction: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+    jitoBundleId: z.ZodOptional<z.ZodString>;
+    jitoBundleStatus: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const ResubmitOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+    newSignatures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const PayerBatchSummarySchema: z.ZodObject<{
+    batchId: z.ZodString;
+    tag: z.ZodOptional<z.ZodString>;
+    status: z.ZodString;
+    submissionType: z.ZodString;
+    parallel: z.ZodBoolean;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    transactions: z.ZodArray<z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$catchall<z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const PayerBatchesOutputSchema: z.ZodObject<{
+    payer: z.ZodString;
+    batches: z.ZodArray<z.ZodObject<{
+        batchId: z.ZodString;
+        tag: z.ZodOptional<z.ZodString>;
+        status: z.ZodString;
+        submissionType: z.ZodString;
+        parallel: z.ZodBoolean;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        transactions: z.ZodArray<z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        page: z.ZodNumber;
+        limit: z.ZodNumber;
+        total: z.ZodNumber;
+        totalPages: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type SubmitInput = z.infer<typeof SubmitInputSchema>;
+type GetInput = z.infer<typeof GetInputSchema>;
+type ResubmitInput = z.infer<typeof ResubmitInputSchema>;
+type GetByPayerInput = z.infer<typeof GetByPayerInputSchema>;
+type GetByPayerAndTagInput = z.infer<typeof GetByPayerAndTagInputSchema>;
+type SubmitOutput = z.infer<typeof SubmitOutputSchema>;
+type BatchStatusOutput = z.infer<typeof BatchStatusOutputSchema>;
+type ResubmitOutput = z.infer<typeof ResubmitOutputSchema>;
+type PayerBatchesOutput = z.infer<typeof PayerBatchesOutputSchema>;
+type TransactionStatus = z.infer<typeof TransactionStatusSchema>;
+type PayerBatchSummary = z.infer<typeof PayerBatchSummarySchema>;
+
+declare const WelcomePackListInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+}, z.core.$strip>;
+declare const WelcomePackCreateInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    assetId: z.ZodString;
+    solAmount: z.ZodNumber;
+    rentRefund: z.ZodString;
+    assetReturnAddress: z.ZodString;
+    rewardsSplit: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        type: z.ZodEnum<{
+            fixed: "fixed";
+            percentage: "percentage";
+        }>;
+        amount: z.ZodNumber;
+    }, z.core.$strip>>;
+    schedule: z.ZodObject<{
+        frequency: z.ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+        }>;
+        time: z.ZodString;
+        timezone: z.ZodString;
+        dayOfWeek: z.ZodOptional<z.ZodString>;
+        dayOfMonth: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    lazyDistributor: z.ZodString;
+}, z.core.$strip>;
+declare const WelcomePackGetInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    packId: z.ZodNumber;
+}, z.core.$strip>;
+declare const WelcomePackDeleteInputSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    packId: z.ZodNumber;
+}, z.core.$strip>;
+declare const WelcomePackGetByAddressInputSchema: z.ZodObject<{
+    packAddress: z.ZodString;
+}, z.core.$strip>;
+declare const WelcomePackClaimInputSchema: z.ZodObject<{
+    packAddress: z.ZodString;
+    walletAddress: z.ZodString;
+    signature: z.ZodString;
+    expirationTs: z.ZodString;
+}, z.core.$strip>;
+declare const WelcomePackInviteInputSchema: z.ZodObject<{
+    packAddress: z.ZodString;
+    walletAddress: z.ZodString;
+    expirationDays: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const WelcomePackSchema: z.ZodObject<{
+    address: z.ZodString;
+    id: z.ZodNumber;
+    owner: z.ZodString;
+    asset: z.ZodString;
+    lazyDistributor: z.ZodString;
+    rewardsMint: z.ZodString;
+    rentRefund: z.ZodString;
+    solAmount: z.ZodString;
+    rewardsSplit: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        type: z.ZodEnum<{
+            fixed: "fixed";
+            percentage: "percentage";
+        }>;
+        amount: z.ZodNumber;
+    }, z.core.$strip>>;
+    rewardsSchedule: z.ZodString;
+    assetReturnAddress: z.ZodString;
+    bumpSeed: z.ZodNumber;
+    uniqueId: z.ZodString;
+    loading: z.ZodOptional<z.ZodBoolean>;
+    hotspot: z.ZodNullable<z.ZodObject<{
+        address: z.ZodString;
+        entityKey: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            iot: "iot";
+            mobile: "mobile";
+            all: "all";
+        }>;
+        deviceType: z.ZodEnum<{
+            "iot-gateway": "iot-gateway";
+            wifiIndoor: "wifiIndoor";
+            wifiOutdoor: "wifiOutdoor";
+            wifiDataOnly: "wifiDataOnly";
+            cbrs: "cbrs";
+        }>;
+        city: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        country: z.ZodOptional<z.ZodString>;
+        asset: z.ZodString;
+        isOnline: z.ZodOptional<z.ZodBoolean>;
+        owner: z.ZodOptional<z.ZodString>;
+        shares: z.ZodOptional<z.ZodObject<{
+            fixed: z.ZodOptional<z.ZodString>;
+            percentage: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        ownershipType: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const WelcomePackListOutputSchema: z.ZodArray<z.ZodObject<{
+    address: z.ZodString;
+    id: z.ZodNumber;
+    owner: z.ZodString;
+    asset: z.ZodString;
+    lazyDistributor: z.ZodString;
+    rewardsMint: z.ZodString;
+    rentRefund: z.ZodString;
+    solAmount: z.ZodString;
+    rewardsSplit: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        type: z.ZodEnum<{
+            fixed: "fixed";
+            percentage: "percentage";
+        }>;
+        amount: z.ZodNumber;
+    }, z.core.$strip>>;
+    rewardsSchedule: z.ZodString;
+    assetReturnAddress: z.ZodString;
+    bumpSeed: z.ZodNumber;
+    uniqueId: z.ZodString;
+    loading: z.ZodOptional<z.ZodBoolean>;
+    hotspot: z.ZodNullable<z.ZodObject<{
+        address: z.ZodString;
+        entityKey: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            iot: "iot";
+            mobile: "mobile";
+            all: "all";
+        }>;
+        deviceType: z.ZodEnum<{
+            "iot-gateway": "iot-gateway";
+            wifiIndoor: "wifiIndoor";
+            wifiOutdoor: "wifiOutdoor";
+            wifiDataOnly: "wifiDataOnly";
+            cbrs: "cbrs";
+        }>;
+        city: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        country: z.ZodOptional<z.ZodString>;
+        asset: z.ZodString;
+        isOnline: z.ZodOptional<z.ZodBoolean>;
+        owner: z.ZodOptional<z.ZodString>;
+        shares: z.ZodOptional<z.ZodObject<{
+            fixed: z.ZodOptional<z.ZodString>;
+            percentage: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        ownershipType: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+declare const WelcomePackCreateOutputSchema: z.ZodObject<{
+    welcomePack: z.ZodObject<{
+        address: z.ZodString;
+        id: z.ZodNumber;
+        owner: z.ZodString;
+        asset: z.ZodString;
+        lazyDistributor: z.ZodString;
+        rewardsMint: z.ZodString;
+        rentRefund: z.ZodString;
+        solAmount: z.ZodString;
+        rewardsSplit: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            type: z.ZodEnum<{
+                fixed: "fixed";
+                percentage: "percentage";
+            }>;
+            amount: z.ZodNumber;
+        }, z.core.$strip>>;
+        rewardsSchedule: z.ZodString;
+        assetReturnAddress: z.ZodString;
+        bumpSeed: z.ZodNumber;
+        uniqueId: z.ZodString;
+        loading: z.ZodOptional<z.ZodBoolean>;
+        hotspot: z.ZodNullable<z.ZodObject<{
+            address: z.ZodString;
+            entityKey: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                iot: "iot";
+                mobile: "mobile";
+                all: "all";
+            }>;
+            deviceType: z.ZodEnum<{
+                "iot-gateway": "iot-gateway";
+                wifiIndoor: "wifiIndoor";
+                wifiOutdoor: "wifiOutdoor";
+                wifiDataOnly: "wifiDataOnly";
+                cbrs: "cbrs";
+            }>;
+            city: z.ZodOptional<z.ZodString>;
+            state: z.ZodOptional<z.ZodString>;
+            country: z.ZodOptional<z.ZodString>;
+            asset: z.ZodString;
+            isOnline: z.ZodOptional<z.ZodBoolean>;
+            owner: z.ZodOptional<z.ZodString>;
+            shares: z.ZodOptional<z.ZodObject<{
+                fixed: z.ZodOptional<z.ZodString>;
+                percentage: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            ownershipType: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    transactionData: z.ZodObject<{
+        transactions: z.ZodArray<z.ZodObject<{
+            serializedTransaction: z.ZodString;
+            metadata: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        parallel: z.ZodBoolean;
+        tag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const WelcomePackDeleteOutputSchema: z.ZodObject<{
+    transactionData: z.ZodObject<{
+        transactions: z.ZodArray<z.ZodObject<{
+            serializedTransaction: z.ZodString;
+            metadata: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        parallel: z.ZodBoolean;
+        tag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const WelcomePackClaimOutputSchema: z.ZodObject<{
+    transactionData: z.ZodObject<{
+        transactions: z.ZodArray<z.ZodObject<{
+            serializedTransaction: z.ZodString;
+            metadata: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        parallel: z.ZodBoolean;
+        tag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const WelcomePackInviteOutputSchema: z.ZodObject<{
+    message: z.ZodString;
+    expirationTs: z.ZodNumber;
+}, z.core.$strip>;
+type WelcomePackListInput = z.infer<typeof WelcomePackListInputSchema>;
+type WelcomePackCreateInput = z.infer<typeof WelcomePackCreateInputSchema>;
+type WelcomePackGetInput = z.infer<typeof WelcomePackGetInputSchema>;
+type WelcomePackDeleteInput = z.infer<typeof WelcomePackDeleteInputSchema>;
+type WelcomePackGetByAddressInput = z.infer<typeof WelcomePackGetByAddressInputSchema>;
+type WelcomePackClaimInput = z.infer<typeof WelcomePackClaimInputSchema>;
+type WelcomePackInviteInput = z.infer<typeof WelcomePackInviteInputSchema>;
+type WelcomePack = z.infer<typeof WelcomePackSchema>;
+type WelcomePackListOutput = z.infer<typeof WelcomePackListOutputSchema>;
+type WelcomePackCreateOutput = z.infer<typeof WelcomePackCreateOutputSchema>;
+type WelcomePackDeleteOutput = z.infer<typeof WelcomePackDeleteOutputSchema>;
+type WelcomePackClaimOutput = z.infer<typeof WelcomePackClaimOutputSchema>;
+type WelcomePackInviteOutput = z.infer<typeof WelcomePackInviteOutputSchema>;
+
+/** Authentication required error */
+declare const UNAUTHORIZED: {
+    readonly status: 401;
+    readonly message: "Authentication required. Please sign in to continue.";
+};
+/** Insufficient permissions error */
+declare const FORBIDDEN: {
+    readonly status: 403;
+    readonly message: "You do not have permission to access this resource.";
+};
+/** Resource not found error */
+declare const NOT_FOUND: {
+    readonly status: 404;
+    readonly message: "The requested resource was not found.";
+};
+/** Input validation failed error */
+declare const VALIDATION_ERROR: {
+    readonly status: 400;
+    readonly message: "Invalid input data provided.";
+    readonly data: z.ZodObject<{
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+};
+/** Rate limit exceeded error */
+declare const RATE_LIMITED: {
+    readonly status: 429;
+    readonly message: "Too many requests. Please try again later.";
+};
+/** Duplicate resource error */
+declare const CONFLICT: {
+    readonly status: 409;
+    readonly message: "A resource with this identifier already exists.";
+    readonly data: z.ZodObject<{
+        existingId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+/**
+ * Common error definitions that can be spread into procedure error configs.
+ */
+declare const commonErrors: {
+    readonly UNAUTHORIZED: {
+        readonly status: 401;
+        readonly message: "Authentication required. Please sign in to continue.";
+    };
+    readonly FORBIDDEN: {
+        readonly status: 403;
+        readonly message: "You do not have permission to access this resource.";
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly message: "The requested resource was not found.";
+    };
+    readonly VALIDATION_ERROR: {
+        readonly status: 400;
+        readonly message: "Invalid input data provided.";
+        readonly data: z.ZodObject<{
+            fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    };
+};
+
+/** Insufficient Solana balance error */
+declare const INSUFFICIENT_FUNDS: {
+    readonly status: 400;
+    readonly message: "Insufficient SOL balance to complete this transaction.";
+    readonly data: z.ZodObject<{
+        required: z.ZodNumber;
+        available: z.ZodNumber;
+    }, z.core.$strip>;
+};
+/** Solana transaction failed error */
+declare const TRANSACTION_FAILED: {
+    readonly status: 500;
+    readonly message: "Transaction failed to execute.";
+    readonly data: z.ZodObject<{
+        logs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        signature: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+/** Transaction simulation failed error */
+declare const SIMULATION_FAILED: {
+    readonly status: 400;
+    readonly message: "Transaction simulation failed.";
+    readonly data: z.ZodObject<{
+        logs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        link: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+/**
+ * Solana-specific error definitions for transaction-related procedures.
+ */
+declare const solanaErrors: {
+    readonly INSUFFICIENT_FUNDS: {
+        readonly status: 400;
+        readonly message: "Insufficient SOL balance to complete this transaction.";
+        readonly data: z.ZodObject<{
+            required: z.ZodNumber;
+            available: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly TRANSACTION_FAILED: {
+        readonly status: 500;
+        readonly message: "Transaction failed to execute.";
+        readonly data: z.ZodObject<{
+            logs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            signature: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly SIMULATION_FAILED: {
+        readonly status: 400;
+        readonly message: "Transaction simulation failed.";
+        readonly data: z.ZodObject<{
+            logs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            link: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+};
+
+/** Asset not owned by wallet error */
+declare const NOT_OWNER: {
+    readonly status: 403;
+    readonly message: "You do not own this asset.";
+    readonly data: z.ZodObject<{
+        owner: z.ZodString;
+        wallet: z.ZodString;
+    }, z.core.$strip>;
+};
+/** Invalid Helium hotspot error */
+declare const INVALID_HOTSPOT: {
+    readonly status: 400;
+    readonly message: "The specified asset is not a valid Helium hotspot.";
+};
+/**
+ * Hotspot-specific error definitions.
+ */
+declare const hotspotErrors: {
+    readonly NOT_OWNER: {
+        readonly status: 403;
+        readonly message: "You do not own this asset.";
+        readonly data: z.ZodObject<{
+            owner: z.ZodString;
+            wallet: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly INVALID_HOTSPOT: {
+        readonly status: 400;
+        readonly message: "The specified asset is not a valid Helium hotspot.";
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly message: "The requested resource was not found.";
+    };
+};
+
+export { type APIContract, type APIRouter, type BatchStatusOutput, BatchStatusOutputSchema, CONFLICT, type ClaimRewardsInput, ClaimRewardsInputSchema, ClaimRewardsOutputSchema, type ClientOptions, type CreateHntAccountInput, CreateHntAccountInputSchema, type CreateHntAccountOutput, CreateHntAccountOutputSchema, type CreateSplitInput, CreateSplitInputSchema, CreateSplitOutputSchema, type DeleteSplitInput, DeleteSplitInputSchema, DeleteSplitOutputSchema, type DeviceType, DeviceTypeSchema, type ErrorResponse, ErrorResponseSchema, FORBIDDEN, type GetBalancesInput, GetBalancesInputSchema, type GetByPayerAndTagInput, GetByPayerAndTagInputSchema, type GetByPayerInput, GetByPayerInputSchema, type GetHotspotsInput, GetHotspotsInputSchema, type GetInput, GetInputSchema, type GetInstructionsInput, GetInstructionsInputSchema, type GetPendingRewardsInput, GetPendingRewardsInputSchema, type GetQuoteInput, GetQuoteInputSchema, type GetSplitInput, GetSplitInputSchema, type GetTokensInput, GetTokensInputSchema, type HealthResponse, HealthResponseSchema, type Hotspot, HotspotSchema, HotspotSharesSchema, type HotspotType, HotspotTypeSchema, type HotspotsData, HotspotsDataSchema, INSUFFICIENT_FUNDS, INVALID_HOTSPOT, type MockImplementation, NOT_FOUND, NOT_OWNER, type OwnershipType, OwnershipTypeSchema, PaginationInputSchema, PaginationOutputSchema, type PayerBatchSummary, PayerBatchSummarySchema, type PayerBatchesOutput, PayerBatchesOutputSchema, type PendingRewardsOutput, PendingRewardsOutputSchema, PublicKeySchema, type QuoteResponse, QuoteResponseSchema, RATE_LIMITED, type ResubmitInput, ResubmitInputSchema, type ResubmitOutput, ResubmitOutputSchema, type RewardSplitInput, RewardSplitInputSchema, SIMULATION_FAILED, type ScheduleInput, ScheduleInputSchema, type SplitResponse, SplitResponseSchema, type SplitShare, SplitShareSchema, type SubmitInput, SubmitInputSchema, type SubmitOutput, SubmitOutputSchema, SwapTransactionDataSchema, TRANSACTION_FAILED, type Token, type TokenAccount, TokenAccountSchema, type TokenBalanceData, TokenBalanceDataSchema, type TokenListOutput, TokenListOutputSchema, TokenSchema, type TransactionBatchRequest, TransactionBatchRequestSchema, type TransactionBatchResponse, TransactionBatchResponseSchema, type TransactionData, TransactionDataSchema, type TransactionItem, TransactionItemSchema, type TransactionMetadata, TransactionMetadataSchema, type TransactionStatus, TransactionStatusSchema, type TransferHotspotInput, TransferHotspotInputSchema, TransferHotspotOutputSchema, type TransferInput, TransferInputSchema, type TransferOutput, TransferOutputSchema, UNAUTHORIZED, type UpdateRewardsDestinationInput, UpdateRewardsDestinationInputSchema, UpdateRewardsDestinationOutputSchema, VALIDATION_ERROR, WalletAddressSchema, type WelcomePack, type WelcomePackClaimInput, WelcomePackClaimInputSchema, type WelcomePackClaimOutput, WelcomePackClaimOutputSchema, type WelcomePackCreateInput, WelcomePackCreateInputSchema, type WelcomePackCreateOutput, WelcomePackCreateOutputSchema, type WelcomePackDeleteInput, WelcomePackDeleteInputSchema, type WelcomePackDeleteOutput, WelcomePackDeleteOutputSchema, type WelcomePackGetByAddressInput, WelcomePackGetByAddressInputSchema, type WelcomePackGetInput, WelcomePackGetInputSchema, type WelcomePackInviteInput, WelcomePackInviteInputSchema, type WelcomePackInviteOutput, WelcomePackInviteOutputSchema, type WelcomePackListInput, WelcomePackListInputSchema, type WelcomePackListOutput, WelcomePackListOutputSchema, WelcomePackSchema, apiContract, commonErrors, createClient, createMockClient, generateOpenAPISpec, getAPIContract, hotspotErrors, solanaErrors };