@vleap/warps 3.0.0-alpha.99 → 3.0.0-beta.154

package/dist/index.d.cts

@@ -1,15 +1,36 @@
 import QRCodeStyling from 'qr-code-styling';
 
+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 WarpBrand = {
     protocol: string;
-    name: string;
-    description: string;
-    logo: string;
+    name: WarpText;
+    description: WarpText;
+    logo: WarpBrandLogo;
     urls?: WarpBrandUrls;
     colors?: WarpBrandColors;
     cta?: WarpBrandCta;
     meta?: WarpMeta;
 };
+type WarpBrandLogoThemed = {
+    light: string;
+    dark: string;
+};
+type WarpBrandLogo = string | WarpBrandLogoThemed;
 type WarpBrandUrls = {
     web?: string;
 };
@@ -18,9 +39,9 @@ type WarpBrandColors = {
     secondary?: string;
 };
 type WarpBrandCta = {
-    title: string;
-    description: string;
-    label: string;
+    title: WarpText;
+    description: WarpText;
+    label: WarpText;
     url: string;
 };
 
@@ -49,24 +70,27 @@ type WarpRegistryConfigInfo = {
     admins: string[];
 };
 
-type WarpExecution = {
-    success: boolean;
+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: any[];
-    valuesRaw: any[];
-    results: WarpExecutionResults;
+    values: {
+        string: string[];
+        native: WarpNativeValue[];
+    };
+    output: WarpExecutionOutput;
     messages: WarpExecutionMessages;
 };
 type WarpExecutionNextInfo = {
     identifier: string | null;
     url: string;
 }[];
-type WarpExecutionResults = Record<WarpResultName, any | null>;
+type WarpExecutionOutput = Record<WarpOutputName, any | null>;
 type WarpExecutionMessages = Record<WarpMessageName, string | null>;
 
 type ClientIndexConfig = {
@@ -96,8 +120,17 @@ type ClientTransformConfig = {
     runner?: TransformRunner | null;
 };
 
-type WarpUserWallets = Record<WarpChain, string | null>;
-type WarpProviderConfig = Record<WarpChainEnv, string>;
+type WarpWalletDetails = {
+    address: string;
+    mnemonic?: string | null;
+    privateKey?: string | null;
+};
+type WarpUserWallets = Record<WarpChain, WarpWalletDetails | string | null>;
+type WarpProviderPreferences = Partial<Record<WarpChainEnv, string | WarpProviderConfig>>;
+type WarpProviderConfig = {
+    url: string;
+    headers?: Record<string, string>;
+};
 type WarpClientConfig = {
     env: WarpChainEnv;
     clientUrl?: string;
@@ -107,9 +140,10 @@ type WarpClientConfig = {
         wallets?: WarpUserWallets;
     };
     preferences?: {
+        locale?: WarpLocale;
         explorers?: Record<WarpChain, WarpExplorerName>;
+        providers?: Record<WarpChain, WarpProviderPreferences>;
     };
-    providers?: Record<WarpChain, WarpProviderConfig>;
     schema?: {
         warp?: string;
         brand?: string;
@@ -117,6 +151,9 @@ type WarpClientConfig = {
     cache?: ClientCacheConfig;
     transform?: ClientTransformConfig;
     index?: ClientIndexConfig;
+    interceptors?: {
+        openLink?: (url: string) => Promise<void>;
+    };
 };
 type WarpCacheConfig = {
     ttl?: number;
@@ -124,17 +161,16 @@ type WarpCacheConfig = {
 type AdapterFactory = (config: WarpClientConfig, fallback?: Adapter) => Adapter;
 type Adapter = {
     chainInfo: WarpChainInfo;
-    prefix: string;
     builder: () => CombinedWarpBuilder;
     executor: AdapterWarpExecutor;
-    results: AdapterWarpResults;
+    output: AdapterWarpOutput;
     serializer: AdapterWarpSerializer;
     registry: AdapterWarpRegistry;
     explorer: AdapterWarpExplorer;
     abiBuilder: () => AdapterWarpAbiBuilder;
     brandBuilder: () => AdapterWarpBrandBuilder;
     dataLoader: AdapterWarpDataLoader;
-    registerTypes?: (typeRegistry: WarpTypeRegistry) => void;
+    wallet: AdapterWarpWallet;
 };
 type WarpAdapterGenericTransaction = any;
 type WarpAdapterGenericRemoteTransaction = any;
@@ -144,10 +180,13 @@ interface WarpTypeHandler {
     stringToNative(value: string): any;
     nativeToString(value: any): string;
 }
-interface WarpTypeRegistry {
+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 {
@@ -180,11 +219,10 @@ interface AdapterWarpBrandBuilder {
 }
 interface AdapterWarpExecutor {
     createTransaction(executable: WarpExecutable): Promise<WarpAdapterGenericTransaction>;
-    executeQuery(executable: WarpExecutable): Promise<WarpExecution>;
-    signMessage(message: string, privateKey: string): Promise<string>;
+    executeQuery(executable: WarpExecutable): Promise<WarpActionExecutionResult>;
 }
-interface AdapterWarpResults {
-    getTransactionExecutionResults(warp: Warp, tx: WarpAdapterGenericRemoteTransaction): Promise<WarpExecution>;
+interface AdapterWarpOutput {
+    getActionExecution(warp: Warp, actionIndex: WarpActionIndex, tx: WarpAdapterGenericRemoteTransaction): Promise<WarpActionExecutionResult>;
 }
 interface AdapterWarpSerializer {
     typedToString(value: WarpAdapterGenericValue): string;
@@ -233,6 +271,16 @@ interface AdapterWarpDataLoader {
     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;
@@ -250,7 +298,9 @@ type WarpChainAsset = {
     symbol: string;
     amount?: bigint;
     decimals?: number;
-    logoUrl?: string;
+    logoUrl?: string | null;
+    price?: number;
+    supply?: bigint;
 };
 type WarpChainAction = {
     chain: WarpChain;
@@ -275,29 +325,35 @@ type WarpChainInfo = {
     blockTime: number;
     addressHrp: string;
     defaultApiUrl: string;
+    logoUrl: string;
     nativeToken: WarpChainAsset;
 };
-type WarpIdType = 'hash' | 'alias';
+type WarpIdentifierType = 'hash' | 'alias';
 type WarpVarPlaceholder = string;
-type WarpResultName = string;
+type WarpOutputName = string;
 type WarpResulutionPath = string;
 type WarpMessageName = string;
 type Warp = {
     protocol: string;
+    chain?: WarpChain;
     name: string;
-    title: string;
-    description: string | null;
+    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>;
+    output?: Record<WarpOutputName, WarpResulutionPath>;
+    messages?: Record<WarpMessageName, WarpText>;
+    alerts?: WarpAlerts;
+    related?: string[];
     meta?: WarpMeta;
 };
 type WarpMeta = {
     chain: WarpChain;
+    identifier: string;
+    query: string | null;
     hash: string;
     creator: string;
     createdAt: string;
@@ -307,21 +363,21 @@ type WarpActionIndex = number;
 type WarpActionType = 'transfer' | 'contract' | 'query' | 'collect' | 'link';
 type WarpTransferAction = {
     type: WarpActionType;
-    chain?: WarpChain;
-    label: string;
-    description?: string | null;
+    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;
-    chain?: WarpChain;
-    label: string;
-    description?: string | null;
+    label: WarpText;
+    description?: WarpText | null;
     address?: string;
     func?: string | null;
     args?: string[];
@@ -330,51 +386,62 @@ type WarpContractAction = {
     transfers?: string[];
     abi?: string;
     inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
     next?: string;
 };
 type WarpQueryAction = {
     type: WarpActionType;
-    chain?: WarpChain;
-    label: string;
-    description?: string | null;
+    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;
-    chain?: WarpChain;
-    label: string;
-    description?: string | null;
-    destination: {
-        url: string;
-        method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
-        headers?: Record<string, string>;
-    };
+    label: WarpText;
+    description?: WarpText | null;
+    destination?: WarpCollectDestination;
     inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
     next?: string;
 };
+type WarpCollectDestination = WarpCollectDestinationHttp | string;
+type WarpCollectDestinationHttp = {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    headers?: Record<string, string>;
+};
 type WarpLinkAction = {
     type: WarpActionType;
-    chain?: WarpChain;
-    label: string;
-    description?: string | null;
+    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;
-type WarpNativeValue = string | number | bigint | boolean | WarpChainAssetValue | null | WarpNativeValue[];
-type WarpActionInputPosition = 'receiver' | 'value' | 'transfer' | `arg:${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}` | 'data' | 'chain' | `payload:${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';
 type WarpActionInputModifier = 'scale';
 type WarpActionInput = {
     name: string;
     as?: string;
-    description?: string | null;
+    label?: WarpText;
+    description?: WarpText | null;
     bot?: string;
     type: WarpActionInputType;
     position?: WarpActionInputPosition;
@@ -383,9 +450,9 @@ type WarpActionInput = {
     min?: number | WarpVarPlaceholder;
     max?: number | WarpVarPlaceholder;
     pattern?: string;
-    patternDescription?: string;
+    patternDescription?: WarpText;
     options?: string[] | {
-        [key: string]: string;
+        [key: string]: WarpText;
     };
     modifier?: string;
     default?: string | number | boolean;
@@ -407,7 +474,7 @@ type WarpExecutable = {
     chain: WarpChainInfo;
     warp: Warp;
     action: number;
-    destination: string;
+    destination: string | null;
     args: string[];
     value: bigint;
     transfers: WarpChainAssetValue[];
@@ -429,6 +496,31 @@ type WarpAbiContents = {
     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",
@@ -442,17 +534,17 @@ declare enum WarpChainName {
 declare const WarpConstants: {
     HttpProtocolPrefix: string;
     IdentifierParamName: string;
-    IdentifierParamSeparator: string[];
-    IdentifierParamSeparatorDefault: string;
+    IdentifierParamSeparator: string;
     IdentifierChainDefault: string;
     IdentifierType: {
-        Alias: WarpIdType;
-        Hash: WarpIdType;
+        Alias: WarpIdentifierType;
+        Hash: WarpIdentifierType;
     };
+    IdentifierAliasMarker: string;
     Globals: {
         UserWallet: {
             Placeholder: string;
-            Accessor: (bag: InterpolationBag) => string | null | undefined;
+            Accessor: (bag: InterpolationBag) => string | WarpWalletDetails | null | undefined;
         };
         ChainApiUrl: {
             Placeholder: string;
@@ -469,6 +561,8 @@ declare const WarpConstants: {
     };
     ArgParamsSeparator: string;
     ArgCompositeSeparator: string;
+    ArgListSeparator: string;
+    ArgStructSeparator: string;
     Transform: {
         Prefix: string;
     };
@@ -478,48 +572,35 @@ declare const WarpConstants: {
     Position: {
         Payload: string;
     };
+    Alerts: {
+        TriggerEventPrefix: string;
+    };
 };
 declare const WarpInputTypes: {
     Option: string;
-    Optional: string;
-    List: string;
-    Variadic: string;
-    Composite: string;
+    Vector: string;
+    Tuple: string;
+    Struct: string;
     String: string;
-    U8: string;
-    U16: string;
-    U32: string;
-    U64: string;
-    U128: string;
-    U256: string;
+    Uint8: string;
+    Uint16: string;
+    Uint32: string;
+    Uint64: string;
+    Uint128: string;
+    Uint256: string;
     Biguint: string;
-    Boolean: string;
+    Bool: string;
     Address: string;
     Asset: string;
     Hex: string;
 };
+declare const safeWindow: Window;
 
-type InterpolationBag = {
-    config: WarpClientConfig;
-    chain: WarpChainName;
-    chainInfo: WarpChainInfo;
-};
+declare const getEventNameFromWarp: (warp: Warp, alertName: string) => string | null;
 
-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";
-    DefaultChainPrefix: string;
-    SuperClientUrls: string[];
-    AvailableActionInputSources: WarpActionInputSource[];
-    AvailableActionInputTypes: WarpActionInputType[];
-    AvailableActionInputPositions: WarpActionInputPosition[];
-};
+declare const getWarpBrandLogoUrl: (brand: WarpBrand, preferences?: {
+    scheme: "light" | "dark";
+}) => string;
 
 interface CryptoProvider {
     getRandomBytes(size: number): Promise<Uint8Array>;
@@ -542,31 +623,69 @@ declare function testCryptoAvailability(): Promise<{
 }>;
 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 findWarpExecutableAction: (warp: Warp) => {
+declare const getWarpPrimaryAction: (warp: Warp) => {
     action: WarpAction;
-    actionIndex: WarpActionIndex;
+    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 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, identifier2: string) => boolean;
+declare const createWarpIdentifier: (chain: WarpChain, type: WarpIdentifierType, identifier: string) => string;
 declare const getWarpInfoFromIdentifier: (prefixedIdentifier: string) => {
-    chainPrefix: string;
-    type: WarpIdType;
+    chain: WarpChain;
+    type: WarpIdentifierType;
     identifier: string;
     identifierBase: string;
 } | null;
 declare const extractIdentifierInfoFromUrl: (url: string) => {
-    chainPrefix: string;
-    type: WarpIdType;
+    chain: WarpChain;
+    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.
@@ -575,7 +694,9 @@ declare const extractIdentifierInfoFromUrl: (url: string) => {
 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;
+declare const applyOutputToMessages: (warp: Warp, output: Record<string, any>, config: WarpClientConfig) => Record<string, string>;
+
+declare const getNextInfo: (config: WarpClientConfig, adapters: Adapter[], warp: Warp, actionIndex: number, output: WarpExecutionOutput) => WarpExecutionNextInfo | null;
 
 /**
  * Builds a nested payload object from a position string and field value.
@@ -598,19 +719,27 @@ declare function buildNestedPayload(position: string, fieldName: string, value:
  */
 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 const getProviderConfig: (config: WarpClientConfig, chain: WarpChain, env: WarpChainEnv, defaultProvider: string) => WarpProviderConfig;
 
-declare const extractCollectResults: (warp: Warp, response: any, actionIndex: number, inputs: ResolvedInput[], transformRunner?: TransformRunner | null) => Promise<{
-    values: any[];
-    results: WarpExecutionResults;
+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[];
+    };
+    output: WarpExecutionOutput;
 }>;
-declare const evaluateResultsCommon: (warp: Warp, baseResults: WarpExecutionResults, actionIndex: number, inputs: ResolvedInput[], 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;
+declare const evaluateOutputCommon: (warp: Warp, baseOutput: WarpExecutionOutput, actionIndex: number, inputs: ResolvedInput[], serializer: WarpSerializer, config: WarpClientConfig) => Promise<WarpExecutionOutput>;
+declare const parseOutputOutIndex: (outputPath: string) => number | null;
 
 /**
  * Signing utilities for creating and validating signed messages
@@ -664,30 +793,45 @@ declare function validateSignedMessage(expiresAt: string): boolean;
  */
 declare function parseSignedMessage(message: string): SignableMessage;
 
-declare const string: (value: string) => string;
-declare const u8: (value: number) => string;
-declare const u16: (value: number) => string;
-declare const u32: (value: number) => string;
-declare const u64: (value: bigint | number) => string;
-declare const biguint: (value: bigint | string | number) => string;
-declare const boolean: (value: boolean) => string;
-declare const address: (value: string) => string;
-declare const asset: (value: WarpChainAsset) => string;
-declare const hex: (value: string) => string;
+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: string): WarpBrandBuilder;
-    setDescription(description: string): WarpBrandBuilder;
-    setLogo(logo: string): WarpBrandBuilder;
+    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;
 }
 
@@ -697,15 +841,17 @@ declare class WarpBuilder implements BaseWarpBuilder {
     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: string): WarpBuilder;
-    setDescription(description: 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;
 }
 
@@ -736,28 +882,54 @@ declare class WarpCache {
 }
 
 type ExecutionHandlers = {
-    onExecuted?: (result: WarpExecution) => void;
+    onExecuted?: (result: WarpActionExecutionResult) => void | Promise<void>;
     onError?: (params: {
         message: string;
     }) => void;
     onSignRequest?: (params: {
         message: string;
         chain: WarpChainInfo;
-    }) => Promise<string>;
+    }) => 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;
-    private serializer;
     constructor(config: WarpClientConfig, adapters: Adapter[], handlers?: ExecutionHandlers | undefined);
-    execute(warp: Warp, inputs: string[], env?: Record<string, any>): Promise<{
+    execute(warp: Warp, inputs: string[], meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<{
+        txs: WarpAdapterGenericTransaction[];
+        chain: WarpChainInfo | null;
+        immediateExecutions: WarpActionExecutionResult[];
+    }>;
+    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;
     }>;
-    evaluateResults(warp: Warp, chain: WarpChain, tx: WarpAdapterGenericRemoteTransaction): Promise<void>;
+    evaluateOutput(warp: Warp, actions: WarpChainAction[]): Promise<void>;
     private executeCollect;
+    private doHttpRequest;
+    private buildCollectResult;
+    private callHandler;
 }
 
 declare class WarpFactory {
@@ -767,8 +939,13 @@ declare class WarpFactory {
     private serializer;
     private cache;
     constructor(config: WarpClientConfig, adapters: Adapter[]);
-    createExecutable(warp: Warp, actionIndex: number, inputs: string[], envs?: Record<string, any>): Promise<WarpExecutable>;
-    getChainInfoForAction(action: WarpAction, inputs?: string[]): Promise<WarpChainInfo>;
+    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>;
@@ -788,9 +965,9 @@ declare class WarpLinkBuilder {
     private readonly adapters;
     constructor(config: WarpClientConfig, adapters: Adapter[]);
     isValid(url: string): boolean;
-    build(chain: WarpChain, type: WarpIdType, id: string): string;
+    build(chain: WarpChain, type: WarpIdentifierType, id: string): string;
     buildFromPrefixedIdentifier(identifier: string): string | null;
-    generateQrCode(chain: WarpChain, type: WarpIdType, id: string, size?: number, background?: string, color?: string, logoColor?: string): QRCodeStyling;
+    generateQrCode(chain: WarpChain, type: WarpIdentifierType, id: string, size?: number, background?: string, color?: string, logoColor?: string): QRCodeStyling;
 }
 
 type DetectionResult = {
@@ -803,7 +980,7 @@ type DetectionResult = {
 };
 type DetectionResultFromHtml = {
     match: boolean;
-    results: {
+    output: {
         url: string;
         warp: Warp;
     }[];
@@ -814,7 +991,7 @@ declare class WarpLinkDetecter {
     constructor(config: WarpClientConfig, adapters: Adapter[]);
     isValid(url: string): boolean;
     detectFromHtml(content: string): Promise<DetectionResultFromHtml>;
-    detect(url: string, cache?: WarpCacheConfig): Promise<DetectionResult>;
+    detect(urlOrId: string, cache?: WarpCacheConfig): Promise<DetectionResult>;
 }
 
 declare class WarpClient {
@@ -826,59 +1003,70 @@ declare class WarpClient {
     addAdapter(adapter: Adapter): WarpClient;
     createExecutor(handlers?: ExecutionHandlers): WarpExecutor;
     detectWarp(urlOrId: string, cache?: WarpCacheConfig): Promise<DetectionResult>;
-    executeWarp(warpOrIdentifierOrUrl: string | Warp, inputs: string[], handlers?: ExecutionHandlers, options?: {
+    executeWarp(warpOrIdentifierOrUrl: string | Warp, inputs: string[], handlers?: ExecutionHandlers, params?: {
         cache?: WarpCacheConfig;
+        queries?: Record<string, any>;
     }): Promise<{
-        tx: WarpAdapterGenericTransaction | null;
+        txs: WarpAdapterGenericTransaction[];
         chain: WarpChainInfo | null;
-        evaluateResults: (remoteTx: WarpAdapterGenericRemoteTransaction) => Promise<void>;
+        immediateExecutions: WarpActionExecutionResult[];
+        evaluateOutput: (remoteTxs: WarpAdapterGenericRemoteTransaction[]) => Promise<void>;
     }>;
-    createInscriptionTransaction(chain: WarpChain, warp: Warp): WarpAdapterGenericTransaction;
+    createInscriptionTransaction(chain: WarpChain, warp: Warp): Promise<WarpAdapterGenericTransaction>;
     createFromTransaction(chain: WarpChain, tx: WarpAdapterGenericRemoteTransaction, validate?: boolean): Promise<Warp>;
     createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<Warp | null>;
-    signMessage(chain: WarpChain, message: string, privateKey: string): Promise<string>;
+    signMessage(chain: WarpChain, message: string): Promise<string>;
+    getActions(chain: WarpChain, ids: string[], awaitCompleted?: boolean): Promise<WarpChainAction[]>;
     getExplorer(chain: WarpChain): AdapterWarpExplorer;
-    getResults(chain: WarpChain): AdapterWarpResults;
+    getOutput(chain: WarpChain): AdapterWarpOutput;
     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, envs?: Record<string, any>): Promise<Warp>;
+    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, envs?: Record<string, any>): Warp;
+    applyVars(config: WarpClientConfig, warp: Warp, meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Warp;
     private applyRootGlobals;
     private applyActionGlobals;
+    applyInputs(text: string, resolvedInputs: ResolvedInput[], serializer: WarpSerializer): 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 WarpSerializer {
-    private typeRegistry;
-    setTypeRegistry(typeRegistry: WarpTypeRegistry): void;
-    nativeToString(type: WarpActionInputType, value: WarpNativeValue): string;
-    stringToNative(value: string): [WarpActionInputType, WarpNativeValue];
-}
-
-declare class WarpTypeRegistryImpl implements WarpTypeRegistry {
+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[];
 }
 
@@ -891,10 +1079,11 @@ 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 AdapterWarpAbiBuilder, type AdapterWarpBrandBuilder, type AdapterWarpBuilder, type AdapterWarpDataLoader, type AdapterWarpExecutor, type AdapterWarpExplorer, type AdapterWarpRegistry, type AdapterWarpResults, type AdapterWarpSerializer, type BaseWarpActionInputType, type BaseWarpBuilder, BrowserCryptoProvider, CacheTtl, type ClientIndexConfig, type ClientTransformConfig, 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 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 WarpExecution, type WarpExecutionMessages, type WarpExecutionNextInfo, type WarpExecutionResults, WarpExecutor, type WarpExplorerName, WarpFactory, type WarpIdType, WarpIndex, WarpInputTypes, WarpInterpolator, 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, WarpSerializer, type WarpTransferAction, type WarpTrustStatus, type WarpTypeHandler, type WarpTypeRegistry, WarpTypeRegistryImpl, type WarpUserWallets, WarpValidator, type WarpVarPlaceholder, address, applyResultsToMessages, asset, biguint, boolean, buildNestedPayload, bytesToBase64, bytesToHex, createAuthHeaders, createAuthMessage, createCryptoProvider, createHttpAuthHeaders, createSignableMessage, evaluateResultsCommon, extractCollectResults, extractIdentifierInfoFromUrl, findWarpAdapterByPrefix, findWarpAdapterForChain, findWarpExecutableAction, getCryptoProvider, getLatestProtocolIdentifier, getNextInfo, getProviderConfig, getProviderUrl, getRandomBytes, getRandomHex, getWarpActionByIndex, getWarpInfoFromIdentifier, hasInputPrefix, hex, mergeNestedPayload, parseResultsOutIndex, parseSignedMessage, replacePlaceholders, setCryptoProvider, shiftBigintBy, splitInput, string, testCryptoAvailability, toPreviewText, u16, u32, u64, u8, validateSignedMessage };
+export { type Adapter, type AdapterFactory, 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 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 Warp, type WarpAbi, type WarpAbiContents, type WarpAction, type WarpActionExecutionResult, type WarpActionExecutionStatus, type WarpActionIndex, type WarpActionInput, type WarpActionInputModifier, type WarpActionInputPosition, 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 WarpChain, type WarpChainAccount, type WarpChainAction, type WarpChainActionStatus, type WarpChainAsset, type WarpChainAssetValue, type WarpChainEnv, type WarpChainInfo, 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 WarpMessageName, type WarpMeta, type WarpNativeValue, type WarpOutputName, 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 WarpTransferAction, type WarpTrustStatus, type WarpTypeHandler, WarpTypeRegistry, type WarpUserWallets, WarpValidator, type WarpVarPlaceholder, type WarpWalletDetails, address, applyOutputToMessages, asset, biguint, bool, buildNestedPayload, bytesToBase64, bytesToHex, cleanWarpIdentifier, createAuthHeaders, createAuthMessage, createCryptoProvider, createHttpAuthHeaders, createSignableMessage, createWarpI18nText, createWarpIdentifier, evaluateOutputCommon, extractCollectOutput, extractIdentifierInfoFromUrl, extractQueryStringFromIdentifier, extractQueryStringFromUrl, extractWarpSecrets, findWarpAdapterForChain, getCryptoProvider, getEventNameFromWarp, getLatestProtocolIdentifier, getNextInfo, getProviderConfig, getRandomBytes, getRandomHex, getWarpActionByIndex, getWarpBrandLogoUrl, getWarpInfoFromIdentifier, getWarpPrimaryAction, getWarpWalletAddress, getWarpWalletAddressFromConfig, getWarpWalletMnemonic, getWarpWalletMnemonicFromConfig, getWarpWalletPrivateKey, getWarpWalletPrivateKeyFromConfig, hasInputPrefix, hex, isEqualWarpIdentifier, isWarpActionAutoExecute, isWarpI18nText, mergeNestedPayload, option, parseOutputOutIndex, parseSignedMessage, replacePlaceholders, resolveWarpText, safeWindow, setCryptoProvider, shiftBigintBy, splitInput, string, struct, testCryptoAvailability, toPreviewText, tuple, uint16, uint32, uint64, uint8, validateSignedMessage, vector };