import * as _xmtp_node_sdk from '@xmtp/node-sdk';
import { Client, EncryptedAttachment, RemoteAttachment, Attachment, Conversation, Dm, Group, DecodedMessage, Reply, Reaction, ReadReceipt, TransactionReference, WalletSendCalls, Actions, GroupUpdated, Intent, LeaveRequest, MultiRemoteAttachment, EnrichedReply, ClientOptions, NetworkOptions, StreamOptions, HexString, CreateDmOptions, CreateGroupOptions, LogLevel, Action, Identifier, Signer } from '@xmtp/node-sdk';
export * from '@xmtp/node-sdk';
import EventEmitter from 'node:events';
import { ContentCodec } from '@xmtp/content-type-primitives';
import { Hex, PrivateKeyAccount, WalletClient, Chain, Transport } from 'viem';

declare class ClientContext<ContentTypes = unknown> {
    #private;
    constructor({ client }: {
        client: Client<ContentTypes>;
    });
    getClientAddress(): string | undefined;
    get client(): Client<ContentTypes>;
}

type AttachmentUploadCallback = (attachment: EncryptedAttachment) => Promise<string>;
/**
 * Downloads and decrypts a remote attachment.
 *
 * @param remoteAttachment - The remote attachment metadata containing the downloadd URL and encryption keys
 * @param agent - The agent instance used to lookup the necessary decoding codec
 * @returns A promise that resolves with the decrypted attachment
 */
declare function downloadRemoteAttachment(remoteAttachment: RemoteAttachment): Promise<Attachment>;
/**
 * Creates a remote attachment object from an encrypted attachment and file URL.
 *
 * @param encryptedAttachment - The encrypted attachment containing encryption keys and metadata
 * @param fileUrl - The URL where the encrypted attachment can be downloaded
 * @returns A remote attachment object with all necessary metadata for retrieval and decryption
 */
declare function createRemoteAttachment(encryptedAttachment: EncryptedAttachment, fileUrl: string): RemoteAttachment;
/**
 * Creates a remote attachment from a file by encrypting it and uploading it to a remote storage.
 * This is a convenience function that combines file processing, encryption, uploading, and
 * remote attachment creation into a single operation.
 *
 * @param unencryptedFile - The unencrypted file to process and upload
 * @param uploadCallback - A callback function that receives the encrypted attachment and returns the URL where it was uploaded
 * @returns A promise that resolves with a remote attachment containing all necessary metadata for retrieval and decryption
 */
declare function createRemoteAttachmentFromFile(unencryptedFile: File, uploadCallback: AttachmentUploadCallback): Promise<RemoteAttachment>;

declare class ConversationContext<ContentTypes = unknown, ConversationType extends Conversation = Conversation> extends ClientContext<ContentTypes> {
    #private;
    constructor({ conversation, client, }: {
        conversation: ConversationType;
        client: Client<ContentTypes>;
    });
    isDm(): this is ConversationContext<ContentTypes, Dm<ContentTypes>>;
    isGroup(): this is ConversationContext<ContentTypes, Group<ContentTypes>>;
    sendRemoteAttachment(unencryptedFile: File, uploadCallback: AttachmentUploadCallback): Promise<void>;
    get conversation(): ConversationType;
    get isAllowed(): boolean;
    get isDenied(): boolean;
    get isUnknown(): boolean;
}

type DecodedMessageWithContent<ContentTypes = unknown> = DecodedMessage<ContentTypes> & {
    content: ContentTypes;
};
declare const filter: {
    fromSelf: <ContentTypes>(message: DecodedMessage<ContentTypes>, client: Client<ContentTypes>) => boolean;
    hasContent: <ContentTypes>(message: DecodedMessage<ContentTypes>) => message is DecodedMessageWithContent<ContentTypes>;
    isDM: (conversation: Conversation) => conversation is Dm;
    isGroup: (conversation: Conversation) => conversation is Group;
    isGroupAdmin: (conversation: Conversation, message: DecodedMessage) => boolean;
    isGroupSuperAdmin: (conversation: Conversation, message: DecodedMessage) => boolean;
    usesCodec: <T extends ContentCodec>(message: DecodedMessage, codecClass: new () => T) => message is DecodedMessageWithContent<ReturnType<T["decode"]>>;
};
declare const f: {
    fromSelf: <ContentTypes>(message: DecodedMessage<ContentTypes>, client: Client<ContentTypes>) => boolean;
    hasContent: <ContentTypes>(message: DecodedMessage<ContentTypes>) => message is DecodedMessageWithContent<ContentTypes>;
    isDM: (conversation: Conversation) => conversation is Dm;
    isGroup: (conversation: Conversation) => conversation is Group;
    isGroupAdmin: (conversation: Conversation, message: DecodedMessage) => boolean;
    isGroupSuperAdmin: (conversation: Conversation, message: DecodedMessage) => boolean;
    usesCodec: <T extends ContentCodec>(message: DecodedMessage, codecClass: new () => T) => message is DecodedMessageWithContent<ReturnType<T["decode"]>>;
};

type MessageContextParams<MessageContentType = unknown, ContentTypes = unknown> = Omit<AgentBaseContext<ContentTypes>, "message"> & {
    message: DecodedMessageWithContent<MessageContentType>;
};
declare class MessageContext<MessageContentType = unknown, ContentTypes = unknown> extends ConversationContext<ContentTypes> {
    #private;
    constructor({ message, conversation, client, }: MessageContextParams<MessageContentType, ContentTypes>);
    usesCodec<T extends ContentCodec>(codecClass: new () => T): this is MessageContext<ReturnType<T["decode"]>>;
    isMarkdown(): this is MessageContext<string>;
    isText(): this is MessageContext<string>;
    isReply(): this is MessageContext<Reply>;
    isReaction(): this is MessageContext<Reaction>;
    isReadReceipt(): this is MessageContext<ReadReceipt>;
    isRemoteAttachment(): this is MessageContext<RemoteAttachment>;
    isTransactionReference(): this is MessageContext<TransactionReference>;
    isWalletSendCalls(): this is MessageContext<WalletSendCalls>;
    sendReaction(content: string, schema?: Reaction["schema"]): Promise<void>;
    sendMarkdownReply(markdown: string): Promise<void>;
    sendTextReply(text: string): Promise<void>;
    getSenderAddress(): Promise<string | undefined>;
    get message(): DecodedMessageWithContent<MessageContentType>;
}

type EventHandlerMap<ContentTypes> = {
    actions: [ctx: MessageContext<Actions, ContentTypes>];
    attachment: [ctx: MessageContext<RemoteAttachment, ContentTypes>];
    conversation: [ctx: ConversationContext<ContentTypes>];
    "group-update": [ctx: MessageContext<GroupUpdated, ContentTypes>];
    dm: [ctx: ConversationContext<ContentTypes, Dm<ContentTypes>>];
    group: [ctx: ConversationContext<ContentTypes, Group<ContentTypes>>];
    "inline-attachment": [ctx: MessageContext<Attachment, ContentTypes>];
    intent: [ctx: MessageContext<Intent, ContentTypes>];
    "leave-request": [ctx: MessageContext<LeaveRequest, ContentTypes>];
    markdown: [ctx: MessageContext<string, ContentTypes>];
    message: [ctx: MessageContext<unknown, ContentTypes>];
    "multi-attachment": [
        ctx: MessageContext<MultiRemoteAttachment, ContentTypes>
    ];
    reaction: [ctx: MessageContext<Reaction, ContentTypes>];
    "read-receipt": [ctx: MessageContext<ReadReceipt, ContentTypes>];
    reply: [ctx: MessageContext<EnrichedReply, ContentTypes>];
    start: [ctx: ClientContext<ContentTypes>];
    stop: [ctx: ClientContext<ContentTypes>];
    text: [ctx: MessageContext<string, ContentTypes>];
    "transaction-reference": [
        ctx: MessageContext<TransactionReference, ContentTypes>
    ];
    unhandledError: [error: Error];
    unknownMessage: [ctx: MessageContext<unknown, ContentTypes>];
    "wallet-send-calls": [ctx: MessageContext<WalletSendCalls, ContentTypes>];
};
type EthAddress = HexString;
type AgentBaseContext<ContentTypes = unknown> = {
    client: Client<ContentTypes>;
    conversation: Conversation;
    message: DecodedMessage;
};
type AgentErrorContext<ContentTypes = unknown> = Partial<AgentBaseContext<ContentTypes>> & {
    client: Client<ContentTypes>;
};
type AgentOptions<ContentTypes> = {
    client: Client<ContentTypes>;
};
type AgentMessageHandler<ContentTypes = unknown> = (ctx: MessageContext<ContentTypes>) => Promise<void> | void;
type AgentMiddleware<ContentTypes = unknown> = (ctx: MessageContext<unknown, ContentTypes>, next: () => Promise<void> | void) => Promise<void>;
type AgentErrorMiddleware<ContentTypes = unknown> = (error: unknown, ctx: AgentErrorContext<ContentTypes>, next: (err?: unknown) => Promise<void> | void) => Promise<void> | void;
type AgentCreateOptions<ContentCodecs extends ContentCodec[] = []> = Omit<ClientOptions & NetworkOptions, "codecs"> & {
    codecs?: ContentCodecs;
};
type AgentStreamingOptions = Omit<StreamOptions, "onValue" | "onError">;
type StreamAllMessagesOptions<ContentTypes> = Parameters<Client<ContentTypes>["conversations"]["streamAllMessages"]>[0];
type AgentErrorRegistrar<ContentTypes> = {
    use(...errorMiddleware: Array<AgentErrorMiddleware<ContentTypes> | AgentErrorMiddleware<ContentTypes>[]>): AgentErrorRegistrar<ContentTypes>;
};
declare class Agent<ContentTypes = unknown> extends EventEmitter<EventHandlerMap<ContentTypes>> {
    #private;
    constructor({ client }: AgentOptions<ContentTypes>);
    static create<ContentCodecs extends ContentCodec[] = []>(signer: Parameters<typeof Client.create>[0], options?: AgentCreateOptions<ContentCodecs>): Promise<Agent<_xmtp_node_sdk.ExtractCodecContentTypes<ContentCodecs>>>;
    static createFromEnv<ContentCodecs extends ContentCodec[] = []>(options?: AgentCreateOptions<ContentCodecs>): Promise<Agent<_xmtp_node_sdk.ExtractCodecContentTypes<ContentCodecs>>>;
    get libxmtpVersion(): string | undefined;
    use(...middleware: Array<AgentMiddleware<ContentTypes> | AgentMiddleware<ContentTypes>[]>): this;
    start(options?: AgentStreamingOptions): Promise<void>;
    get client(): Client<ContentTypes>;
    get errors(): AgentErrorRegistrar<ContentTypes>;
    stop(): Promise<void>;
    createDmWithAddress(address: EthAddress, options?: CreateDmOptions): Promise<Dm<ContentTypes>>;
    createGroupWithAddresses(addresses: EthAddress[], options?: CreateGroupOptions): Promise<Group<ContentTypes>>;
    addMembersWithAddresses<ContentTypes>(group: Group<ContentTypes>, addresses: EthAddress[]): Promise<void>;
    getConversationContext(conversationId: string): Promise<ConversationContext<ContentTypes, Dm<ContentTypes> | Group<ContentTypes>> | undefined>;
    get address(): string | undefined;
}

declare class AgentError extends Error {
    #private;
    constructor(code: number, message: string, cause?: unknown);
    get code(): number;
}
declare class AgentStreamingError extends AgentError {
}

declare const getValidLogLevels: () => LogLevel[];
declare const parseLogLevel: (rawLevel: string) => LogLevel | null;
declare const logDetails: <ContentTypes>(agent: Agent<ContentTypes>) => Promise<void>;
/**
 * Returns a URL to test your agent on https://xmtp.chat/ (for development purposes only).
 *
 * @param client - Your XMTP client
 * @returns The URL to test your agent with
 */
declare const getTestUrl: <ContentTypes>(client: Client<ContentTypes>) => string;
type InstallationInfo = {
    totalInstallations: number;
    installationId: string;
    mostRecentInstallationId: null | string;
    isMostRecent: boolean;
};
declare const getInstallationInfo: <ContentTypes>(client: Client<ContentTypes>) => Promise<InstallationInfo>;

/** Content type supported by the "CommandRouter" */
type SupportedType = string;
interface CommandRouterConfig {
    /** Command string to trigger help output (e.g., "/help") */
    helpCommand?: `/${string}`;
}
declare class CommandRouter<ContentTypes = unknown> {
    #private;
    constructor(config?: CommandRouterConfig);
    get commandList(): string[];
    command(command: string, handler: AgentMessageHandler<SupportedType>): this;
    command(command: string, description: string, handler: AgentMessageHandler<SupportedType>): this;
    default(handler: AgentMessageHandler<SupportedType>): this;
    handle(ctx: MessageContext<SupportedType>): Promise<boolean>;
    middleware(): AgentMiddleware<ContentTypes>;
}

interface HealthReport {
    cpuPercent: number;
    eventLoopDelayMs: number;
    heapMB: number;
    heapPercent: number;
    heapLimitMB: number;
    totalMB: number;
}
interface PerformanceMonitorConfig {
    /** Interval in ms between health reports (default: 60000). Set to 0 to disable. */
    healthReportInterval?: number;
    /** Threshold in ms for critical warning (default: 10000) */
    criticalThresholdInterval?: number;
    /** Called when a message takes longer than the critical threshold to process. Defaults to logging a warning. */
    onCriticalResponse?: (durationMs: number) => void;
    /** Called on each health report interval. Defaults to logging CPU and memory stats. */
    onHealthReport?: (report: HealthReport) => void;
    /** Called after every message with the processing duration in ms. */
    onResponse?: (durationMs: number) => void;
    /** Called when shutdown is invoked. Defaults to logging a message. */
    onShutdown?: () => void;
}
/**
 * Middleware that measures message processing time and logs periodic
 * CPU / memory health reports.
 *
 * Register it as the first middleware so the timer wraps all downstream
 * middleware and handlers, giving you the total processing time independent
 * of other logic.
 */
declare class PerformanceMonitor<ContentTypes = unknown> {
    #private;
    constructor(config?: PerformanceMonitorConfig);
    shutdown(): void;
    middleware(): AgentMiddleware<ContentTypes>;
}

type ActionWizardCompleteHandler<ContentTypes> = (answers: Record<string, string>, ctx: MessageContext<unknown, ContentTypes>) => Promise<void> | void;
type ActionWizardCancelHandler<ContentTypes> = (ctx: MessageContext<unknown, ContentTypes>) => Promise<void> | void;
type ActionWizardCancelOptions = {
    /** Custom label for the cancel button (default: "Cancel") */
    label?: string;
};
type ActionWizardOptions = {
    /**
     * When true, the wizard sends all steps via DM to the user.
     * Recommended when the user is expected to enter sensitive information
     * (e.g. API keys, passwords) to keep it out of group conversations.
     */
    dm?: boolean;
    /** Enable a cancel button on each select step. Set to `true` for the default label, or pass options to customize. */
    cancel?: boolean | ActionWizardCancelOptions;
};
/**
 * Multi-step interactive wizard using XMTP actions and intents.
 *
 * Supports two step types:
 * - **select** — presents action buttons, the user responds by clicking one (triggers an intent)
 * - **text** — prompts the user for free-text input
 *
 * The wizard activates when a user sends `/{id}` (e.g. `/api-setup`).
 * Sending the command again while a session is active restarts the wizard from the first step.
 */
declare class ActionWizard<ContentTypes = unknown> {
    #private;
    constructor(id: string, options?: ActionWizardOptions);
    static sessionKey(conversationId: string, senderInboxId: string): string;
    static stepKey(wizardId: string, stepId: string): string;
    select(id: string, options: {
        description: string;
        actions: Action[];
    }): this;
    text(id: string, options: {
        description: string;
        isMarkdown?: boolean;
    }): this;
    onComplete(handler: ActionWizardCompleteHandler<ContentTypes>): this;
    onCancel(handler: ActionWizardCancelHandler<ContentTypes>): this;
    start(ctx: MessageContext<unknown, ContentTypes>): Promise<void>;
    isActive(conversationId: string, senderInboxId: string): boolean;
    middleware(): AgentMiddleware<ContentTypes>;
}

type User = {
    key: Hex;
    account: PrivateKeyAccount;
    wallet: WalletClient;
};
declare const createUser: (key?: HexString, chain?: Chain) => User;
declare const createIdentifier: (user: User) => Identifier;
declare const createSigner: (user: User) => Signer;

declare const createNameResolver: (apiKey?: string) => (name: string) => Promise<string | null>;

/**
 * Minimal ERC-20 ABI containing transfer, balanceOf, and decimals functions.
 * Can be used with viem's encodeFunctionData for custom ERC-20 interactions.
 *
 * @see https://eips.ethereum.org/EIPS/eip-20#methods
 */
declare const erc20Abi: readonly [{
    readonly type: "function";
    readonly name: "transfer";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
}, {
    readonly type: "function";
    readonly name: "balanceOf";
    readonly inputs: readonly [{
        readonly name: "account";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
}, {
    readonly type: "function";
    readonly name: "decimals";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
}];
type CreateERC20TransferCallsOptions = {
    /** The viem Chain object (e.g., baseSepolia from "viem/chains"). */
    chain: Chain;
    /** The ERC-20 token contract address (e.g., Base Token Contract List: https://basescan.org/tokens). */
    tokenAddress: Hex;
    /** The sender's address. */
    from: Hex;
    /** The recipient's address. */
    to: Hex;
    /** The amount to transfer in the token's base units (e.g., 1_000_000 for 1 USDC). */
    amount: bigint;
    /** Description that will be shown in the app with the transaction. */
    description: string;
};
type CreateNativeTransferCallsOptions = Omit<CreateERC20TransferCallsOptions, "tokenAddress">;
type GetERC20BalanceOptions = {
    /** The viem Chain object. */
    chain: Chain;
    /** The ERC-20 token contract address. */
    tokenAddress: Hex;
    /** The address to query the balance of. */
    address: Hex;
    /** Optional custom viem transport. Defaults to http(). */
    transport?: Transport;
};
type GetERC20DecimalsOptions = {
    /** The viem Chain object. */
    chain: Chain;
    /** The ERC-20 token contract address. */
    tokenAddress: Hex;
    /** Optional custom viem transport. Defaults to http(). */
    transport?: Transport;
};
/**
 * Creates a WalletSendCalls payload for an ERC-20 token transfer.
 *
 * @param options - The transfer options
 * @returns A WalletSendCalls object ready to send
 */
declare function createERC20TransferCalls(options: CreateERC20TransferCallsOptions): WalletSendCalls;
/**
 * Creates a WalletSendCalls payload for a native token transfer (ETH, MATIC, etc.).
 *
 * @param options - The transfer options
 * @returns A WalletSendCalls object ready to send
 */
declare function createNativeTransferCalls(options: CreateNativeTransferCallsOptions): WalletSendCalls;
/**
 * Reads the ERC-20 token balance for a given address from the blockchain.
 *
 * @param options - The query options including chain, token address, and wallet address
 * @returns The token balance in base units as a bigint
 */
declare function getERC20Balance(options: GetERC20BalanceOptions): Promise<bigint>;
/**
 * Reads the number of decimals for an ERC-20 token from the blockchain.
 *
 * @param options - The query options including chain and token address
 * @returns The number of decimals (typically 6 or 18)
 */
declare function getERC20Decimals(options: GetERC20DecimalsOptions): Promise<number>;

export { ActionWizard, Agent, AgentError, AgentStreamingError, ClientContext, CommandRouter, ConversationContext, MessageContext, PerformanceMonitor, createERC20TransferCalls, createIdentifier, createNameResolver, createNativeTransferCalls, createRemoteAttachment, createRemoteAttachmentFromFile, createSigner, createUser, downloadRemoteAttachment, erc20Abi, f, filter, getERC20Balance, getERC20Decimals, getInstallationInfo, getTestUrl, getValidLogLevels, logDetails, parseLogLevel };
export type { ActionWizardCancelOptions, ActionWizardOptions, AgentBaseContext, AgentCreateOptions, AgentErrorContext, AgentErrorMiddleware, AgentErrorRegistrar, AgentMessageHandler, AgentMiddleware, AgentOptions, AgentStreamingOptions, AttachmentUploadCallback, CommandRouterConfig, CreateERC20TransferCallsOptions, CreateNativeTransferCallsOptions, DecodedMessageWithContent, GetERC20BalanceOptions, GetERC20DecimalsOptions, HealthReport, MessageContextParams, PerformanceMonitorConfig, StreamAllMessagesOptions, User };