import { z } from 'zod';
export { Kaia, KaiaPlugin } from './kaia.plugin.mjs';
import '@goat-sdk/core';
import '@goat-sdk/wallet-evm';

declare const getAccountOverview$1: (parameters: any, config: any) => Promise<string>;

declare const getCurrentBalance$1: (parameters: any, config: any) => Promise<string>;

declare const getFTBalance$1: (parameters: any, config: any) => Promise<string>;

declare const getNFTBalance$1: (parameters: any, config: any) => Promise<string>;

declare const getKaiaInfo$1: (parameters: any, config: any) => Promise<string>;

declare const getBlockInfo$1: (parameters: any, config: any) => Promise<string>;

declare const getLatestBlock$1: (parameters: any, config: any) => Promise<string>;

declare const getTransactionsByAccount$1: (parameters: any, config: any) => Promise<string>;

declare const getTransactionsByBlockNumber$1: (parameters: any, config: any) => Promise<string>;

declare namespace services$2 {
  export { getAccountOverview$1 as getAccountOverview, getBlockInfo$1 as getBlockInfo, getCurrentBalance$1 as getCurrentBalance, getFTBalance$1 as getFTBalance, getKaiaInfo$1 as getKaiaInfo, getLatestBlock$1 as getLatestBlock, getNFTBalance$1 as getNFTBalance, getTransactionsByAccount$1 as getTransactionsByAccount, getTransactionsByBlockNumber$1 as getTransactionsByBlockNumber };
}

declare const getAccountOverview: {
    name: string;
    description: string;
    params: z.ZodObject<{
        address: z.ZodString;
        network: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        address: string;
        network: string;
    }, {
        address: string;
        network: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: ({
        user: string;
        content: {
            text: string;
            action?: undefined;
        };
    } | {
        user: string;
        content: {
            text: string;
            action: string;
        };
    })[][];
};
declare const getCurrentBalance: {
    name: string;
    description: string;
    params: z.ZodObject<{
        address: z.ZodString;
        network: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        address: string;
        network: string;
    }, {
        address: string;
        network: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: ({
        user: string;
        content: {
            text: string;
            action?: undefined;
        };
    } | {
        user: string;
        content: {
            text: string;
            action: string;
        };
    })[][];
};
declare const getFTBalance: {
    name: string;
    description: string;
    params: z.ZodObject<{
        address: z.ZodString;
        network: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        address: string;
        network: string;
    }, {
        address: string;
        network: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: ({
        user: string;
        content: {
            text: string;
            action?: undefined;
        };
    } | {
        user: string;
        content: {
            text: string;
            action: string;
        };
    })[][];
};
declare const getNFTBalance: {
    name: string;
    description: string;
    params: z.ZodObject<{
        address: z.ZodString;
        network: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        address: string;
        network: string;
    }, {
        address: string;
        network: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: ({
        user: string;
        content: {
            text: string;
            action?: undefined;
        };
    } | {
        user: string;
        content: {
            text: string;
            action: string;
        };
    })[][];
};
declare const getKaiaInfo: {
    name: string;
    description: string;
    params: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: ({
        user: string;
        content: {
            text: string;
            action?: undefined;
        };
    } | {
        user: string;
        content: {
            text: string;
            action: string;
        };
    })[][];
};
declare const getBlockInfo: {
    name: string;
    description: string;
    params: z.ZodObject<{
        blockNumber: z.ZodNumber;
        network: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        network: string;
        blockNumber: number;
    }, {
        network: string;
        blockNumber: number;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: ({
        user: string;
        content: {
            text: string;
            action?: undefined;
        };
    } | {
        user: string;
        content: {
            text: string;
            action: string;
        };
    })[][];
};
declare const getLatestBlock: {
    name: string;
    description: string;
    params: z.ZodObject<{
        network: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        network: string;
    }, {
        network: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: ({
        user: string;
        content: {
            text: string;
            action?: undefined;
        };
    } | {
        user: string;
        content: {
            text: string;
            action: string;
        };
    })[][];
};
declare const getTransactionsByAccount: {
    name: string;
    description: string;
    params: z.ZodObject<{
        address: z.ZodString;
        network: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        address: string;
        network: string;
    }, {
        address: string;
        network: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: ({
        user: string;
        content: {
            text: string;
            action?: undefined;
        };
    } | {
        user: string;
        content: {
            text: string;
            action: string;
        };
    })[][];
};
declare const getTransactionsByBlockNumber: {
    name: string;
    description: string;
    params: z.ZodObject<{
        blockNumber: z.ZodNumber;
        network: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        network: string;
        blockNumber: number;
    }, {
        network: string;
        blockNumber: number;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: ({
        user: string;
        content: {
            text: string;
            action?: undefined;
        };
    } | {
        user: string;
        content: {
            text: string;
            action: string;
        };
    })[][];
};

declare const metadata$2_getAccountOverview: typeof getAccountOverview;
declare const metadata$2_getBlockInfo: typeof getBlockInfo;
declare const metadata$2_getCurrentBalance: typeof getCurrentBalance;
declare const metadata$2_getFTBalance: typeof getFTBalance;
declare const metadata$2_getKaiaInfo: typeof getKaiaInfo;
declare const metadata$2_getLatestBlock: typeof getLatestBlock;
declare const metadata$2_getNFTBalance: typeof getNFTBalance;
declare const metadata$2_getTransactionsByAccount: typeof getTransactionsByAccount;
declare const metadata$2_getTransactionsByBlockNumber: typeof getTransactionsByBlockNumber;
declare namespace metadata$2 {
  export { metadata$2_getAccountOverview as getAccountOverview, metadata$2_getBlockInfo as getBlockInfo, metadata$2_getCurrentBalance as getCurrentBalance, metadata$2_getFTBalance as getFTBalance, metadata$2_getKaiaInfo as getKaiaInfo, metadata$2_getLatestBlock as getLatestBlock, metadata$2_getNFTBalance as getNFTBalance, metadata$2_getTransactionsByAccount as getTransactionsByAccount, metadata$2_getTransactionsByBlockNumber as getTransactionsByBlockNumber };
}

declare namespace Kaiascan {
  export { metadata$2 as Metadata, services$2 as Services };
}

type TokenTransferPayload = {
    sender: `0x${string}`;
    type: "erc20" | "erc721" | "erc1155";
    receiver: `0x${string}`;
    amount: string | bigint | number;
    tokenId: string;
    contractAddress: string;
};

declare const transferErc20$1: (parameters: Omit<TokenTransferPayload, "type" | "tokenId">, config: any, walletClient: any) => Promise<{
    transactionHash: any;
}>;

declare const transferErc721$1: (parameters: Omit<TokenTransferPayload, "type" | "amount">, config: any, walletClient: any) => Promise<{
    transactionHash: any;
}>;

declare const transferErc1155$1: (parameters: Omit<TokenTransferPayload, "type">, config: any, walletClient: any) => Promise<{
    transactionHash: any;
}>;

declare const transferNativeToken$1: (parameters: Omit<TokenTransferPayload, "type" | "tokenId" | "contractAddress">, config: any, walletClient: any) => Promise<{
    transactionHash: any;
}>;

declare const transferFaucet$1: (parameters: any, config: any, walletClient: any) => Promise<{
    transactionHash: any;
}>;

declare namespace services$1 {
  export { transferErc1155$1 as transferErc1155, transferErc20$1 as transferErc20, transferErc721$1 as transferErc721, transferFaucet$1 as transferFaucet, transferNativeToken$1 as transferNativeToken };
}

declare const transferFaucet: {
    name: string;
    description: string;
    params: z.ZodObject<{
        receiver: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        receiver: string;
    }, {
        receiver: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: ({
        user: string;
        content: {
            text: string;
            action?: undefined;
        };
    } | {
        user: string;
        content: {
            text: string;
            action: string;
        };
    })[][];
};
declare const transferErc20: {
    name: string;
    description: string;
    params: z.ZodObject<{
        receiver: z.ZodString;
        amount: z.ZodNumber;
        contractAddress: z.ZodString;
        network: z.ZodEnum<["kaia", "kairos"]>;
    }, "strip", z.ZodTypeAny, {
        network: "kairos" | "kaia";
        receiver: string;
        amount: number;
        contractAddress: string;
    }, {
        network: "kairos" | "kaia";
        receiver: string;
        amount: number;
        contractAddress: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: never[];
};
declare const transferErc721: {
    name: string;
    description: string;
    params: z.ZodObject<{
        receiver: z.ZodString;
        tokenId: z.ZodString;
        contractAddress: z.ZodString;
        network: z.ZodEnum<["kaia", "kairos"]>;
    }, "strip", z.ZodTypeAny, {
        network: "kairos" | "kaia";
        receiver: string;
        tokenId: string;
        contractAddress: string;
    }, {
        network: "kairos" | "kaia";
        receiver: string;
        tokenId: string;
        contractAddress: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: never[];
};
declare const transferErc1155: {
    name: string;
    description: string;
    params: z.ZodObject<{
        receiver: z.ZodString;
        amount: z.ZodNumber;
        tokenId: z.ZodString;
        contractAddress: z.ZodString;
        network: z.ZodEnum<["kaia", "kairos"]>;
    }, "strip", z.ZodTypeAny, {
        network: "kairos" | "kaia";
        receiver: string;
        amount: number;
        tokenId: string;
        contractAddress: string;
    }, {
        network: "kairos" | "kaia";
        receiver: string;
        amount: number;
        tokenId: string;
        contractAddress: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: never[];
};
declare const transferNativeToken: {
    name: string;
    description: string;
    params: z.ZodObject<{
        receiver: z.ZodString;
        amount: z.ZodNumber;
        network: z.ZodEnum<["kaia", "kairos"]>;
    }, "strip", z.ZodTypeAny, {
        network: "kairos" | "kaia";
        receiver: string;
        amount: number;
    }, {
        network: "kairos" | "kaia";
        receiver: string;
        amount: number;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: {
        user: string;
        content: {
            text: string;
            action: string;
        };
    }[][][];
};

declare const metadata$1_transferErc1155: typeof transferErc1155;
declare const metadata$1_transferErc20: typeof transferErc20;
declare const metadata$1_transferErc721: typeof transferErc721;
declare const metadata$1_transferFaucet: typeof transferFaucet;
declare const metadata$1_transferNativeToken: typeof transferNativeToken;
declare namespace metadata$1 {
  export { metadata$1_transferErc1155 as transferErc1155, metadata$1_transferErc20 as transferErc20, metadata$1_transferErc721 as transferErc721, metadata$1_transferFaucet as transferFaucet, metadata$1_transferNativeToken as transferNativeToken };
}

declare namespace Web3 {
  export { metadata$1 as Metadata, services$1 as Services };
}

declare const getPoolByTokenSymbol$1: (parameters: any) => Promise<any>;

declare const getPoolByTokenAddress$1: (parameters: any) => Promise<any>;

declare const getPoolDayData$1: (parameters: any) => Promise<any>;

declare const getTokenDayData$1: (parameters: any) => Promise<any>;

declare namespace services {
  export { getPoolByTokenAddress$1 as getPoolByTokenAddress, getPoolByTokenSymbol$1 as getPoolByTokenSymbol, getPoolDayData$1 as getPoolDayData, getTokenDayData$1 as getTokenDayData };
}

declare const getPoolByTokenSymbol: {
    name: string;
    description: string;
    params: z.ZodObject<{
        symbol0: z.ZodString;
        symbol1: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        symbol0: string;
        symbol1: string;
    }, {
        symbol0: string;
        symbol1: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: never[];
};
declare const getPoolByTokenAddress: {
    name: string;
    description: string;
    params: z.ZodObject<{
        token0Address: z.ZodString;
        token1Address: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        token0Address: string;
        token1Address: string;
    }, {
        token0Address: string;
        token1Address: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: never[];
};
declare const getPoolDayData: {
    name: string;
    description: string;
    params: z.ZodObject<{
        poolAddress: z.ZodString;
        count: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        poolAddress: string;
        count: number;
    }, {
        poolAddress: string;
        count: number;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: never[];
};
declare const getTokenDayData: {
    name: string;
    description: string;
    params: z.ZodObject<{
        tokenAddress: z.ZodString;
        count: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        count: number;
        tokenAddress: string;
    }, {
        count: number;
        tokenAddress: string;
    }>;
    similes: string[];
    validate: () => Promise<boolean>;
    examples: never[];
};

declare const metadata_getPoolByTokenAddress: typeof getPoolByTokenAddress;
declare const metadata_getPoolByTokenSymbol: typeof getPoolByTokenSymbol;
declare const metadata_getPoolDayData: typeof getPoolDayData;
declare const metadata_getTokenDayData: typeof getTokenDayData;
declare namespace metadata {
  export { metadata_getPoolByTokenAddress as getPoolByTokenAddress, metadata_getPoolByTokenSymbol as getPoolByTokenSymbol, metadata_getPoolDayData as getPoolDayData, metadata_getTokenDayData as getTokenDayData };
}

declare namespace DgSwap {
  export { metadata as Metadata, services as Services };
}

declare enum PackagesEnum {
    KAIASCAN = "kaiascan",
    WEB3 = "web3",
    DGSWAP = "dgSwap"
}
declare const Packages: {
    kaiascan: typeof Kaiascan;
    web3: typeof Web3;
    dgSwap: typeof DgSwap;
};

export { Packages, PackagesEnum };