@joai/warps 3.0.0-beta.198

package/dist/index.d.ts

@@ -0,0 +1,1270 @@
+import QRCodeStyling from 'qr-code-styling';
+
+declare enum WarpChainName {
+    Multiversx = "multiversx",
+    Vibechain = "vibechain",
+    Sui = "sui",
+    Ethereum = "ethereum",
+    Base = "base",
+    Arbitrum = "arbitrum",
+    Polygon = "polygon",
+    Somnia = "somnia",
+    Fastset = "fastset",
+    Solana = "solana",
+    Near = "near"
+}
+declare const WarpConstants: {
+    HttpProtocolPrefix: string;
+    IdentifierParamName: string;
+    IdentifierParamSeparator: string;
+    IdentifierChainDefault: WarpChainName;
+    IdentifierType: {
+        Alias: WarpIdentifierType;
+        Hash: WarpIdentifierType;
+    };
+    IdentifierAliasMarker: string;
+    Globals: {
+        UserWallet: {
+            Placeholder: string;
+            Accessor: (bag: InterpolationBag) => string | WarpWalletDetails | null | undefined;
+        };
+        UserWalletPublicKey: {
+            Placeholder: string;
+            Accessor: (bag: InterpolationBag) => string | null;
+        };
+        ChainApiUrl: {
+            Placeholder: string;
+            Accessor: (bag: InterpolationBag) => string;
+        };
+        ChainAddressHrp: {
+            Placeholder: string;
+            Accessor: (bag: InterpolationBag) => string;
+        };
+    };
+    Vars: {
+        Query: string;
+        Env: string;
+    };
+    ArgParamsSeparator: string;
+    ArgCompositeSeparator: string;
+    ArgListSeparator: string;
+    ArgStructSeparator: string;
+    Transform: {
+        Prefix: string;
+    };
+    Source: {
+        UserWallet: string;
+    };
+    Position: {
+        Payload: string;
+    };
+    Alerts: {
+        TriggerEventPrefix: string;
+    };
+};
+declare const WarpInputTypes: {
+    Option: string;
+    Vector: string;
+    Tuple: string;
+    Struct: string;
+    String: string;
+    Uint8: string;
+    Uint16: string;
+    Uint32: string;
+    Uint64: string;
+    Uint128: string;
+    Uint256: string;
+    Biguint: string;
+    Bool: string;
+    Address: string;
+    Asset: string;
+    Hex: string;
+};
+declare const safeWindow: Window;
+
+type WarpLocale = 'en' | 'es' | 'fr' | 'de' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'nl' | 'sv' | 'da' | 'no' | 'fi' | 'pl' | 'tr' | 'el' | 'he' | 'th' | 'vi' | 'id' | 'ms' | 'tl' | string;
+type WarpText = string | WarpI18nText;
+type WarpI18nText = {
+    [language: string]: string;
+};
+
+type WarpAlertName = string;
+type WarpAlert = {
+    label: WarpText;
+    trigger: string;
+    subject: WarpText;
+    body: WarpText;
+    action?: string;
+};
+type WarpAlerts = Record<WarpAlertName, WarpAlert>;
+
+type WarpChainEnv = 'mainnet' | 'testnet' | 'devnet';
+type WarpTheme = 'light' | 'dark';
+type ProtocolName = 'warp' | 'brand' | 'abi';
+
+type WarpBrand = {
+    protocol: string;
+    name: WarpText;
+    description: WarpText;
+    logo: WarpBrandLogo;
+    urls?: WarpBrandUrls;
+    colors?: WarpBrandColors;
+    cta?: WarpBrandCta;
+    meta?: WarpMeta;
+};
+type WarpBrandLogoThemed = Record<WarpTheme, string>;
+type WarpBrandLogo = string | WarpBrandLogoThemed;
+type WarpBrandUrls = {
+    web?: string;
+};
+type WarpBrandColors = {
+    primary?: string;
+    secondary?: string;
+};
+type WarpBrandCta = {
+    title: WarpText;
+    description: WarpText;
+    label: WarpText;
+    url: string;
+};
+
+type ClientCacheConfig = {
+    ttl?: number;
+    type?: WarpCacheType;
+    path?: string;
+};
+type WarpCacheType = 'memory' | 'localStorage' | 'static' | 'filesystem';
+
+type WarpActionExecutionStatus = 'success' | 'error' | 'unhandled';
+type WarpActionExecutionResult = {
+    status: WarpActionExecutionStatus;
+    warp: Warp;
+    action: number;
+    user: string | null;
+    txHash: string | null;
+    tx: WarpAdapterGenericTransaction | null;
+    next: WarpExecutionNextInfo | null;
+    values: {
+        string: string[];
+        native: WarpNativeValue[];
+        mapped: Record<string, any>;
+    };
+    output: WarpExecutionOutput;
+    messages: WarpExecutionMessages;
+    destination: string | null;
+    resolvedInputs: string[];
+};
+type WarpExecutionNextInfo = {
+    identifier: string | null;
+    url: string;
+}[];
+type WarpExecutionOutput = Record<WarpOutputName, any | null>;
+type WarpExecutionMessages = Record<WarpMessageName, string | null>;
+
+type WarpTrustStatus = 'unverified' | 'verified' | 'blacklisted';
+type WarpRegistryInfo = {
+    hash: string;
+    alias: string | null;
+    trust: WarpTrustStatus;
+    owner: string;
+    createdAt: number;
+    upgradedAt: number;
+    brand: string | null;
+    upgrade: string | null;
+};
+type WarpRegistryConfigInfo = {
+    unitPrice: bigint;
+    admins: string[];
+};
+
+type ClientIndexConfig = {
+    url?: string;
+    apiKey?: string;
+    searchParamName?: string;
+};
+type WarpSearchResult = {
+    hits: WarpSearchHit[];
+};
+type WarpSearchHit = {
+    hash: string;
+    alias: string;
+    name: string;
+    title: string;
+    description: string;
+    preview: string;
+    status: string;
+    category: string;
+    featured: boolean;
+};
+
+interface TransformRunner {
+    run(code: string, context: any): Promise<any>;
+}
+type ClientTransformConfig = {
+    runner?: TransformRunner | null;
+};
+
+interface WalletProvider {
+    getAddress(): Promise<string | null>;
+    getPublicKey(): Promise<string | null>;
+    signTransaction(tx: any): Promise<any>;
+    signMessage(message: string): Promise<string>;
+    importFromMnemonic(mnemonic: string): Promise<WarpWalletDetails>;
+    importFromPrivateKey(privateKey: string): Promise<WarpWalletDetails>;
+    export(): Promise<WarpWalletDetails>;
+    generate(): Promise<WarpWalletDetails>;
+}
+type WalletProviderFactory = (config: WarpClientConfig, chain: WarpChainInfo) => WalletProvider | null;
+
+type WarpWalletProvider = 'mnemonic' | 'privateKey' | 'coinbase' | 'privy' | 'gaupa';
+type WarpWalletDetails = {
+    provider: WarpWalletProvider;
+    address: string;
+    mnemonic?: string | null;
+    privateKey?: string | null;
+    externalId?: string | null;
+};
+type WarpUserWallets = Partial<Record<WarpChainName, WarpWalletDetails | string | null>>;
+type WarpProviderPreferences = Partial<Record<WarpChainEnv, string | WarpProviderConfig>>;
+type WarpProviderConfig = {
+    url: string;
+    headers?: Record<string, string>;
+};
+type WarpClientConfig = {
+    env: WarpChainEnv;
+    clientUrl?: string;
+    currentUrl?: string;
+    vars?: Record<string, string | number>;
+    user?: {
+        id?: string;
+        wallets?: WarpUserWallets;
+    };
+    preferences?: {
+        locale?: WarpLocale;
+        theme?: WarpTheme;
+        explorers?: Partial<Record<WarpChainName, WarpExplorerName>>;
+        providers?: Partial<Record<WarpChainName, WarpProviderPreferences>>;
+    };
+    walletProviders?: Partial<Record<WarpChainName, Partial<Record<WarpWalletProvider, WalletProviderFactory>>>>;
+    fallback?: WarpChainName;
+    schema?: {
+        warp?: string;
+        brand?: string;
+    };
+    cache?: ClientCacheConfig;
+    transform?: ClientTransformConfig;
+    index?: ClientIndexConfig;
+    interceptors?: {
+        openLink?: (url: string) => Promise<void>;
+    };
+};
+type WarpCacheConfig = {
+    ttl?: number;
+};
+type ChainAdapterFactory = (config: WarpClientConfig, fallback?: ChainAdapter | undefined) => ChainAdapter;
+type ChainAdapter = {
+    chainInfo: WarpChainInfo;
+    builder: () => CombinedWarpBuilder;
+    executor: AdapterWarpExecutor;
+    output: AdapterWarpOutput;
+    serializer: AdapterWarpSerializer;
+    registry: AdapterWarpRegistry;
+    explorer: AdapterWarpExplorer;
+    abiBuilder: () => AdapterWarpAbiBuilder;
+    brandBuilder: () => AdapterWarpBrandBuilder;
+    dataLoader: AdapterWarpDataLoader;
+    wallet: AdapterWarpWallet;
+};
+type WarpAdapterGenericTransaction = any;
+type WarpAdapterGenericRemoteTransaction = any;
+type WarpAdapterGenericValue = any;
+type WarpAdapterGenericType = any;
+interface WarpTypeHandler {
+    stringToNative(value: string): any;
+    nativeToString(value: any): string;
+}
+interface AdapterTypeRegistry {
+    registerType(typeName: string, handler: WarpTypeHandler): void;
+    registerTypeAlias(typeName: string, alias: string): void;
+    hasType(typeName: string): boolean;
+    getHandler(typeName: string): WarpTypeHandler | undefined;
+    getAlias(typeName: string): string | undefined;
+    resolveType(typeName: string): string;
+    getRegisteredTypes(): string[];
+}
+interface BaseWarpBuilder {
+    createFromRaw(encoded: string, validate?: boolean): Promise<Warp>;
+    createFromUrl(url: string): Promise<Warp>;
+    setName(name: string): BaseWarpBuilder;
+    setTitle(title: string): BaseWarpBuilder;
+    setDescription(description: string | null): BaseWarpBuilder;
+    setPreview(preview: string): BaseWarpBuilder;
+    setActions(actions: WarpAction[]): BaseWarpBuilder;
+    addAction(action: WarpAction): BaseWarpBuilder;
+    setOutput(output: Record<string, string> | null): BaseWarpBuilder;
+    build(validate?: boolean): Promise<Warp>;
+}
+interface AdapterWarpBuilder {
+    createInscriptionTransaction(warp: Warp): Promise<WarpAdapterGenericTransaction>;
+    createFromTransaction(tx: WarpAdapterGenericTransaction, validate?: boolean): Promise<Warp>;
+    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<Warp | null>;
+}
+type CombinedWarpBuilder = AdapterWarpBuilder & BaseWarpBuilder;
+interface AdapterWarpAbiBuilder {
+    createInscriptionTransaction(abi: WarpAbiContents): Promise<WarpAdapterGenericTransaction>;
+    createFromRaw(encoded: string): Promise<any>;
+    createFromTransaction(tx: WarpAdapterGenericTransaction): Promise<any>;
+    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<any | null>;
+}
+interface AdapterWarpBrandBuilder {
+    createInscriptionTransaction(brand: WarpBrand): WarpAdapterGenericTransaction;
+    createFromTransaction(tx: WarpAdapterGenericTransaction, validate?: boolean): Promise<WarpBrand>;
+    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<WarpBrand | null>;
+}
+interface AdapterWarpExecutor {
+    createTransaction(executable: WarpExecutable): Promise<WarpAdapterGenericTransaction>;
+    executeQuery(executable: WarpExecutable): Promise<WarpActionExecutionResult>;
+}
+interface AdapterWarpOutput {
+    getActionExecution(warp: Warp, actionIndex: WarpActionIndex, tx: WarpAdapterGenericRemoteTransaction): Promise<WarpActionExecutionResult>;
+}
+interface AdapterWarpSerializer {
+    typedToString(value: WarpAdapterGenericValue): string;
+    typedToNative(value: WarpAdapterGenericValue): [WarpActionInputType, WarpNativeValue];
+    nativeToTyped(type: WarpActionInputType, value: WarpNativeValue): WarpAdapterGenericValue;
+    nativeToType(type: BaseWarpActionInputType): WarpAdapterGenericType;
+    stringToTyped(value: string): WarpAdapterGenericValue;
+}
+interface AdapterWarpRegistry {
+    init(): Promise<void>;
+    getRegistryConfig(): WarpRegistryConfigInfo;
+    createWarpRegisterTransaction(txHash: string, alias?: string | null, brand?: string | null): Promise<WarpAdapterGenericTransaction>;
+    createWarpUnregisterTransaction(txHash: string): Promise<WarpAdapterGenericTransaction>;
+    createWarpUpgradeTransaction(alias: string, txHash: string, brand?: string | null): Promise<WarpAdapterGenericTransaction>;
+    createWarpAliasSetTransaction(txHash: string, alias: string): Promise<WarpAdapterGenericTransaction>;
+    createWarpVerifyTransaction(txHash: string): Promise<WarpAdapterGenericTransaction>;
+    createWarpTransferOwnershipTransaction(txHash: string, newOwner: string): Promise<WarpAdapterGenericTransaction>;
+    createBrandRegisterTransaction(txHash: string): Promise<WarpAdapterGenericTransaction>;
+    createWarpBrandingTransaction(warpHash: string, brandHash: string): Promise<WarpAdapterGenericTransaction>;
+    getInfoByAlias(alias: string, cache?: WarpCacheConfig): Promise<{
+        registryInfo: WarpRegistryInfo | null;
+        brand: WarpBrand | null;
+    }>;
+    getInfoByHash(hash: string, cache?: WarpCacheConfig): Promise<{
+        registryInfo: WarpRegistryInfo | null;
+        brand: WarpBrand | null;
+    }>;
+    getUserWarpRegistryInfos(user?: string): Promise<WarpRegistryInfo[]>;
+    getUserBrands(user?: string): Promise<WarpBrand[]>;
+    fetchBrand(hash: string, cache?: WarpCacheConfig): Promise<WarpBrand | null>;
+}
+interface AdapterWarpExplorer {
+    getAccountUrl(address: string): string;
+    getTransactionUrl(hash: string): string;
+    getAssetUrl(identifier: string): string;
+    getContractUrl(address: string): string;
+}
+interface WarpDataLoaderOptions {
+    page?: number;
+    size?: number;
+}
+interface AdapterWarpDataLoader {
+    getAccount(address: string): Promise<WarpChainAccount>;
+    getAccountAssets(address: string): Promise<WarpChainAsset[]>;
+    getAsset(identifier: string): Promise<WarpChainAsset | null>;
+    getAction(identifier: string, awaitCompleted?: boolean): Promise<WarpChainAction | null>;
+    getAccountActions(address: string, options?: WarpDataLoaderOptions): Promise<WarpChainAction[]>;
+}
+interface AdapterWarpWallet {
+    signTransaction(tx: WarpAdapterGenericTransaction): Promise<WarpAdapterGenericTransaction>;
+    signTransactions(txs: WarpAdapterGenericTransaction[]): Promise<WarpAdapterGenericTransaction[]>;
+    signMessage(message: string): Promise<string>;
+    sendTransactions(txs: WarpAdapterGenericTransaction[]): Promise<string[]>;
+    sendTransaction(tx: WarpAdapterGenericTransaction): Promise<string>;
+    importFromMnemonic(mnemonic: string): Promise<WarpWalletDetails>;
+    importFromPrivateKey(privateKey: string): Promise<WarpWalletDetails>;
+    export(provider: WarpWalletProvider): Promise<WarpWalletDetails>;
+    generate(provider: WarpWalletProvider): Promise<WarpWalletDetails>;
+    getAddress(): string | null;
+    getPublicKey(): string | null;
+    registerX402Handlers?(client: unknown): Promise<Record<string, () => void>>;
+}
+
+type WarpChainAccount = {
+    chain: WarpChainName;
+    address: string;
+    balance: bigint;
+};
+type WarpChainAssetValue = {
+    identifier: string;
+    amount: bigint;
+};
+type WarpChainAssetLogoThemed = Record<WarpTheme, string>;
+type WarpChainAssetLogo = string | WarpChainAssetLogoThemed | null;
+type WarpChainAsset = {
+    chain: WarpChainName;
+    identifier: string;
+    name: string;
+    symbol: string;
+    amount?: bigint;
+    decimals?: number;
+    logoUrl?: WarpChainAssetLogo;
+    price?: number;
+    supply?: bigint;
+};
+type WarpChainAction = {
+    chain: WarpChainName;
+    id: string;
+    sender: string;
+    receiver: string;
+    value: bigint;
+    function: string;
+    status: WarpChainActionStatus;
+    createdAt: string;
+    error?: string | null;
+    tx?: WarpAdapterGenericRemoteTransaction | null;
+};
+type WarpChainActionStatus = 'pending' | 'success' | 'failed';
+
+type WarpExplorerName = string;
+type WarpChainInfoLogoThemed = Record<WarpTheme, string>;
+type WarpChainInfoLogo = string | WarpChainInfoLogoThemed;
+type WarpChainInfo = {
+    name: WarpChainName;
+    displayName: string;
+    chainId: string;
+    blockTime: number;
+    addressHrp: string;
+    defaultApiUrl: string;
+    logoUrl: WarpChainInfoLogo;
+    nativeToken: WarpChainAsset;
+};
+type WarpIdentifierType = 'hash' | 'alias';
+type WarpVarPlaceholder = string;
+type WarpOutputName = string;
+type WarpResulutionPath = string;
+type WarpMessageName = string;
+type Warp = {
+    protocol: string;
+    chain?: WarpChainName;
+    name: string;
+    title: WarpText;
+    description: WarpText | null;
+    bot?: string;
+    preview?: string;
+    vars?: Record<WarpVarPlaceholder, string>;
+    actions: WarpAction[];
+    next?: string;
+    output?: Record<WarpOutputName, WarpResulutionPath>;
+    messages?: Record<WarpMessageName, WarpText>;
+    ui?: string;
+    alerts?: WarpAlerts;
+    related?: string[];
+    meta?: WarpMeta;
+};
+type WarpMeta = {
+    chain: WarpChainName;
+    identifier: string;
+    query: string | null;
+    hash: string;
+    creator: string;
+    createdAt: string;
+};
+type WarpAction = WarpTransferAction | WarpContractAction | WarpQueryAction | WarpCollectAction | WarpLinkAction | WarpMcpAction | WarpPromptAction;
+type WarpActionIndex = number;
+type WarpActionType = 'transfer' | 'contract' | 'query' | 'collect' | 'link' | 'mcp' | 'prompt';
+type WarpTransferAction = {
+    type: WarpActionType;
+    label: WarpText;
+    description?: WarpText | null;
+    address?: string;
+    data?: string;
+    value?: string;
+    transfers?: string[];
+    inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
+    next?: string;
+    when?: string;
+};
+type WarpContractAction = {
+    type: WarpActionType;
+    label: WarpText;
+    description?: WarpText | null;
+    address?: string;
+    func?: string | null;
+    args?: string[];
+    value?: string;
+    gasLimit: number;
+    transfers?: string[];
+    abi?: string;
+    inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
+    next?: string;
+    when?: string;
+};
+type WarpQueryAction = {
+    type: WarpActionType;
+    label: WarpText;
+    description?: WarpText | null;
+    address?: string;
+    func?: string;
+    args?: string[];
+    abi?: string;
+    inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
+    next?: string;
+    when?: string;
+};
+type WarpCollectAction = {
+    type: WarpActionType;
+    label: WarpText;
+    description?: WarpText | null;
+    destination?: WarpCollectDestination;
+    inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
+    next?: string;
+    when?: string;
+};
+type WarpCollectDestination = WarpCollectDestinationHttp | string;
+type WarpCollectDestinationHttp = {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    headers?: Record<string, string>;
+};
+type WarpLinkAction = {
+    type: WarpActionType;
+    label: WarpText;
+    description?: WarpText | null;
+    url: string;
+    inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
+    when?: string;
+};
+type WarpMcpAction = {
+    type: WarpActionType;
+    label: WarpText;
+    description?: WarpText | null;
+    destination?: WarpMcpDestination;
+    inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
+    next?: string;
+    when?: string;
+};
+type WarpMcpDestination = {
+    url: string;
+    tool: string;
+    headers?: Record<string, string>;
+};
+type WarpPromptAction = {
+    type: WarpActionType;
+    label: WarpText;
+    description?: WarpText | null;
+    prompt: string;
+    inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
+    next?: string;
+    when?: string;
+};
+type WarpActionInputSource = 'field' | 'query' | 'user:wallet' | 'hidden';
+type BaseWarpActionInputType = 'string' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'uint128' | 'uint256' | 'biguint' | 'bool' | 'address' | 'hex' | string;
+type WarpActionInputType = string;
+interface WarpStructValue {
+    [key: string]: WarpNativeValue;
+}
+type WarpNativeValue = string | number | bigint | boolean | WarpChainAssetValue | null | WarpNativeValue[] | WarpStructValue;
+type WarpActionInputPosition = 'receiver' | 'value' | 'transfer' | `arg:${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}` | 'data' | 'chain' | `payload:${string}` | 'destination' | WarpActionInputPositionAssetObject;
+type WarpActionInputPositionAssetObject = {
+    token: `arg:${string}`;
+    amount: `arg:${string}`;
+};
+type WarpActionInputModifier = 'scale' | 'transform';
+type WarpActionInput = {
+    name: string;
+    as?: string;
+    label?: WarpText;
+    description?: WarpText | null;
+    bot?: string;
+    type: WarpActionInputType;
+    position?: WarpActionInputPosition;
+    source: WarpActionInputSource;
+    required?: boolean;
+    min?: number | WarpVarPlaceholder;
+    max?: number | WarpVarPlaceholder;
+    pattern?: string;
+    patternDescription?: WarpText;
+    options?: string[] | {
+        [key: string]: WarpText;
+    };
+    modifier?: string;
+    default?: string | number | boolean;
+};
+type ResolvedInput = {
+    input: WarpActionInput;
+    value: string | null;
+};
+type WarpContract = {
+    address: string;
+    owner: string;
+    verified: boolean;
+};
+type WarpContractVerification = {
+    codeHash: string;
+    abi: object;
+};
+type WarpExecutable = {
+    adapter: ChainAdapter;
+    chain: WarpChainInfo;
+    warp: Warp;
+    action: number;
+    destination: string | null;
+    args: string[];
+    value: bigint;
+    transfers: WarpChainAssetValue[];
+    data: string | null;
+    resolvedInputs: ResolvedInput[];
+};
+
+type WarpAbi = {
+    protocol: string;
+    content: WarpAbiContents;
+    meta?: WarpMeta;
+};
+type WarpAbiContents = {
+    name?: string;
+    constructor?: any;
+    upgradeConstructor?: any;
+    endpoints?: any[];
+    types?: Record<string, any>;
+    events?: any[];
+};
+
+type WarpSecret = {
+    key: string;
+    description?: string | null;
+};
+
+type InterpolationBag = {
+    config: WarpClientConfig;
+    adapter: ChainAdapter;
+};
+
+declare const WarpProtocolVersions: {
+    Warp: string;
+    Brand: string;
+    Abi: string;
+};
+declare const WarpConfig: {
+    LatestWarpSchemaUrl: string;
+    LatestBrandSchemaUrl: string;
+    DefaultClientUrl: (env: WarpChainEnv) => "https://usewarp.to" | "https://testnet.usewarp.to" | "https://devnet.usewarp.to";
+    SuperClientUrls: string[];
+    AvailableActionInputSources: WarpActionInputSource[];
+    AvailableActionInputTypes: WarpActionInputType[];
+    AvailableActionInputPositions: WarpActionInputPosition[];
+};
+
+declare const withAdapterFallback: (factory: ChainAdapterFactory, fallbackFactory: ChainAdapterFactory) => ChainAdapterFactory;
+
+declare const getEventNameFromWarp: (warp: Warp, alertName: string) => string | null;
+
+declare const getWarpBrandLogoUrl: (brand: WarpBrand, config?: WarpClientConfig) => string;
+declare const getWarpChainAssetLogoUrl: (asset: WarpChainAsset, config?: WarpClientConfig) => string | null;
+declare const getWarpChainInfoLogoUrl: (chainInfo: WarpChainInfo, config?: WarpClientConfig) => string;
+
+interface CryptoProvider {
+    getRandomBytes(size: number): Promise<Uint8Array>;
+}
+declare class BrowserCryptoProvider implements CryptoProvider {
+    getRandomBytes(size: number): Promise<Uint8Array>;
+}
+declare class NodeCryptoProvider implements CryptoProvider {
+    getRandomBytes(size: number): Promise<Uint8Array>;
+}
+declare function getCryptoProvider(): CryptoProvider;
+declare function setCryptoProvider(provider: CryptoProvider): void;
+declare function getRandomBytes(size: number, cryptoProvider?: CryptoProvider): Promise<Uint8Array>;
+declare function bytesToHex(bytes: Uint8Array): string;
+declare function bytesToBase64(bytes: Uint8Array): string;
+declare function getRandomHex(length: number, cryptoProvider?: CryptoProvider): Promise<string>;
+declare function testCryptoAvailability(): Promise<{
+    randomBytes: boolean;
+    environment: 'browser' | 'nodejs' | 'unknown';
+}>;
+declare function createCryptoProvider(): CryptoProvider;
+
+declare const extractWarpSecrets: (warp: Warp) => WarpSecret[];
+
+declare const findWarpAdapterForChain: (chain: WarpChainName, adapters: ChainAdapter[]) => ChainAdapter;
+declare const getLatestProtocolIdentifier: (name: ProtocolName) => string;
+declare const getWarpActionByIndex: (warp: Warp, index: number) => WarpAction;
+declare const getWarpPrimaryAction: (warp: Warp) => {
+    action: WarpAction;
+    index: number;
+};
+declare const isWarpActionAutoExecute: (action: WarpAction, warp: Warp) => boolean;
+declare const shiftBigintBy: (value: bigint | string | number, decimals: number) => bigint;
+declare const toPreviewText: (text: string, maxChars?: number) => string;
+declare const replacePlaceholders: (message: string, bag: Record<string, any>) => string;
+declare const replacePlaceholdersInWhenExpression: (expression: string, bag: Record<string, any>) => string;
+declare const evaluateWhenCondition: (expression: string) => boolean;
+
+declare const WARP_LANGUAGES: {
+    readonly de: "German";
+    readonly en: "English";
+    readonly es: "Spanish";
+    readonly fr: "French";
+    readonly it: "Italian";
+    readonly pt: "Portuguese";
+    readonly ru: "Russian";
+    readonly zh: "Chinese";
+    readonly ja: "Japanese";
+    readonly ko: "Korean";
+    readonly ar: "Arabic";
+    readonly hi: "Hindi";
+    readonly nl: "Dutch";
+    readonly sv: "Swedish";
+    readonly da: "Danish";
+    readonly no: "Norwegian";
+    readonly fi: "Finnish";
+    readonly pl: "Polish";
+    readonly tr: "Turkish";
+    readonly el: "Greek";
+    readonly he: "Hebrew";
+    readonly th: "Thai";
+    readonly vi: "Vietnamese";
+    readonly id: "Indonesian";
+    readonly ms: "Malay";
+    readonly tl: "Tagalog";
+};
+declare const resolveWarpText: (text: WarpText, config?: WarpClientConfig) => string;
+declare const isWarpI18nText: (text: WarpText) => text is WarpI18nText;
+declare const createWarpI18nText: (translations: Record<string, string>) => WarpI18nText;
+
+declare const cleanWarpIdentifier: (identifier: string) => string;
+declare const isEqualWarpIdentifier: (identifier1: string | null | undefined, identifier2: string | null | undefined) => boolean;
+declare const createWarpIdentifier: (chain: WarpChainName, type: WarpIdentifierType, identifier: string) => string;
+declare const getWarpInfoFromIdentifier: (prefixedIdentifier: string) => {
+    chain: WarpChainName;
+    type: WarpIdentifierType;
+    identifier: string;
+    identifierBase: string;
+} | null;
+declare const extractIdentifierInfoFromUrl: (url: string) => {
+    chain: WarpChainName;
+    type: WarpIdentifierType;
+    identifier: string;
+    identifierBase: string;
+} | null;
+declare const extractQueryStringFromUrl: (url: string) => string | null;
+declare const extractQueryStringFromIdentifier: (identifier: string) => string | null;
+
+/**
+ * Splits an input string into type and value, using only the first colon as separator.
+ * This handles cases where the value itself contains colons (like SUI token IDs).
+ */
+declare const splitInput: (input: string) => [WarpActionInputType, string];
+declare const hasInputPrefix: (input: string) => boolean;
+
+declare const applyOutputToMessages: (warp: Warp, output: Record<string, any>, config: WarpClientConfig) => Record<string, string>;
+
+declare const getNextInfo: (config: WarpClientConfig, adapters: ChainAdapter[], warp: Warp, actionIndex: number, output: WarpExecutionOutput) => WarpExecutionNextInfo | null;
+
+declare class WarpSerializer {
+    private readonly typeRegistry?;
+    constructor(options?: {
+        typeRegistry?: AdapterTypeRegistry;
+    });
+    nativeToString(type: WarpActionInputType, value: WarpNativeValue): string;
+    stringToNative(value: string): [WarpActionInputType, WarpNativeValue];
+    private getTypeAndValue;
+}
+
+declare const extractCollectOutput: (warp: Warp, response: any, actionIndex: number, inputs: ResolvedInput[], serializer: WarpSerializer, config: WarpClientConfig) => Promise<{
+    values: {
+        string: string[];
+        native: any[];
+        mapped: Record<string, any>;
+    };
+    output: WarpExecutionOutput;
+}>;
+declare const evaluateOutputCommon: (warp: Warp, baseOutput: WarpExecutionOutput, actionIndex: number, inputs: ResolvedInput[], serializer: WarpSerializer, config: WarpClientConfig) => Promise<WarpExecutionOutput>;
+declare const extractPromptOutput: (warp: Warp, promptValue: string, actionIndex: number, inputs: ResolvedInput[], serializer: WarpSerializer, config: WarpClientConfig) => Promise<{
+    values: {
+        string: string[];
+        native: any[];
+        mapped: Record<string, any>;
+    };
+    output: WarpExecutionOutput;
+}>;
+declare const parseOutputOutIndex: (outputPath: string) => number | null;
+
+/**
+ * Builds a nested payload object from a position string and field value.
+ * Position strings should be in format: "payload:path.to.nested.location"
+ *
+ * @param position - The position string defining where to place the value
+ * @param fieldName - The field name to use for the value
+ * @param value - The value to place at the position
+ * @returns A nested object structure or flat object if position doesn't start with 'payload:'
+ */
+declare function buildNestedPayload(position: string, fieldName: string, value: any): any;
+/**
+ * Recursively merges a source object into a target object and returns the merged result.
+ * Existing nested objects are merged recursively, primitive values are overwritten.
+ * Does not mutate the original target or source objects.
+ *
+ * @param target - The target object to merge into
+ * @param source - The source object to merge from
+ * @returns A new object with the merged result
+ */
+declare function mergeNestedPayload(target: any, source: any): any;
+/**
+ * Converts a resolved input to a payload value, handling special types like biguint and asset.
+ *
+ * @param resolvedInput - The resolved input to convert
+ * @param serializer - The serializer to use for conversion
+ * @returns The converted value, or null if the input has no value
+ */
+declare function toInputPayloadValue(resolvedInput: ResolvedInput, serializer: WarpSerializer): any;
+/**
+ * Extracts non-empty string values from resolved inputs.
+ *
+ * @param inputs - The resolved inputs to extract values from
+ * @returns An array of non-empty string values
+ */
+declare function extractResolvedInputValues(inputs: ResolvedInput[]): string[];
+/**
+ * Builds a mapped output object from resolved inputs, using input name or "as" property as key.
+ * This is the same structure as the payload, but used for output mapping.
+ *
+ * @param inputs - The resolved inputs to build the mapped output from
+ * @param serializer - The serializer to use for value conversion
+ * @returns A mapped object with input names/aliases as keys and converted values
+ */
+declare function buildMappedOutput(inputs: ResolvedInput[], serializer: WarpSerializer): Record<string, any>;
+
+declare const getProviderConfig: (config: WarpClientConfig, chain: WarpChainName, env: WarpChainEnv, defaultProvider: string) => WarpProviderConfig;
+
+/**
+ * Signing utilities for creating and validating signed messages
+ * Works with any crypto provider or uses automatic detection
+ */
+
+interface SignableMessage {
+    wallet: string;
+    nonce: string;
+    expiresAt: string;
+    purpose: string;
+}
+type HttpAuthHeaders = Record<string, string> & {
+    'X-Signer-Wallet': string;
+    'X-Signer-Signature': string;
+    'X-Signer-Nonce': string;
+    'X-Signer-ExpiresAt': string;
+};
+/**
+ * Creates a signable message with standard security fields
+ * This can be used for any type of proof or authentication
+ */
+declare function createSignableMessage(walletAddress: string, purpose: string, cryptoProvider?: CryptoProvider, expiresInMinutes?: number): Promise<{
+    message: string;
+    nonce: string;
+    expiresAt: string;
+}>;
+/**
+ * Creates a signable message for HTTP authentication
+ * This is a convenience function that uses the standard format
+ */
+declare function createAuthMessage(walletAddress: string, appName: string, cryptoProvider?: CryptoProvider, purpose?: string): Promise<{
+    message: string;
+    nonce: string;
+    expiresAt: string;
+}>;
+/**
+ * Creates HTTP authentication headers from a signature
+ */
+declare function createAuthHeaders(walletAddress: string, signature: string, nonce: string, expiresAt: string): HttpAuthHeaders;
+/**
+ * Creates HTTP authentication headers for a wallet using the provided signing function
+ */
+declare function createHttpAuthHeaders(walletAddress: string, signMessage: (message: string) => Promise<string>, appName: string, cryptoProvider?: CryptoProvider): Promise<HttpAuthHeaders>;
+/**
+ * Validates a signed message by checking expiration
+ */
+declare function validateSignedMessage(expiresAt: string): boolean;
+/**
+ * Parses a signed message to extract its components
+ */
+declare function parseSignedMessage(message: string): SignableMessage;
+
+declare const getWalletFromConfigOrFail: (config: WarpClientConfig, chain: WarpChainName) => string | WarpWalletDetails;
+declare const getWarpWalletAddress: (wallet: WarpWalletDetails | string | null | undefined) => string | null;
+declare const getWarpWalletAddressFromConfig: (config: WarpClientConfig, chain: WarpChainName) => string | null;
+declare const getWarpWalletPrivateKey: (wallet: WarpWalletDetails | string | null | undefined) => string | null;
+declare const getWarpWalletMnemonic: (wallet: WarpWalletDetails | string | null | undefined) => string | null;
+declare const getWarpWalletExternalId: (wallet: WarpWalletDetails | string | null | undefined) => string | null;
+declare const getWarpWalletPrivateKeyFromConfig: (config: WarpClientConfig, chain: WarpChainName) => string | null;
+declare const getWarpWalletMnemonicFromConfig: (config: WarpClientConfig, chain: WarpChainName) => string | null;
+declare const getWarpWalletExternalIdFromConfig: (config: WarpClientConfig, chain: WarpChainName) => string | null;
+declare const getWarpWalletExternalIdFromConfigOrFail: (config: WarpClientConfig, chain: WarpChainName) => string;
+declare const isWarpWalletReadOnly: (wallet: WarpWalletDetails | string | null | undefined) => boolean;
+declare const setWarpWalletInConfig: (config: WarpClientConfig, chain: WarpChainName, wallet: WarpWalletDetails) => void;
+declare const normalizeMnemonic: (mnemonic: string | undefined | null) => string;
+declare const validateMnemonicLength: (mnemonic: string, expectedWords?: number) => void;
+declare const normalizeAndValidateMnemonic: (mnemonic: string, expectedWords?: number) => string;
+
+interface WalletCache {
+    address: string | null;
+    publicKey: string | null;
+}
+declare function initializeWalletCache(provider: WalletProvider | null): Promise<WalletCache>;
+
+declare function createDefaultWalletProvider(config: WarpClientConfig, chain: WarpChainInfo, rpcProvider?: any): WalletProvider | null;
+
+declare function handleX402Payment(response: Response, url: string, method: string, body: string | undefined, adapters: ChainAdapter[]): Promise<Response>;
+
+type CodecFunc<T extends WarpNativeValue = WarpNativeValue> = (value: T) => string;
+declare const string: CodecFunc<string>;
+declare const uint8: CodecFunc<number>;
+declare const uint16: CodecFunc<number>;
+declare const uint32: CodecFunc<number>;
+declare const uint64: CodecFunc<bigint | number>;
+declare const biguint: CodecFunc<bigint | string | number>;
+declare const bool: CodecFunc<boolean>;
+declare const address: CodecFunc<string>;
+declare const asset: CodecFunc<WarpChainAssetValue & {
+    decimals?: number;
+}>;
+declare const hex: CodecFunc<string>;
+declare const option: <T extends WarpNativeValue>(codecFunc: CodecFunc<T>, value: T | null) => string;
+declare const tuple: (...values: WarpNativeValue[]) => string;
+declare const struct: CodecFunc<WarpStructValue>;
+declare const vector: CodecFunc<WarpNativeValue[]>;
+
+declare class WarpBrandBuilder {
+    private config;
+    private pendingBrand;
+    constructor(config: WarpClientConfig);
+    createFromRaw(encoded: string, validateSchema?: boolean): Promise<WarpBrand>;
+    setName(name: WarpText): WarpBrandBuilder;
+    setDescription(description: WarpText): WarpBrandBuilder;
+    setLogo(logo: WarpBrandLogo): WarpBrandBuilder;
+    setUrls(urls: WarpBrandUrls): WarpBrandBuilder;
+    setColors(colors: WarpBrandColors): WarpBrandBuilder;
+    setCta(cta: WarpBrandCta): WarpBrandBuilder;
+    build(): Promise<WarpBrand>;
+    private ensure;
+    private ensureWarpText;
+    private ensureValidSchema;
+}
+
+declare class WarpBuilder implements BaseWarpBuilder {
+    protected readonly config: WarpClientConfig;
+    private pendingWarp;
+    constructor(config: WarpClientConfig);
+    createFromRaw(encoded: string, validate?: boolean): Promise<Warp>;
+    createFromUrl(url: string): Promise<Warp>;
+    setChain(chain: WarpChainName): WarpBuilder;
+    setName(name: string): WarpBuilder;
+    setTitle(title: WarpText): WarpBuilder;
+    setDescription(description: WarpText | null): WarpBuilder;
+    setPreview(preview: string): WarpBuilder;
+    setActions(actions: WarpAction[]): WarpBuilder;
+    addAction(action: WarpAction): WarpBuilder;
+    setOutput(output: Record<string, string> | null): WarpBuilder;
+    build(validate?: boolean): Promise<Warp>;
+    getDescriptionPreview(description: string, maxChars?: number): string;
+    private ensure;
+    private ensureWarpText;
+    private validate;
+}
+
+declare const CacheTtl: {
+    OneMinute: number;
+    OneHour: number;
+    OneDay: number;
+    OneWeek: number;
+    OneMonth: number;
+    OneYear: number;
+};
+declare const WarpCacheKey: {
+    Warp: (env: WarpChainEnv, id: string) => string;
+    WarpAbi: (env: WarpChainEnv, id: string) => string;
+    WarpExecutable: (env: WarpChainEnv, id: string, action: number) => string;
+    RegistryInfo: (env: WarpChainEnv, id: string) => string;
+    Brand: (env: WarpChainEnv, hash: string) => string;
+    Asset: (env: WarpChainEnv, chain: string, identifier: string) => string;
+};
+declare class WarpCache {
+    private strategy;
+    constructor(env: WarpChainEnv, config?: ClientCacheConfig);
+    private selectStrategy;
+    set<T>(key: string, value: T, ttl: number): void;
+    get<T>(key: string): T | null;
+    forget(key: string): void;
+    clear(): void;
+}
+
+type ExecutionHandlers = {
+    onExecuted?: (result: WarpActionExecutionResult) => void | Promise<void>;
+    onError?: (params: {
+        message: string;
+        result: WarpActionExecutionResult;
+    }) => void;
+    onSignRequest?: (params: {
+        message: string;
+        chain: WarpChainInfo;
+    }) => string | Promise<string>;
+    onActionExecuted?: (params: {
+        action: WarpActionIndex;
+        chain: WarpChainInfo | null;
+        execution: WarpActionExecutionResult | null;
+        tx: WarpAdapterGenericTransaction | null;
+    }) => void;
+    onActionUnhandled?: (params: {
+        action: WarpActionIndex;
+        chain: WarpChainInfo | null;
+        execution: WarpActionExecutionResult | null;
+        tx: WarpAdapterGenericTransaction | null;
+    }) => void;
+};
+declare class WarpExecutor {
+    private config;
+    private adapters;
+    private handlers?;
+    private factory;
+    constructor(config: WarpClientConfig, adapters: ChainAdapter[], handlers?: ExecutionHandlers | undefined);
+    execute(warp: Warp, inputs: string[], meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<{
+        txs: WarpAdapterGenericTransaction[];
+        chain: WarpChainInfo | null;
+        immediateExecutions: WarpActionExecutionResult[];
+        resolvedInputs: string[];
+    }>;
+    executeAction(warp: Warp, actionIndex: WarpActionIndex, inputs: string[], meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<{
+        tx: WarpAdapterGenericTransaction | null;
+        chain: WarpChainInfo | null;
+        immediateExecution: WarpActionExecutionResult | null;
+        executable: WarpExecutable | null;
+    }>;
+    evaluateOutput(warp: Warp, actions: WarpChainAction[]): Promise<void>;
+    private executeCollect;
+    private doHttpRequest;
+    private getDestinationFromResolvedInputs;
+    private executeMcp;
+    private buildCollectResult;
+    private callHandler;
+    private executePrompt;
+    private evaluateWhenCondition;
+}
+
+declare class WarpInterpolator {
+    private config;
+    private adapter;
+    private adapters?;
+    constructor(config: WarpClientConfig, adapter: ChainAdapter, adapters?: ChainAdapter[] | undefined);
+    apply(warp: Warp, meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<Warp>;
+    applyGlobals(warp: Warp): Promise<Warp>;
+    applyVars(warp: Warp, meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Warp;
+    private applyRootGlobals;
+    private applyActionGlobals;
+    applyInputs(text: string, resolvedInputs: ResolvedInput[], serializer: WarpSerializer, primaryInputs?: ResolvedInput[]): string;
+    private applyGlobalsToText;
+    private replacePlaceholdersWithChain;
+    buildInputBag(resolvedInputs: ResolvedInput[], serializer: WarpSerializer, primaryInputs?: ResolvedInput[]): Record<string, string>;
+}
+
+declare class WarpFactory {
+    private config;
+    private adapters;
+    private url;
+    private serializer;
+    private cache;
+    constructor(config: WarpClientConfig, adapters: ChainAdapter[]);
+    getSerializer(): WarpSerializer;
+    getResolvedInputsFromCache(env: WarpChainEnv, warpHash: string | undefined, actionIndex: number): string[];
+    createExecutable(warp: Warp, actionIndex: number, inputs: string[], meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<WarpExecutable>;
+    getChainInfoForWarp(warp: Warp, inputs?: string[]): Promise<WarpChainInfo>;
+    getStringTypedInputs(action: WarpAction, inputs: string[]): string[];
+    getResolvedInputs(chain: WarpChainName, action: WarpAction, inputArgs: string[], interpolator?: WarpInterpolator): Promise<ResolvedInput[]>;
+    private requiresPayloadInputs;
+    private resolveActionInputs;
+    getModifiedInputs(inputs: ResolvedInput[]): Promise<ResolvedInput[]>;
+    /**
+     * Builds a context object containing all previous evaluated inputs for use in transform modifiers.
+     *
+     * The context object provides access to inputs by their `as` field (if present) or `name` field.
+     * For asset-type inputs, additional properties are available:
+     * - `{key}` - The full asset object with `identifier` and `amount` properties
+     * - `{key}.token` - The asset identifier as a string
+     * - `{key}.amount` - The asset amount as a string
+     * - `{key}.identifier` - Alias for `{key}.token`
+     *
+     * @example
+     * // Given inputs:
+     * // - { name: 'Asset', as: 'asset', type: 'asset', value: 'asset:ETH|1000000000000000000' }
+     * // - { name: 'Amount', type: 'uint256', value: 'uint256:500' }
+     *
+     * // The context will be:
+     * {
+     *   asset: { identifier: 'ETH', amount: 1000000000000000000n },
+     *   'asset.token': 'ETH',
+     *   'asset.amount': '1000000000000000000',
+     *   'asset.identifier': 'ETH',
+     *   Amount: 500n
+     * }
+     *
+     * // Usage in transform modifier:
+     * // "modifier": "transform:(inputs) => inputs.asset?.identifier === 'ETH' ? {...} : inputs.asset"
+     *
+     * @param inputs - Array of all resolved inputs
+     * @param currentIndex - Index of the current input being processed
+     * @param currentInput - The current input being transformed (optional, included in context)
+     * @returns Context object with all previous inputs accessible by name/as
+     */
+    private buildInputContext;
+    preprocessInput(chain: WarpChainName, input: string): Promise<string>;
+    private getDestinationFromAction;
+    private getPreparedArgs;
+    private tryGetChainFromInputs;
+}
+
+declare class WarpIndex {
+    private config;
+    constructor(config: WarpClientConfig);
+    search(query: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<WarpSearchHit[]>;
+}
+
+declare class WarpLinkBuilder {
+    private readonly config;
+    private readonly adapters;
+    constructor(config: WarpClientConfig, adapters: ChainAdapter[]);
+    isValid(url: string): boolean;
+    build(chain: WarpChainName, type: WarpIdentifierType, id: string): string;
+    buildFromPrefixedIdentifier(identifier: string): string | null;
+    generateQrCode(chain: WarpChainName, type: WarpIdentifierType, id: string, size?: number, background?: string, color?: string, logoColor?: string): QRCodeStyling;
+}
+
+type DetectionResult = {
+    match: boolean;
+    url: string;
+    warp: Warp | null;
+    chain: WarpChainName | null;
+    registryInfo: WarpRegistryInfo | null;
+    brand: WarpBrand | null;
+};
+type DetectionResultFromHtml = {
+    match: boolean;
+    output: {
+        url: string;
+        warp: Warp;
+    }[];
+};
+declare class WarpLinkDetecter {
+    private config;
+    private adapters;
+    constructor(config: WarpClientConfig, adapters: ChainAdapter[]);
+    isValid(url: string): boolean;
+    detectFromHtml(content: string): Promise<DetectionResultFromHtml>;
+    detect(urlOrId: string, cache?: WarpCacheConfig): Promise<DetectionResult>;
+}
+
+type WarpClientOptions = {
+    chains: ChainAdapterFactory[];
+};
+declare class WarpClient {
+    private readonly config;
+    private readonly options;
+    readonly chains: ChainAdapter[];
+    constructor(config: WarpClientConfig, options: WarpClientOptions);
+    getConfig(): WarpClientConfig;
+    createExecutor(handlers?: ExecutionHandlers): WarpExecutor;
+    detectWarp(urlOrId: string, cache?: WarpCacheConfig): Promise<DetectionResult>;
+    executeWarp(warpOrIdentifierOrUrl: string | Warp, inputs: string[], handlers?: ExecutionHandlers, params?: {
+        cache?: WarpCacheConfig;
+        queries?: Record<string, any>;
+    }): Promise<{
+        txs: WarpAdapterGenericTransaction[];
+        chain: WarpChainInfo | null;
+        immediateExecutions: WarpActionExecutionResult[];
+        evaluateOutput: (remoteTxs: WarpAdapterGenericRemoteTransaction[]) => Promise<void>;
+        resolvedInputs: string[];
+    }>;
+    createInscriptionTransaction(chain: WarpChainName, warp: Warp): Promise<WarpAdapterGenericTransaction>;
+    createFromTransaction(chain: WarpChainName, tx: WarpAdapterGenericRemoteTransaction, validate?: boolean): Promise<Warp>;
+    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<Warp | null>;
+    signMessage(chain: WarpChainName, message: string): Promise<string>;
+    getActions(chain: WarpChainName, ids: string[], awaitCompleted?: boolean): Promise<WarpChainAction[]>;
+    getExplorer(chain: WarpChainName): AdapterWarpExplorer;
+    getOutput(chain: WarpChainName): AdapterWarpOutput;
+    getRegistry(chain: WarpChainName): Promise<AdapterWarpRegistry>;
+    getDataLoader(chain: WarpChainName): AdapterWarpDataLoader;
+    getWallet(chain: WarpChainName): AdapterWarpWallet;
+    get factory(): WarpFactory;
+    get index(): WarpIndex;
+    get linkBuilder(): WarpLinkBuilder;
+    createBuilder(chain: WarpChainName): CombinedWarpBuilder;
+    createAbiBuilder(chain: WarpChainName): AdapterWarpAbiBuilder;
+    createBrandBuilder(chain: WarpChainName): AdapterWarpBrandBuilder;
+    createSerializer(chain: WarpChainName): AdapterWarpSerializer;
+    resolveText(warpText: WarpText): string;
+}
+
+declare class WarpLogger {
+    private static isTestEnv;
+    static debug(...args: any[]): void;
+    static info(...args: any[]): void;
+    static warn(...args: any[]): void;
+    static error(...args: any[]): void;
+}
+
+declare class WarpTypeRegistry implements AdapterTypeRegistry {
+    private typeHandlers;
+    private typeAliases;
+    registerType(typeName: string, handler: WarpTypeHandler): void;
+    registerTypeAlias(typeName: string, alias: string): void;
+    hasType(typeName: string): boolean;
+    getHandler(typeName: string): WarpTypeHandler | undefined;
+    getAlias(typeName: string): string | undefined;
+    resolveType(typeName: string): string;
+    getRegisteredTypes(): string[];
+}
+
+type ValidationResult = {
+    valid: boolean;
+    errors: ValidationError[];
+};
+type ValidationError = string;
+declare class WarpValidator {
+    private config;
+    constructor(config: WarpClientConfig);
+    validate(warp: Warp): Promise<ValidationResult>;
+    private validatePrimaryAction;
+    private validateMaxOneValuePosition;
+    private validateVariableNamesAndResultNamesUppercase;
+    private validateAbiIsSetIfApplicable;
+    private validateSchema;
+}
+
+export { type AdapterTypeRegistry, type AdapterWarpAbiBuilder, type AdapterWarpBrandBuilder, type AdapterWarpBuilder, type AdapterWarpDataLoader, type AdapterWarpExecutor, type AdapterWarpExplorer, type AdapterWarpOutput, type AdapterWarpRegistry, type AdapterWarpSerializer, type AdapterWarpWallet, type BaseWarpActionInputType, type BaseWarpBuilder, BrowserCryptoProvider, CacheTtl, type ChainAdapter, type ChainAdapterFactory, type ClientIndexConfig, type ClientTransformConfig, type CodecFunc, type CombinedWarpBuilder, type CryptoProvider, type DetectionResult, type DetectionResultFromHtml, type ExecutionHandlers, type HttpAuthHeaders, type InterpolationBag, NodeCryptoProvider, type ProtocolName, type ResolvedInput, type SignableMessage, type TransformRunner, WARP_LANGUAGES, type WalletCache, type WalletProvider, type WalletProviderFactory, type Warp, type WarpAbi, type WarpAbiContents, type WarpAction, type WarpActionExecutionResult, type WarpActionExecutionStatus, type WarpActionIndex, type WarpActionInput, type WarpActionInputModifier, type WarpActionInputPosition, type WarpActionInputPositionAssetObject, type WarpActionInputSource, type WarpActionInputType, type WarpActionType, type WarpAdapterGenericRemoteTransaction, type WarpAdapterGenericTransaction, type WarpAdapterGenericType, type WarpAdapterGenericValue, type WarpAlert, type WarpAlertName, type WarpAlerts, type WarpBrand, WarpBrandBuilder, type WarpBrandColors, type WarpBrandCta, type WarpBrandLogo, type WarpBrandLogoThemed, type WarpBrandUrls, WarpBuilder, WarpCache, type WarpCacheConfig, WarpCacheKey, type WarpChainAccount, type WarpChainAction, type WarpChainActionStatus, type WarpChainAsset, type WarpChainAssetLogo, type WarpChainAssetLogoThemed, type WarpChainAssetValue, type WarpChainEnv, type WarpChainInfo, type WarpChainInfoLogo, type WarpChainInfoLogoThemed, WarpChainName, WarpClient, type WarpClientConfig, type WarpCollectAction, type WarpCollectDestination, type WarpCollectDestinationHttp, WarpConfig, WarpConstants, type WarpContract, type WarpContractAction, type WarpContractVerification, type WarpDataLoaderOptions, type WarpExecutable, type WarpExecutionMessages, type WarpExecutionNextInfo, type WarpExecutionOutput, WarpExecutor, type WarpExplorerName, WarpFactory, type WarpI18nText, type WarpIdentifierType, WarpIndex, WarpInputTypes, WarpInterpolator, type WarpLinkAction, WarpLinkBuilder, WarpLinkDetecter, type WarpLocale, WarpLogger, type WarpMcpAction, type WarpMcpDestination, type WarpMessageName, type WarpMeta, type WarpNativeValue, type WarpOutputName, type WarpPromptAction, WarpProtocolVersions, type WarpProviderConfig, type WarpProviderPreferences, type WarpQueryAction, type WarpRegistryConfigInfo, type WarpRegistryInfo, type WarpResulutionPath, type WarpSearchHit, type WarpSearchResult, type WarpSecret, WarpSerializer, type WarpStructValue, type WarpText, type WarpTheme, type WarpTransferAction, type WarpTrustStatus, type WarpTypeHandler, WarpTypeRegistry, type WarpUserWallets, WarpValidator, type WarpVarPlaceholder, type WarpWalletDetails, type WarpWalletProvider, address, applyOutputToMessages, asset, biguint, bool, buildMappedOutput, buildNestedPayload, bytesToBase64, bytesToHex, cleanWarpIdentifier, createAuthHeaders, createAuthMessage, createCryptoProvider, createDefaultWalletProvider, createHttpAuthHeaders, createSignableMessage, createWarpI18nText, createWarpIdentifier, evaluateOutputCommon, evaluateWhenCondition, extractCollectOutput, extractIdentifierInfoFromUrl, extractPromptOutput, extractQueryStringFromIdentifier, extractQueryStringFromUrl, extractResolvedInputValues, extractWarpSecrets, findWarpAdapterForChain, getCryptoProvider, getEventNameFromWarp, getLatestProtocolIdentifier, getNextInfo, getProviderConfig, getRandomBytes, getRandomHex, getWalletFromConfigOrFail, getWarpActionByIndex, getWarpBrandLogoUrl, getWarpChainAssetLogoUrl, getWarpChainInfoLogoUrl, getWarpInfoFromIdentifier, getWarpPrimaryAction, getWarpWalletAddress, getWarpWalletAddressFromConfig, getWarpWalletExternalId, getWarpWalletExternalIdFromConfig, getWarpWalletExternalIdFromConfigOrFail, getWarpWalletMnemonic, getWarpWalletMnemonicFromConfig, getWarpWalletPrivateKey, getWarpWalletPrivateKeyFromConfig, handleX402Payment, hasInputPrefix, hex, initializeWalletCache, isEqualWarpIdentifier, isWarpActionAutoExecute, isWarpI18nText, isWarpWalletReadOnly, mergeNestedPayload, normalizeAndValidateMnemonic, normalizeMnemonic, option, parseOutputOutIndex, parseSignedMessage, replacePlaceholders, replacePlaceholdersInWhenExpression, resolveWarpText, safeWindow, setCryptoProvider, setWarpWalletInConfig, shiftBigintBy, splitInput, string, struct, testCryptoAvailability, toInputPayloadValue, toPreviewText, tuple, uint16, uint32, uint64, uint8, validateMnemonicLength, validateSignedMessage, vector, withAdapterFallback };