@gala-chain/launchpad-sdk 3.5.2 → 3.6.0

package/dist/schemas/primitives.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Primitive Zod Schemas
+ *
+ * Reusable validation schemas for common data types across the SDK.
+ * These schemas replace manual CONSTRAINTS objects and type guards.
+ */
+import { z } from 'zod';
+/**
+ * Token name schema - alphanumeric, 3-20 characters
+ * Used for token creation and identification
+ */
+export declare const tokenNameSchema: z.ZodString;
+/**
+ * Token symbol schema - uppercase letters, 1-8 characters
+ * Used for token ticker symbols
+ */
+export declare const tokenSymbolSchema: z.ZodString;
+/**
+ * Token description schema - 1-500 characters
+ * Used for token metadata
+ */
+export declare const tokenDescriptionSchema: z.ZodString;
+/**
+ * User token name schema - more permissive, 1-50 characters
+ * Used for user operations where token names may vary
+ */
+export declare const userTokenNameSchema: z.ZodString;
+/**
+ * Search query schema - 1-100 characters
+ * Used for search and filter operations
+ */
+export declare const searchQuerySchema: z.ZodString;
+/**
+ * Full name schema - alphabets and spaces only, 1-100 characters
+ * Used for user profiles
+ */
+export declare const fullNameSchema: z.ZodString;
+/**
+ * Backend address format schema - eth|[40-hex-chars]
+ * Used for GalaChain address format
+ */
+export declare const addressFormatSchema: z.ZodString;
+/**
+ * Ethereum address schema - 0x[40-hex-chars]
+ * Standard Ethereum address format
+ */
+export declare const ethereumAddressSchema: z.ZodString;
+/**
+ * Flexible address schema - accepts both formats
+ * Automatically normalizes to backend format
+ */
+export declare const flexibleAddressSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+/**
+ * Vault address schema - supports both eth| and service| formats
+ * Used for token vault addresses
+ */
+export declare const vaultAddressSchema: z.ZodEffects<z.ZodString, string, string>;
+/**
+ * Positive decimal string schema
+ * Used for amounts, quantities, prices
+ */
+export declare const positiveDecimalStringSchema: z.ZodEffects<z.ZodString, string, string>;
+/**
+ * Non-negative decimal string schema
+ * Allows zero values
+ */
+export declare const nonNegativeDecimalStringSchema: z.ZodEffects<z.ZodString, string, string>;
+/**
+ * Faucet amount schema - positive, non-zero decimal
+ * Used for faucet requests
+ */
+export declare const faucetAmountSchema: z.ZodString;
+/**
+ * HTTP/HTTPS URL schema
+ * Validates basic URL structure
+ */
+export declare const urlSchema: z.ZodString;
+/**
+ * Optional URL schema
+ * Allows empty string or valid URL
+ */
+export declare const optionalUrlSchema: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+/**
+ * Page number schema - 1-1000
+ * Used for paginated queries
+ */
+export declare const pageNumberSchema: z.ZodDefault<z.ZodNumber>;
+/**
+ * Limit schema factory - creates limit schemas with custom max values
+ * @param maxLimit - Maximum items per page
+ */
+export declare function createLimitSchema(maxLimit?: number): z.ZodDefault<z.ZodNumber>;
+/**
+ * Standard pagination limit - 1-100 items
+ */
+export declare const standardLimitSchema: z.ZodDefault<z.ZodNumber>;
+/**
+ * User operation limit - 1-20 items
+ */
+export declare const userLimitSchema: z.ZodDefault<z.ZodNumber>;
+/**
+ * Trade operation limit - 1-20 items
+ */
+export declare const tradeLimitSchema: z.ZodDefault<z.ZodNumber>;
+/**
+ * File size schema - 1 byte to 10MB
+ */
+export declare const fileSizeSchema: z.ZodNumber;
+/**
+ * Filename schema - max 255 characters
+ */
+export declare const filenameSchema: z.ZodString;
+/**
+ * Allowed image MIME types
+ */
+export declare const imageMimeTypeSchema: z.ZodEnum<["image/png", "image/jpg", "image/jpeg", "image/gif", "image/webp", "image/svg+xml"]>;
+/**
+ * Comment message schema - 1-500 characters
+ */
+export declare const commentMessageSchema: z.ZodString;
+/**
+ * ISO 8601 date string schema
+ */
+export declare const isoDateStringSchema: z.ZodString;
+/**
+ * Unix timestamp schema (milliseconds)
+ */
+export declare const timestampSchema: z.ZodNumber;
+/**
+ * Private key schema - 0x prefix followed by 64 hex characters
+ * Used for wallet authentication in SDK and MCP tools
+ */
+export declare const privateKeySchema: z.ZodString;
+/**
+ * Transaction ID schema - UUID format
+ * Used for tracking bundler transactions in MCP tools
+ */
+export declare const transactionIdSchema: z.ZodString;
+/**
+ * Unique key schema - idempotency key for transfers
+ * Format: galaconnect-operation-{unique-id}
+ */
+export declare const uniqueKeySchema: z.ZodString;
+//# sourceMappingURL=primitives.d.ts.map

package/dist/schemas/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../src/schemas/primitives.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;;GAGG;AACH,eAAO,MAAM,eAAe,aAIsD,CAAC;AAEnF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,aAIyC,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,sBAAsB,aAG4B,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,mBAAmB,aAGsB,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,aAG4B,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,cAAc,aAI+C,CAAC;AAM3E;;;GAGG;AACH,eAAO,MAAM,mBAAmB,aAEmD,CAAC;AAEpF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,aAEgC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,qBAAqB,yEAc9B,CAAC;AAEL;;;GAGG;AACH,eAAO,MAAM,kBAAkB,2CAO5B,CAAC;AAMJ;;;GAGG;AACH,eAAO,MAAM,2BAA2B,2CAMrC,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,8BAA8B,2CAMxC,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,kBAAkB,aAEsD,CAAC;AAMtF;;;GAGG;AACH,eAAO,MAAM,SAAS,aAG6C,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,kFAM3B,CAAC;AAMJ;;;GAGG;AACH,eAAO,MAAM,gBAAgB,2BAKhB,CAAC;AAEd;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,GAAE,MAAY,6BAOvD;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,2BAAyB,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,eAAe,2BAAwB,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,gBAAgB,2BAAwB,CAAC;AAMtD;;GAEG;AACH,eAAO,MAAM,cAAc,aAI0B,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,cAAc,aAE2B,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,mBAAmB,iGAO9B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,oBAAoB,aAGoB,CAAC;AAMtD;;GAEG;AACH,eAAO,MAAM,mBAAmB,aAEmB,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,eAAe,aAGe,CAAC;AAM5C;;;GAGG;AACH,eAAO,MAAM,gBAAgB,aAEwD,CAAC;AAEtF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,aAK7B,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,eAAe,aAKzB,CAAC"}

package/dist/schemas/trade.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Trade Operation Zod Schemas
+ *
+ * Validation schemas for trading operations including buy/sell,
+ * amount calculations, and trade history queries.
+ * Replaces manual TRADE_CONSTRAINTS with type-safe Zod schemas.
+ */
+import { z } from 'zod';
+/**
+ * Trade type schema - 'buy' or 'sell'
+ */
+export declare const tradeTypeSchema: z.ZodEnum<["buy", "sell"]>;
+/**
+ * Trade type enum for backend - uppercase 'BUY' or 'SELL'
+ */
+export declare const tradeTypeBackendSchema: z.ZodEnum<["BUY", "SELL"]>;
+/**
+ * Create trade data schema
+ * For legacy trade creation endpoints
+ */
+export declare const createTradeDataSchema: z.ZodObject<{
+    tradeType: z.ZodEnum<["buy", "sell"]>;
+    tokenAmount: z.ZodEffects<z.ZodString, string, string>;
+    vaultAddress: z.ZodEffects<z.ZodString, string, string>;
+    userAddress: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    slippageTolerance: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    deadline: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    userAddress: string;
+    tradeType: "buy" | "sell";
+    tokenAmount: string;
+    vaultAddress: string;
+    slippageTolerance?: string | undefined;
+    deadline?: number | undefined;
+}, {
+    userAddress: string;
+    tradeType: "buy" | "sell";
+    tokenAmount: string;
+    vaultAddress: string;
+    slippageTolerance?: string | undefined;
+    deadline?: number | undefined;
+}>;
+/**
+ * Buy tokens data schema
+ * For buying launchpad tokens with GALA
+ */
+export declare const buyTokensDataSchema: z.ZodObject<{
+    tokenSymbol: z.ZodString;
+    nativeTokenQuantity: z.ZodEffects<z.ZodString, string, string>;
+    expectedToken: z.ZodEffects<z.ZodString, string, string>;
+    maxAcceptableReverseBondingCurveFee: z.ZodOptional<z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>>;
+}, "strip", z.ZodTypeAny, {
+    tokenSymbol: string;
+    nativeTokenQuantity: string;
+    expectedToken: string;
+    maxAcceptableReverseBondingCurveFee?: string | undefined;
+}, {
+    tokenSymbol: string;
+    nativeTokenQuantity: string;
+    expectedToken: string;
+    maxAcceptableReverseBondingCurveFee?: string | undefined;
+}>;
+/**
+ * Sell tokens data schema
+ * For selling launchpad tokens for GALA
+ */
+export declare const sellTokensDataSchema: z.ZodObject<{
+    tokenSymbol: z.ZodString;
+    tokenQuantity: z.ZodEffects<z.ZodString, string, string>;
+    expectedNativeToken: z.ZodEffects<z.ZodString, string, string>;
+    maxAcceptableReverseBondingCurveFee: z.ZodOptional<z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>>;
+}, "strip", z.ZodTypeAny, {
+    tokenSymbol: string;
+    tokenQuantity: string;
+    expectedNativeToken: string;
+    maxAcceptableReverseBondingCurveFee?: string | undefined;
+}, {
+    tokenSymbol: string;
+    tokenQuantity: string;
+    expectedNativeToken: string;
+    maxAcceptableReverseBondingCurveFee?: string | undefined;
+}>;
+/**
+ * Get trade options schema
+ * Basic trade query with optional token name filter
+ */
+export declare const getTradeOptionsSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+} & {
+    tokenName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    page: number;
+    limit: number;
+    tokenName?: string | undefined;
+}, {
+    page?: number | undefined;
+    limit?: number | undefined;
+    tokenName?: string | undefined;
+}>;
+/**
+ * Trade list params schema
+ * Simplified pagination-only params
+ */
+export declare const tradeListParamsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    page?: number | undefined;
+    limit?: number | undefined;
+}, {
+    page?: number | undefined;
+    limit?: number | undefined;
+}>;
+/**
+ * Trade calculation type schema
+ * NATIVE = GALA input/output, MEME = launchpad token input/output
+ */
+export declare const tradeCalculationTypeSchema: z.ZodEnum<["NATIVE", "MEME"]>;
+/**
+ * Trade calculation method schema
+ * IN = amount going into pool, OUT = amount coming out of pool
+ */
+export declare const tradeCalculationMethodSchema: z.ZodEnum<["IN", "OUT"]>;
+/**
+ * Get amount options schema
+ * For calculating trade amounts with bonding curve
+ */
+export declare const getAmountOptionsSchema: z.ZodObject<{
+    type: z.ZodEnum<["NATIVE", "MEME"]>;
+    method: z.ZodEnum<["IN", "OUT"]>;
+    vaultAddress: z.ZodEffects<z.ZodString, string, string>;
+    amount: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    method: "IN" | "OUT";
+    type: "NATIVE" | "MEME";
+    amount: string;
+    vaultAddress: string;
+}, {
+    method: "IN" | "OUT";
+    type: "NATIVE" | "MEME";
+    amount: string;
+    vaultAddress: string;
+}>;
+/**
+ * Calculate pre-mint data schema
+ * For calculating initial token purchase amounts during creation
+ */
+export declare const calculatePreMintDataSchema: z.ZodObject<{
+    nativeTokenQuantity: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    nativeTokenQuantity: string;
+}, {
+    nativeTokenQuantity: string;
+}>;
+/**
+ * Fetch pool details data schema
+ */
+export declare const fetchPoolDetailsDataSchema: z.ZodObject<{
+    vaultAddress: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    vaultAddress: string;
+}, {
+    vaultAddress: string;
+}>;
+/**
+ * Reverse bonding curve configuration schema
+ */
+export declare const reverseBondingCurveConfigurationSchema: z.ZodObject<{
+    minFeePortion: z.ZodEffects<z.ZodString, string, string>;
+    maxFeePortion: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    minFeePortion: string;
+    maxFeePortion: string;
+}, {
+    minFeePortion: string;
+    maxFeePortion: string;
+}>;
+export type TradeType = z.infer<typeof tradeTypeSchema>;
+export type TradeTypeBackend = z.infer<typeof tradeTypeBackendSchema>;
+export type CreateTradeData = z.infer<typeof createTradeDataSchema>;
+export type BuyTokensData = z.infer<typeof buyTokensDataSchema>;
+export type SellTokensData = z.infer<typeof sellTokensDataSchema>;
+export type GetTradeOptions = z.infer<typeof getTradeOptionsSchema>;
+export type TradeListParams = z.infer<typeof tradeListParamsSchema>;
+export type TradeCalculationType = z.infer<typeof tradeCalculationTypeSchema>;
+export type TradeCalculationMethod = z.infer<typeof tradeCalculationMethodSchema>;
+export type GetAmountOptions = z.infer<typeof getAmountOptionsSchema>;
+export type CalculatePreMintData = z.infer<typeof calculatePreMintDataSchema>;
+export type FetchPoolDetailsData = z.infer<typeof fetchPoolDetailsDataSchema>;
+export type ReverseBondingCurveConfiguration = z.infer<typeof reverseBondingCurveConfigurationSchema>;
+//# sourceMappingURL=trade.d.ts.map

package/dist/schemas/trade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trade.d.ts","sourceRoot":"","sources":["../../src/schemas/trade.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB;;GAEG;AACH,eAAO,MAAM,eAAe,4BAA0B,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,sBAAsB,4BAA0B,CAAC;AAM9D;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;EAOhC,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAO9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAO/B,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;EAEhC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;EAGhC,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,0BAA0B,+BAA6B,CAAC;AAErE;;;GAGG;AACH,eAAO,MAAM,4BAA4B,0BAAwB,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;EAKjC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;;EAErC,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;EAErC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sCAAsC;;;;;;;;;EAGjD,CAAC;AAMH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAC"}

package/dist/schemas/user.d.ts

@@ -0,0 +1,251 @@
+/**
+ * User Operation Zod Schemas
+ *
+ * Validation schemas for user-related operations including token lists,
+ * profiles, balances, and faucet transfers.
+ * Replaces manual USER_CONSTRAINTS with type-safe Zod schemas.
+ */
+import { z } from 'zod';
+/**
+ * User token type schema
+ */
+export declare const userTokenTypeSchema: z.ZodEnum<["all", "DEFI", "ASSET"]>;
+/**
+ * Token list options schema
+ * Includes pagination, type filter, address filter, search, and token name
+ */
+export declare const tokenListOptionsSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+} & {
+    type: z.ZodOptional<z.ZodEnum<["all", "DEFI", "ASSET"]>>;
+    address: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    search: z.ZodOptional<z.ZodString>;
+    tokenName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    page: number;
+    limit: number;
+    address?: string | undefined;
+    type?: "all" | "DEFI" | "ASSET" | undefined;
+    tokenName?: string | undefined;
+    search?: string | undefined;
+}, {
+    address?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+    type?: "all" | "DEFI" | "ASSET" | undefined;
+    tokenName?: string | undefined;
+    search?: string | undefined;
+}>;
+/**
+ * Transfer faucets data schema
+ * For transferring test tokens to a wallet
+ */
+export declare const transferFaucetsDataSchema: z.ZodObject<{
+    walletAddress: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    amount: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    walletAddress: string;
+    amount: string;
+}, {
+    walletAddress: string;
+    amount: string;
+}>;
+/**
+ * Fetch GALA balance options schema
+ */
+export declare const fetchGalaBalanceOptionsSchema: z.ZodObject<{
+    address: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    refresh: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    address?: string | undefined;
+    refresh?: boolean | undefined;
+}, {
+    address?: string | undefined;
+    refresh?: boolean | undefined;
+}>;
+/**
+ * Update profile data schema
+ */
+export declare const updateProfileDataSchema: z.ZodObject<{
+    profileImage: z.ZodString;
+    fullName: z.ZodString;
+    address: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    privateKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    address: string;
+    profileImage: string;
+    fullName: string;
+    privateKey?: string | undefined;
+}, {
+    address: string;
+    profileImage: string;
+    fullName: string;
+    privateKey?: string | undefined;
+}>;
+/**
+ * Upload profile image options schema
+ */
+export declare const uploadProfileImageOptionsSchema: z.ZodObject<{
+    file: z.ZodUnion<[z.ZodType<File, z.ZodTypeDef, File>, z.ZodType<Buffer<ArrayBufferLike>, z.ZodTypeDef, Buffer<ArrayBufferLike>>]>;
+    address: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    privateKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    file: File | Buffer<ArrayBufferLike>;
+    address?: string | undefined;
+    privateKey?: string | undefined;
+}, {
+    file: File | Buffer<ArrayBufferLike>;
+    address?: string | undefined;
+    privateKey?: string | undefined;
+}>;
+/**
+ * Fetch token balance options schema
+ * Supports flexible token identification via tokenId, tokenClassKey, or tokenName
+ */
+export declare const fetchTokenBalanceOptionsSchema: z.ZodEffects<z.ZodObject<{
+    address: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    tokenId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        collection: z.ZodString;
+        category: z.ZodString;
+        type: z.ZodString;
+        additionalKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    }, {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    }>, z.ZodObject<{
+        collection: z.ZodString;
+        category: z.ZodString;
+        type: z.ZodString;
+        additionalKey: z.ZodString;
+        instance: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+        instance: string;
+    }, {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+        instance: string;
+    }>]>>;
+    tokenClassKey: z.ZodOptional<z.ZodObject<{
+        collection: z.ZodString;
+        category: z.ZodString;
+        type: z.ZodString;
+        additionalKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    }, {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    }>>;
+    tokenName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    address: string;
+    tokenName?: string | undefined;
+    tokenId?: string | {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    } | {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+        instance: string;
+    } | undefined;
+    tokenClassKey?: {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    } | undefined;
+}, {
+    address: string;
+    tokenName?: string | undefined;
+    tokenId?: string | {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    } | {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+        instance: string;
+    } | undefined;
+    tokenClassKey?: {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    } | undefined;
+}>, {
+    address: string;
+    tokenName?: string | undefined;
+    tokenId?: string | {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    } | {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+        instance: string;
+    } | undefined;
+    tokenClassKey?: {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    } | undefined;
+}, {
+    address: string;
+    tokenName?: string | undefined;
+    tokenId?: string | {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    } | {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+        instance: string;
+    } | undefined;
+    tokenClassKey?: {
+        type: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+    } | undefined;
+}>;
+export type UserTokenType = z.infer<typeof userTokenTypeSchema>;
+export type TokenListOptions = z.infer<typeof tokenListOptionsSchema>;
+export type TransferFaucetsData = z.infer<typeof transferFaucetsDataSchema>;
+export type FetchGalaBalanceOptions = z.infer<typeof fetchGalaBalanceOptionsSchema>;
+export type UpdateProfileData = z.infer<typeof updateProfileDataSchema>;
+export type UploadProfileImageOptions = z.infer<typeof uploadProfileImageOptionsSchema>;
+export type FetchTokenBalanceOptions = z.infer<typeof fetchTokenBalanceOptionsSchema>;
+//# sourceMappingURL=user.d.ts.map

package/dist/schemas/user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/schemas/user.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB;;GAEG;AACH,eAAO,MAAM,mBAAmB,qCAAmC,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;EAKjC,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;EAGpC,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;EAGxC,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;EAKlC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;EAO1C,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4B1C,CAAC;AAMF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACxF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC"}