@vleap/warps 3.0.0-alpha.32 → 3.0.0-alpha.34

package/dist/chunk-3SAEGOMQ.mjs

@@ -0,0 +1 @@
+var d=(a=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(a,{get:(b,c)=>(typeof require<"u"?require:b)[c]}):a)(function(a){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+a+'" is not supported')});export{d as a};

package/dist/index.d.mts

@@ -1,62 +1,624 @@
-import { WarpInitConfig, WarpBrand, WarpAbi, WarpExecution, Warp, WarpAdapterGenericTransaction, WarpChainInfo, WarpAdapterGenericRemoteTransaction, WarpExecutable, WarpAction, ResolvedInput } from '@vleap/warps-core';
-export * from '@vleap/warps-core';
-import { Transaction, TransactionOnNetwork } from '@multiversx/sdk-core';
-import { WarpBrandUrls, WarpBrandColors, WarpBrandCta } from '@vleap/warps-core/src/types';
+import QRCodeStyling from 'qr-code-styling';
 
-declare class BrandBuilder {
+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;
+    ChainInfo: (env: WarpChainEnv, chain: WarpChain) => string;
+    ChainInfos: (env: WarpChainEnv) => string;
+};
+type CacheType = 'memory' | 'localStorage';
+declare class WarpCache {
+    private strategy;
+    constructor(type?: CacheType);
+    private selectStrategy;
+    set<T>(key: string, value: T, ttl: number): void;
+    get<T>(key: string): T | null;
+    forget(key: string): void;
+    clear(): void;
+}
+
+type WarpChainEnv = 'mainnet' | 'testnet' | 'devnet';
+type ProtocolName = 'warp' | 'brand' | 'abi';
+
+type WarpChain = string;
+type WarpInitConfig = {
+    env: WarpChainEnv;
+    repository: Adapter;
+    adapters: Adapter[];
+    preferredChain?: WarpChain;
+    clientUrl?: string;
+    currentUrl?: string;
+    vars?: Record<string, string | number>;
+    user?: {
+        wallet?: string;
+    };
+    schema?: {
+        warp?: string;
+        brand?: string;
+    };
+    cache?: {
+        ttl?: number;
+        type?: CacheType;
+    };
+    registry?: {
+        contract?: string;
+    };
+    index?: {
+        url?: string;
+        apiKey?: string;
+        searchParamName?: string;
+    };
+};
+type WarpCacheConfig = {
+    ttl?: number;
+};
+type WarpChainInfo = {
+    name: WarpChain;
+    displayName: string;
+    chainId: string;
+    blockTime: number;
+    addressHrp: string;
+    apiUrl: string;
+    explorerUrl: string;
+    nativeToken: string;
+};
+type WarpIdType = 'hash' | 'alias';
+type WarpVarPlaceholder = string;
+type WarpResultName = string;
+type WarpResulutionPath = string;
+type WarpMessageName = string;
+type Warp = {
+    protocol: string;
+    name: string;
+    title: string;
+    description: string | null;
+    bot?: string;
+    preview?: string;
+    vars?: Record<WarpVarPlaceholder, string>;
+    actions: WarpAction[];
+    next?: string;
+    results?: Record<WarpResultName, WarpResulutionPath>;
+    messages?: Record<WarpMessageName, string>;
+    meta?: WarpMeta;
+};
+type WarpMeta = {
+    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;
+    chain?: WarpChain;
+    label: string;
+    description?: string | null;
+    address?: string;
+    data?: string;
+    value?: string;
+    transfers?: string[];
+    inputs?: WarpActionInput[];
+    next?: string;
+};
+type WarpContractAction = {
+    type: WarpActionType;
+    chain?: WarpChain;
+    label: string;
+    description?: string | null;
+    address?: string;
+    func?: string | null;
+    args?: string[];
+    value?: string;
+    gasLimit: number;
+    transfers?: string[];
+    abi?: string;
+    inputs?: WarpActionInput[];
+    next?: string;
+};
+type WarpQueryAction = {
+    type: WarpActionType;
+    chain?: WarpChain;
+    label: string;
+    description?: string | null;
+    address?: string;
+    func?: string;
+    args?: string[];
+    abi?: string;
+    inputs?: WarpActionInput[];
+    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>;
+    };
+    inputs?: WarpActionInput[];
+    next?: string;
+};
+type WarpLinkAction = {
+    type: WarpActionType;
+    chain?: WarpChain;
+    label: string;
+    description?: string | null;
+    url: string;
+    inputs?: WarpActionInput[];
+};
+type WarpActionInputSource = 'field' | 'query' | 'user:wallet';
+type BaseWarpActionInputType = 'string' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'biguint' | 'bool' | 'address' | 'hex' | string;
+type WarpActionInputType = string;
+type WarpNativeValue = string | number | bigint | boolean | null | WarpNativeValue[];
+type WarpActionInputPosition = 'receiver' | 'value' | 'transfer' | `arg:${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}` | 'data' | 'chain';
+type WarpActionInputModifier = 'scale';
+type WarpActionInput = {
+    name: string;
+    as?: string;
+    description?: string | null;
+    bot?: string;
+    type: WarpActionInputType;
+    position?: WarpActionInputPosition;
+    source: WarpActionInputSource;
+    required?: boolean;
+    min?: number | WarpVarPlaceholder;
+    max?: number | WarpVarPlaceholder;
+    pattern?: string;
+    patternDescription?: string;
+    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: string[];
+    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 WarpBrand = {
+    protocol: string;
+    name: string;
+    description: string;
+    logo: string;
+    urls?: WarpBrandUrls;
+    colors?: WarpBrandColors;
+    cta?: WarpBrandCta;
+    meta?: WarpBrandMeta;
+};
+type WarpBrandUrls = {
+    web?: string;
+};
+type WarpBrandColors = {
+    primary?: string;
+    secondary?: string;
+};
+type WarpBrandCta = {
+    title: string;
+    description: string;
+    label: string;
+    url: string;
+};
+type WarpBrandMeta = {
+    hash: string;
+    creator: string;
+    createdAt: string;
+};
+
+type InterpolationBag = {
+    config: WarpInitConfig;
+    chain: WarpChainInfo;
+};
+
+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 WarpExecution = {
+    success: boolean;
+    warp: Warp;
+    action: number;
+    user: string | null;
+    txHash: string | null;
+    next: WarpExecutionNextInfo | null;
+    values: any[];
+    results: WarpExecutionResults;
+    messages: WarpExecutionMessages;
+};
+type WarpExecutionNextInfo = {
+    identifier: string | null;
+    url: string;
+}[];
+type WarpExecutionResults = Record<WarpResultName, any | null>;
+type WarpExecutionMessages = Record<WarpMessageName, string | null>;
+
+type WarpSearchResult = {
+    hits: WarpSearchHit[];
+};
+type WarpSearchHit = {
+    hash: string;
+    alias: string;
+    name: string;
+    title: string;
+    description: string;
+    preview: string;
+    status: string;
+    category: string;
+    featured: boolean;
+};
+
+type Adapter = {
+    chain: WarpChain;
+    builder: AdapterWarpBuilderConstructor;
+    executor: AdapterWarpExecutorConstructor;
+    results: AdapterWarpResultsConstructor;
+    serializer: AdapterWarpSerializerConstructor;
+    registry: AdapterWarpRegistryConstructor;
+};
+type WarpAdapterGenericTransaction = any;
+type WarpAdapterGenericRemoteTransaction = any;
+type WarpAdapterGenericValue = any;
+type WarpAdapterGenericType = any;
+interface AdapterWarpBuilderConstructor {
+    new (config: WarpInitConfig): AdapterWarpBuilder;
+}
+interface AdapterWarpBuilder {
+    createInscriptionTransaction(warp: Warp): WarpAdapterGenericTransaction;
+    createFromTransaction(tx: WarpAdapterGenericTransaction, validate?: boolean): Promise<Warp>;
+    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<Warp | null>;
+}
+interface AdapterWarpExecutorConstructor {
+    new (config: WarpInitConfig): AdapterWarpExecutor;
+}
+interface AdapterWarpExecutor {
+    createTransaction(executable: WarpExecutable): Promise<WarpAdapterGenericTransaction>;
+    preprocessInput(chain: WarpChainInfo, input: string, type: WarpActionInputType, value: string): Promise<string>;
+}
+interface AdapterWarpResultsConstructor {
+    new (config: WarpInitConfig): AdapterWarpResults;
+}
+interface AdapterWarpResults {
+    getTransactionExecutionResults(warp: Warp, actionIndex: WarpActionIndex, tx: WarpAdapterGenericRemoteTransaction): Promise<WarpExecution>;
+}
+interface AdapterWarpSerializerConstructor {
+    new (): AdapterWarpSerializer;
+}
+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 AdapterWarpRegistryConstructor {
+    new (config: WarpInitConfig): AdapterWarpRegistry;
+}
+interface AdapterWarpRegistry {
+    createWarpRegisterTransaction(txHash: string, alias?: string | null, brand?: string | null): WarpAdapterGenericTransaction;
+    createWarpUnregisterTransaction(txHash: string): WarpAdapterGenericTransaction;
+    createWarpUpgradeTransaction(alias: string, txHash: string): WarpAdapterGenericTransaction;
+    createWarpAliasSetTransaction(txHash: string, alias: string): WarpAdapterGenericTransaction;
+    createWarpVerifyTransaction(txHash: string): WarpAdapterGenericTransaction;
+    createWarpTransferOwnershipTransaction(txHash: string, newOwner: string): WarpAdapterGenericTransaction;
+    createBrandRegisterTransaction(txHash: string): WarpAdapterGenericTransaction;
+    createWarpBrandingTransaction(warpHash: string, brandHash: string): 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[]>;
+    getChainInfos(cache?: WarpCacheConfig): Promise<WarpChainInfo[]>;
+    getChainInfo(chain: WarpChain, cache?: WarpCacheConfig): Promise<WarpChainInfo | null>;
+    setChain(info: WarpChainInfo): Promise<WarpAdapterGenericTransaction>;
+    removeChain(chain: WarpChain): Promise<WarpAdapterGenericTransaction>;
+    fetchBrand(hash: string, cache?: WarpCacheConfig): Promise<WarpBrand | 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";
+    SuperClientUrls: string[];
+    MainChain: {
+        Name: string;
+        DisplayName: string;
+        ApiUrl: (env: WarpChainEnv) => "https://devnet-api.multiversx.com" | "https://testnet-api.multiversx.com" | "https://api.multiversx.com";
+        ExplorerUrl: (env: WarpChainEnv) => "https://devnet-explorer.multiversx.com" | "https://testnet-explorer.multiversx.com" | "https://explorer.multiversx.com";
+        BlockTime: (env: WarpChainEnv) => number;
+        AddressHrp: string;
+        ChainId: (env: WarpChainEnv) => "D" | "T" | "1";
+        NativeToken: string;
+    };
+    Registry: {
+        Contract: (env: WarpChainEnv) => "erd1qqqqqqqqqqqqqpgqje2f99vr6r7sk54thg03c9suzcvwr4nfl3tsfkdl36" | "####" | "erd1qqqqqqqqqqqqqpgq3mrpj3u6q7tejv6d7eqhnyd27n9v5c5tl3ts08mffe";
+    };
+    AvailableActionInputSources: WarpActionInputSource[];
+    AvailableActionInputTypes: WarpActionInputType[];
+    AvailableActionInputPositions: WarpActionInputPosition[];
+};
+
+declare const WarpConstants: {
+    HttpProtocolPrefix: string;
+    IdentifierParamName: string;
+    IdentifierParamSeparator: string;
+    IdentifierType: {
+        Alias: WarpIdType;
+        Hash: WarpIdType;
+    };
+    Source: {
+        UserWallet: string;
+    };
+    Globals: {
+        UserWallet: {
+            Placeholder: string;
+            Accessor: (bag: InterpolationBag) => string | undefined;
+        };
+        ChainApiUrl: {
+            Placeholder: string;
+            Accessor: (bag: InterpolationBag) => string;
+        };
+        ChainExplorerUrl: {
+            Placeholder: string;
+            Accessor: (bag: InterpolationBag) => string;
+        };
+    };
+    Vars: {
+        Query: string;
+        Env: string;
+    };
+    ArgParamsSeparator: string;
+    ArgCompositeSeparator: string;
+    Transform: {
+        Prefix: string;
+    };
+};
+declare const WarpInputTypes: {
+    Option: string;
+    Optional: string;
+    List: string;
+    Variadic: string;
+    Composite: string;
+    String: string;
+    U8: string;
+    U16: string;
+    U32: string;
+    U64: string;
+    Biguint: string;
+    Boolean: string;
+    Address: string;
+    Hex: string;
+};
+
+declare const getMainChainInfo: (config: WarpInitConfig) => WarpChainInfo;
+declare const getChainExplorerUrl: (chain: WarpChainInfo, path?: string) => string;
+declare const getLatestProtocolIdentifier: (name: ProtocolName) => string;
+declare const getWarpActionByIndex: (warp: Warp, index: number) => WarpAction;
+declare const toTypedChainInfo: (chainInfo: any) => WarpChainInfo;
+declare const shiftBigintBy: (value: bigint | string, 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 getWarpInfoFromIdentifier: (prefixedIdentifier: string) => {
+    type: WarpIdType;
+    identifier: string;
+    identifierBase: string;
+} | null;
+declare const extractIdentifierInfoFromUrl: (url: string) => {
+    type: WarpIdType;
+    identifier: string;
+    identifierBase: string;
+} | null;
+
+declare const getNextInfo: (config: WarpInitConfig, warp: Warp, actionIndex: number, results: WarpExecutionResults) => WarpExecutionNextInfo | null;
+
+declare const extractCollectResults: (warp: Warp, response: any, actionIndex: number, inputs: ResolvedInput[]) => Promise<{
+    values: any[];
+    results: WarpExecutionResults;
+}>;
+declare const evaluateResultsCommon: (warp: Warp, baseResults: WarpExecutionResults, actionIndex: number, inputs: ResolvedInput[]) => 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;
+
+type KnownToken = {
+    id: string;
+    name: string;
+    decimals: number;
+};
+declare const KnownTokens: KnownToken[];
+declare const findKnownTokenById: (id: string) => KnownToken | null;
+
+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) => string;
+declare const biguint: (value: bigint | string | number) => string;
+declare const boolean: (value: boolean) => string;
+declare const address: (value: string) => string;
+declare const hex: (value: string) => string;
+
+declare class WarpBrandBuilder {
     private config;
     private pendingBrand;
     constructor(config: WarpInitConfig);
-    createInscriptionTransaction(brand: WarpBrand): Transaction;
     createFromRaw(encoded: string, validateSchema?: boolean): Promise<WarpBrand>;
-    createFromTransaction(tx: TransactionOnNetwork, validateSchema?: boolean): Promise<WarpBrand>;
-    createFromTransactionHash(hash: string): Promise<WarpBrand | null>;
-    setName(name: string): BrandBuilder;
-    setDescription(description: string): BrandBuilder;
-    setLogo(logo: string): BrandBuilder;
-    setUrls(urls: WarpBrandUrls): BrandBuilder;
-    setColors(colors: WarpBrandColors): BrandBuilder;
-    setCta(cta: WarpBrandCta): BrandBuilder;
+    setName(name: string): WarpBrandBuilder;
+    setDescription(description: string): WarpBrandBuilder;
+    setLogo(logo: string): WarpBrandBuilder;
+    setUrls(urls: WarpBrandUrls): WarpBrandBuilder;
+    setColors(colors: WarpBrandColors): WarpBrandBuilder;
+    setCta(cta: WarpBrandCta): WarpBrandBuilder;
     build(): Promise<WarpBrand>;
     private ensure;
     private ensureValidSchema;
 }
 
-declare class WarpAbiBuilder {
-    createFromRaw(encoded: string): Promise<WarpAbi>;
+declare class WarpBuilder {
+    private config;
+    private pendingWarp;
+    constructor(config: WarpInitConfig);
+    createFromRaw(encoded: string, validate?: boolean): Promise<Warp>;
+    setName(name: string): WarpBuilder;
+    setTitle(title: string): WarpBuilder;
+    setDescription(description: string): 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 validate;
 }
 
-type ExecutionHandlers = {
-    onExecuted?: (result: WarpExecution) => void;
-};
-declare class WarpExecutor {
+declare class WarpIndex {
     private config;
-    private factory;
-    private handlers;
-    constructor(config: WarpInitConfig, handlers: ExecutionHandlers);
-    execute(warp: Warp, inputs: string[]): Promise<[WarpAdapterGenericTransaction | null, WarpChainInfo | null]>;
-    evaluateResults(warp: Warp, chain: WarpChainInfo, tx: WarpAdapterGenericRemoteTransaction): Promise<void>;
-    private determineActionIndex;
-    private executeCollect;
+    constructor(config: WarpInitConfig);
+    search(query: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<WarpSearchHit[]>;
 }
 
-declare class WarpFactory {
+declare class WarpInterpolator {
     private config;
-    private url;
-    private serializer;
-    private cache;
+    private registry;
     constructor(config: WarpInitConfig);
-    createExecutable(warp: Warp, actionIndex: number, inputs: string[]): Promise<WarpExecutable>;
-    getResolvedInputs(chain: WarpChainInfo, action: WarpAction, inputArgs: string[]): Promise<ResolvedInput[]>;
-    getModifiedInputs(inputs: ResolvedInput[]): ResolvedInput[];
-    preprocessInput(chain: WarpChainInfo, input: string): Promise<string>;
-    private getPreparedArgs;
+    apply(config: WarpInitConfig, warp: Warp): Promise<Warp>;
+    applyGlobals(config: WarpInitConfig, warp: Warp): Promise<Warp>;
+    applyVars(config: WarpInitConfig, warp: Warp): Warp;
+    private applyRootGlobals;
+    private applyActionGlobals;
 }
 
-declare class WarpUtils {
-    static getChainInfoForAction(config: WarpInitConfig, action: WarpAction, inputs?: string[]): Promise<WarpChainInfo>;
-    private static tryGetChainFromInputs;
-    private static getDefaultChainInfo;
+declare class WarpLinkBuilder {
+    private config;
+    constructor(config: WarpInitConfig);
+    isValid(url: string): boolean;
+    build(type: WarpIdType, id: string): string;
+    buildFromPrefixedIdentifier(identifier: string): string;
+    generateQrCode(type: WarpIdType, id: string, size?: number, background?: string, color?: string, logoColor?: string): QRCodeStyling;
+}
+
+type DetectionResult = {
+    match: boolean;
+    url: string;
+    warp: Warp | null;
+    registryInfo: WarpRegistryInfo | null;
+    brand: WarpBrand | null;
+};
+type DetectionResultFromHtml = {
+    match: boolean;
+    results: {
+        url: string;
+        warp: Warp;
+    }[];
+};
+declare class WarpLinkDetecter {
+    private config;
+    private registry;
+    private builder;
+    constructor(config: WarpInitConfig);
+    isValid(url: string): boolean;
+    detectFromHtml(content: string): Promise<DetectionResultFromHtml>;
+    detect(url: string, cache?: WarpCacheConfig): Promise<DetectionResult>;
+}
+
+declare class WarpLogger {
+    private static isTestEnv;
+    static info(...args: any[]): void;
+    static warn(...args: any[]): void;
+    static error(...args: any[]): void;
+}
+
+declare class WarpSerializer {
+    nativeToString(type: WarpActionInputType, value: WarpNativeValue): string;
+    stringToNative(value: string): [WarpActionInputType, WarpNativeValue];
+}
+
+type ValidationResult = {
+    valid: boolean;
+    errors: ValidationError[];
+};
+type ValidationError = string;
+declare class WarpValidator {
+    private config;
+    constructor(config: WarpInitConfig);
+    validate(warp: Warp): Promise<ValidationResult>;
+    private validateMaxOneValuePosition;
+    private validateVariableNamesAndResultNamesUppercase;
+    private validateAbiIsSetIfApplicable;
+    private validateSchema;
 }
 
-export { BrandBuilder, WarpAbiBuilder, WarpExecutor, WarpFactory, WarpUtils };
+export { type Adapter, type AdapterWarpBuilder, type AdapterWarpBuilderConstructor, type AdapterWarpExecutor, type AdapterWarpExecutorConstructor, type AdapterWarpRegistry, type AdapterWarpRegistryConstructor, type AdapterWarpResults, type AdapterWarpResultsConstructor, type AdapterWarpSerializer, type AdapterWarpSerializerConstructor, type BaseWarpActionInputType, CacheTtl, type CacheType, type InterpolationBag, type KnownToken, KnownTokens, type ProtocolName, type ResolvedInput, 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 WarpBrandMeta, type WarpBrandUrls, WarpBuilder, WarpCache, type WarpCacheConfig, WarpCacheKey, type WarpChain, type WarpChainEnv, type WarpChainInfo, type WarpCollectAction, WarpConfig, WarpConstants, type WarpContract, type WarpContractAction, type WarpContractVerification, type WarpExecutable, type WarpExecution, type WarpExecutionMessages, type WarpExecutionNextInfo, type WarpExecutionResults, type WarpIdType, WarpIndex, type WarpInitConfig, WarpInputTypes, WarpInterpolator, type WarpLinkAction, WarpLinkBuilder, WarpLinkDetecter, WarpLogger, type WarpMessageName, type WarpMeta, type WarpNativeValue, WarpProtocolVersions, type WarpQueryAction, type WarpRegistryConfigInfo, type WarpRegistryInfo, type WarpResultName, type WarpResulutionPath, type WarpSearchHit, type WarpSearchResult, WarpSerializer, type WarpTransferAction, type WarpTrustStatus, WarpValidator, type WarpVarPlaceholder, address, applyResultsToMessages, biguint, boolean, evaluateResultsCommon, extractCollectResults, extractIdentifierInfoFromUrl, findKnownTokenById, getChainExplorerUrl, getLatestProtocolIdentifier, getMainChainInfo, getNextInfo, getWarpActionByIndex, getWarpInfoFromIdentifier, hex, parseResultsOutIndex, replacePlaceholders, shiftBigintBy, string, toPreviewText, toTypedChainInfo, u16, u32, u64, u8 };