@vleap/warps 3.0.0-alpha.13 → 3.0.0-alpha.131

package/dist/index.d.cts

@@ -0,0 +1,1028 @@
+import QRCodeStyling from 'qr-code-styling';
+
+type WarpLanguage = '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 = {
+    trigger: string;
+    subject: WarpText;
+    body: WarpText;
+    action?: string;
+};
+type WarpAlerts = Record<WarpAlertName, WarpAlert>;
+
+type WarpBrand = {
+    protocol: string;
+    name: WarpText;
+    description: WarpText;
+    logo: string;
+    urls?: WarpBrandUrls;
+    colors?: WarpBrandColors;
+    cta?: WarpBrandCta;
+    meta?: WarpMeta;
+};
+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;
+};
+type WarpCacheType = 'memory' | 'localStorage';
+
+type WarpChainEnv = 'mainnet' | 'testnet' | 'devnet';
+type ProtocolName = 'warp' | 'brand' | 'abi';
+
+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 WarpActionExecution = {
+    success: boolean;
+    warp: Warp;
+    action: number;
+    user: string | null;
+    txHash: string | null;
+    tx: WarpAdapterGenericTransaction | null;
+    next: WarpExecutionNextInfo | null;
+    values: {
+        string: string[];
+        native: WarpNativeValue[];
+    };
+    results: WarpExecutionResults;
+    messages: WarpExecutionMessages;
+};
+type WarpExecutionNextInfo = {
+    identifier: string | null;
+    url: string;
+}[];
+type WarpExecutionResults = Record<WarpResultName, any | null>;
+type WarpExecutionMessages = Record<WarpMessageName, string | null>;
+
+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;
+};
+
+type WarpWalletDetails = {
+    address: string;
+    mnemonic?: string | null;
+    privateKey?: string | null;
+};
+type WarpUserWallets = Record<WarpChain, WarpWalletDetails | string | null>;
+type WarpProviderConfig = Record<WarpChainEnv, string>;
+type WarpClientConfig = {
+    env: WarpChainEnv;
+    clientUrl?: string;
+    currentUrl?: string;
+    vars?: Record<string, string | number>;
+    user?: {
+        wallets?: WarpUserWallets;
+    };
+    preferences?: {
+        language?: WarpLanguage;
+        explorers?: Record<WarpChain, WarpExplorerName>;
+    };
+    providers?: Record<WarpChain, WarpProviderConfig>;
+    schema?: {
+        warp?: string;
+        brand?: string;
+    };
+    cache?: ClientCacheConfig;
+    transform?: ClientTransformConfig;
+    index?: ClientIndexConfig;
+    interceptors?: {
+        openLink?: (url: string) => Promise<void>;
+    };
+};
+type WarpCacheConfig = {
+    ttl?: number;
+};
+type AdapterFactory = (config: WarpClientConfig, fallback?: Adapter) => Adapter;
+type Adapter = {
+    chainInfo: WarpChainInfo;
+    prefix: string;
+    builder: () => CombinedWarpBuilder;
+    executor: AdapterWarpExecutor;
+    results: AdapterWarpResults;
+    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): BaseWarpBuilder;
+    setPreview(preview: string): BaseWarpBuilder;
+    setActions(actions: WarpAction[]): BaseWarpBuilder;
+    addAction(action: WarpAction): BaseWarpBuilder;
+    build(): 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<WarpActionExecution>;
+}
+interface AdapterWarpResults {
+    getActionExecution(warp: Warp, actionIndex: WarpActionIndex, tx: WarpAdapterGenericRemoteTransaction): Promise<WarpActionExecution>;
+}
+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>;
+    create(mnemonic: string): WarpWalletDetails;
+    generate(): WarpWalletDetails;
+    getAddress(): string | null;
+}
+
+type WarpChainAccount = {
+    chain: WarpChain;
+    address: string;
+    balance: bigint;
+};
+type WarpChainAssetValue = {
+    identifier: string;
+    amount: bigint;
+};
+type WarpChainAsset = {
+    chain: WarpChain;
+    identifier: string;
+    name: string;
+    symbol: string;
+    amount?: bigint;
+    decimals?: number;
+    logoUrl?: string | null;
+    price?: number;
+    supply?: bigint;
+};
+type WarpChainAction = {
+    chain: WarpChain;
+    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 WarpChain = string;
+type WarpExplorerName = string;
+type WarpChainInfo = {
+    name: string;
+    displayName: string;
+    chainId: string;
+    blockTime: number;
+    addressHrp: string;
+    defaultApiUrl: string;
+    logoUrl: string;
+    nativeToken: WarpChainAsset;
+};
+type WarpIdType = 'hash' | 'alias';
+type WarpVarPlaceholder = string;
+type WarpResultName = string;
+type WarpResulutionPath = string;
+type WarpMessageName = string;
+type Warp = {
+    protocol: string;
+    chain?: WarpChain;
+    name: string;
+    title: WarpText;
+    description: WarpText | null;
+    bot?: string;
+    preview?: string;
+    vars?: Record<WarpVarPlaceholder, string>;
+    actions: WarpAction[];
+    next?: string;
+    results?: Record<WarpResultName, WarpResulutionPath>;
+    messages?: Record<WarpMessageName, string>;
+    alerts?: WarpAlerts;
+    meta?: WarpMeta;
+};
+type WarpMeta = {
+    chain: WarpChain;
+    hash: string;
+    creator: string;
+    createdAt: string;
+};
+type WarpAction = WarpTransferAction | WarpContractAction | WarpQueryAction | WarpCollectAction | WarpLinkAction;
+type WarpActionIndex = number;
+type WarpActionType = 'transfer' | 'contract' | 'query' | 'collect' | 'link';
+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;
+};
+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;
+};
+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;
+};
+type WarpCollectAction = {
+    type: WarpActionType;
+    label: WarpText;
+    description?: WarpText | null;
+    destination: {
+        url: string;
+        method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+        headers?: Record<string, string>;
+    };
+    inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
+    next?: string;
+};
+type WarpLinkAction = {
+    type: WarpActionType;
+    label: WarpText;
+    description?: WarpText | null;
+    url: string;
+    inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
+};
+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}`;
+type WarpActionInputModifier = 'scale';
+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]: string;
+    };
+    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 = {
+    chain: WarpChainInfo;
+    warp: Warp;
+    action: number;
+    destination: string;
+    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;
+    chain: WarpChainInfo;
+};
+
+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 enum WarpChainName {
+    Multiversx = "multiversx",
+    Vibechain = "vibechain",
+    Sui = "sui",
+    Ethereum = "ethereum",
+    Base = "base",
+    Arbitrum = "arbitrum",
+    Somnia = "somnia",
+    Fastset = "fastset"
+}
+declare const WarpConstants: {
+    HttpProtocolPrefix: string;
+    IdentifierParamName: string;
+    IdentifierParamSeparator: string;
+    IdentifierChainDefault: string;
+    IdentifierType: {
+        Alias: WarpIdType;
+        Hash: WarpIdType;
+    };
+    IdentifierAliasMarker: string;
+    Globals: {
+        UserWallet: {
+            Placeholder: string;
+            Accessor: (bag: InterpolationBag) => string | WarpWalletDetails | null | undefined;
+        };
+        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;
+    };
+};
+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;
+
+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: WarpChain, adapters: Adapter[]) => Adapter;
+declare const findWarpAdapterByPrefix: (prefix: string, adapters: Adapter[]) => Adapter;
+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 applyResultsToMessages: (warp: Warp, results: Record<string, any>) => Record<string, string>;
+
+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 getWarpInfoFromIdentifier: (prefixedIdentifier: string) => {
+    chainPrefix: string;
+    type: WarpIdType;
+    identifier: string;
+    identifierBase: string;
+} | null;
+declare const extractIdentifierInfoFromUrl: (url: string) => {
+    chainPrefix: string;
+    type: WarpIdType;
+    identifier: string;
+    identifierBase: 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 getNextInfo: (config: WarpClientConfig, adapters: Adapter[], warp: Warp, actionIndex: number, results: WarpExecutionResults) => WarpExecutionNextInfo | 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;
+
+declare const getProviderUrl: (config: WarpClientConfig, chain: WarpChain, env: WarpChainEnv, defaultProvider: string) => string;
+declare const getProviderConfig: (config: WarpClientConfig, chain: WarpChain) => WarpProviderConfig | undefined;
+
+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 extractCollectResults: (warp: Warp, response: any, actionIndex: number, inputs: ResolvedInput[], serializer: WarpSerializer, transformRunner?: TransformRunner | null) => Promise<{
+    values: {
+        string: string[];
+        native: any[];
+    };
+    results: WarpExecutionResults;
+}>;
+declare const evaluateResultsCommon: (warp: Warp, baseResults: WarpExecutionResults, actionIndex: number, inputs: ResolvedInput[], serializer: WarpSerializer, transformRunner?: TransformRunner | null) => Promise<WarpExecutionResults>;
+/**
+ * Parses out[N] notation and returns the action index (1-based) or null if invalid.
+ * Also handles plain "out" which defaults to action index 1.
+ */
+declare const parseResultsOutIndex: (resultPath: string) => number | null;
+
+/**
+ * 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 getWarpWalletAddress: (wallet: WarpWalletDetails | string | null | undefined) => string | null;
+declare const getWarpWalletAddressFromConfig: (config: WarpClientConfig, chain: WarpChain) => string | null;
+declare const getWarpWalletPrivateKey: (wallet: WarpWalletDetails | string | null | undefined) => string | null | undefined;
+declare const getWarpWalletMnemonic: (wallet: WarpWalletDetails | string | null | undefined) => string | null | undefined;
+declare const getWarpWalletPrivateKeyFromConfig: (config: WarpClientConfig, chain: WarpChain) => string | null;
+declare const getWarpWalletMnemonicFromConfig: (config: WarpClientConfig, chain: WarpChain) => string | null;
+
+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: string): 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: WarpChain): WarpBuilder;
+    setName(name: string): WarpBuilder;
+    setTitle(title: WarpText): WarpBuilder;
+    setDescription(description: WarpText): WarpBuilder;
+    setPreview(preview: string): WarpBuilder;
+    setActions(actions: WarpAction[]): WarpBuilder;
+    addAction(action: WarpAction): WarpBuilder;
+    build(): 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(type?: WarpCacheType);
+    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: WarpActionExecution) => void | Promise<void>;
+    onError?: (params: {
+        message: string;
+    }) => void;
+    onSignRequest?: (params: {
+        message: string;
+        chain: WarpChainInfo;
+    }) => string | Promise<string>;
+    onActionExecuted?: (params: {
+        action: WarpActionIndex;
+        chain: WarpChainInfo | null;
+        execution: WarpActionExecution | null;
+        tx: WarpAdapterGenericTransaction | null;
+    }) => void;
+};
+declare class WarpExecutor {
+    private config;
+    private adapters;
+    private handlers?;
+    private factory;
+    constructor(config: WarpClientConfig, adapters: Adapter[], handlers?: ExecutionHandlers | undefined);
+    execute(warp: Warp, inputs: string[], meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<{
+        txs: WarpAdapterGenericTransaction[];
+        chain: WarpChainInfo | null;
+        immediateExecutions: WarpActionExecution[];
+    }>;
+    executeAction(warp: Warp, actionIndex: WarpActionIndex, inputs: string[], meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<{
+        tx: WarpAdapterGenericTransaction | null;
+        chain: WarpChainInfo | null;
+        immediateExecution: WarpActionExecution | null;
+    }>;
+    evaluateResults(warp: Warp, actions: WarpChainAction[]): Promise<void>;
+    private executeCollect;
+    private callHandler;
+}
+
+declare class WarpFactory {
+    private config;
+    private adapters;
+    private url;
+    private serializer;
+    private cache;
+    constructor(config: WarpClientConfig, adapters: Adapter[]);
+    getSerializer(): WarpSerializer;
+    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: WarpChain, action: WarpAction, inputArgs: string[]): Promise<ResolvedInput[]>;
+    getModifiedInputs(inputs: ResolvedInput[]): ResolvedInput[];
+    preprocessInput(chain: WarpChain, 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: Adapter[]);
+    isValid(url: string): boolean;
+    build(chain: WarpChain, type: WarpIdType, id: string): string;
+    buildFromPrefixedIdentifier(identifier: string): string | null;
+    generateQrCode(chain: WarpChain, type: WarpIdType, id: string, size?: number, background?: string, color?: string, logoColor?: string): QRCodeStyling;
+}
+
+type DetectionResult = {
+    match: boolean;
+    url: string;
+    warp: Warp | null;
+    chain: WarpChain | null;
+    registryInfo: WarpRegistryInfo | null;
+    brand: WarpBrand | null;
+};
+type DetectionResultFromHtml = {
+    match: boolean;
+    results: {
+        url: string;
+        warp: Warp;
+    }[];
+};
+declare class WarpLinkDetecter {
+    private config;
+    private adapters;
+    constructor(config: WarpClientConfig, adapters: Adapter[]);
+    isValid(url: string): boolean;
+    detectFromHtml(content: string): Promise<DetectionResultFromHtml>;
+    detect(urlOrId: string, cache?: WarpCacheConfig): Promise<DetectionResult>;
+}
+
+declare class WarpClient {
+    private readonly config;
+    private adapters;
+    constructor(config: WarpClientConfig, adapters: Adapter[]);
+    getConfig(): WarpClientConfig;
+    getAdapters(): Adapter[];
+    addAdapter(adapter: Adapter): WarpClient;
+    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: WarpActionExecution[];
+        evaluateResults: (remoteTxs: WarpAdapterGenericRemoteTransaction[]) => Promise<void>;
+    }>;
+    createInscriptionTransaction(chain: WarpChain, warp: Warp): WarpAdapterGenericTransaction;
+    createFromTransaction(chain: WarpChain, tx: WarpAdapterGenericRemoteTransaction, validate?: boolean): Promise<Warp>;
+    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<Warp | null>;
+    signMessage(chain: WarpChain, message: string): Promise<string>;
+    getActions(chain: WarpChain, ids: string[], awaitCompleted?: boolean): Promise<WarpChainAction[]>;
+    getExplorer(chain: WarpChain): AdapterWarpExplorer;
+    getResults(chain: WarpChain): AdapterWarpResults;
+    getRegistry(chain: WarpChain): Promise<AdapterWarpRegistry>;
+    getDataLoader(chain: WarpChain): AdapterWarpDataLoader;
+    getWallet(chain: WarpChain): AdapterWarpWallet;
+    get factory(): WarpFactory;
+    get index(): WarpIndex;
+    get linkBuilder(): WarpLinkBuilder;
+    createBuilder(chain: WarpChain): CombinedWarpBuilder;
+    createAbiBuilder(chain: WarpChain): AdapterWarpAbiBuilder;
+    createBrandBuilder(chain: WarpChain): AdapterWarpBrandBuilder;
+    createSerializer(chain: WarpChain): AdapterWarpSerializer;
+    resolveText(warpText: WarpText): string;
+}
+
+declare class WarpInterpolator {
+    private config;
+    private adapter;
+    constructor(config: WarpClientConfig, adapter: Adapter);
+    apply(config: WarpClientConfig, warp: Warp, meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<Warp>;
+    applyGlobals(config: WarpClientConfig, warp: Warp): Promise<Warp>;
+    applyVars(config: WarpClientConfig, warp: Warp, meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Warp;
+    private applyRootGlobals;
+    private applyActionGlobals;
+}
+
+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 Adapter, type AdapterFactory, type AdapterTypeRegistry, type AdapterWarpAbiBuilder, type AdapterWarpBrandBuilder, type AdapterWarpBuilder, type AdapterWarpDataLoader, type AdapterWarpExecutor, type AdapterWarpExplorer, type AdapterWarpRegistry, type AdapterWarpResults, type AdapterWarpSerializer, type AdapterWarpWallet, type BaseWarpActionInputType, type BaseWarpBuilder, BrowserCryptoProvider, CacheTtl, 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, type Warp, type WarpAbi, type WarpAbiContents, type WarpAction, type WarpActionExecution, type WarpActionIndex, type WarpActionInput, type WarpActionInputModifier, type WarpActionInputPosition, type WarpActionInputSource, type WarpActionInputType, type WarpActionType, type WarpAdapterGenericRemoteTransaction, type WarpAdapterGenericTransaction, type WarpAdapterGenericType, type WarpAdapterGenericValue, type WarpBrand, WarpBrandBuilder, type WarpBrandColors, type WarpBrandCta, type WarpBrandUrls, WarpBuilder, WarpCache, type WarpCacheConfig, WarpCacheKey, type WarpChain, type WarpChainAccount, type WarpChainAction, type WarpChainActionStatus, type WarpChainAsset, type WarpChainAssetValue, type WarpChainEnv, type WarpChainInfo, WarpChainName, WarpClient, type WarpClientConfig, type WarpCollectAction, WarpConfig, WarpConstants, type WarpContract, type WarpContractAction, type WarpContractVerification, type WarpDataLoaderOptions, type WarpExecutable, type WarpExecutionMessages, type WarpExecutionNextInfo, type WarpExecutionResults, WarpExecutor, type WarpExplorerName, WarpFactory, type WarpI18nText, type WarpIdType, WarpIndex, WarpInputTypes, WarpInterpolator, type WarpLanguage, type WarpLinkAction, WarpLinkBuilder, WarpLinkDetecter, WarpLogger, type WarpMessageName, type WarpMeta, type WarpNativeValue, WarpProtocolVersions, type WarpProviderConfig, type WarpQueryAction, type WarpRegistryConfigInfo, type WarpRegistryInfo, type WarpResultName, type WarpResulutionPath, type WarpSearchHit, type WarpSearchResult, type WarpSecret, WarpSerializer, type WarpStructValue, type WarpText, type WarpTransferAction, type WarpTrustStatus, type WarpTypeHandler, WarpTypeRegistry, type WarpUserWallets, WarpValidator, type WarpVarPlaceholder, type WarpWalletDetails, address, applyResultsToMessages, asset, biguint, bool, buildNestedPayload, bytesToBase64, bytesToHex, createAuthHeaders, createAuthMessage, createCryptoProvider, createHttpAuthHeaders, createSignableMessage, createWarpI18nText, evaluateResultsCommon, extractCollectResults, extractIdentifierInfoFromUrl, extractWarpSecrets, findWarpAdapterByPrefix, findWarpAdapterForChain, getCryptoProvider, getLatestProtocolIdentifier, getNextInfo, getProviderConfig, getProviderUrl, getRandomBytes, getRandomHex, getWarpActionByIndex, getWarpInfoFromIdentifier, getWarpPrimaryAction, getWarpWalletAddress, getWarpWalletAddressFromConfig, getWarpWalletMnemonic, getWarpWalletMnemonicFromConfig, getWarpWalletPrivateKey, getWarpWalletPrivateKeyFromConfig, hasInputPrefix, hex, isWarpActionAutoExecute, isWarpI18nText, mergeNestedPayload, option, parseResultsOutIndex, parseSignedMessage, replacePlaceholders, resolveWarpText, safeWindow, setCryptoProvider, shiftBigintBy, splitInput, string, struct, testCryptoAvailability, toPreviewText, tuple, uint16, uint32, uint64, uint8, validateSignedMessage, vector };