import type { AccountClient, Address, BN, Context as AnchorContext, MethodsNamespace, Program as AProgram, ProgramAccount } from "@coral-xyz/anchor";
import type { Idl, IdlAccountItem, IdlAccounts, IdlEvent, IdlEventField, IdlField, IdlInstruction, IdlType, IdlTypeDef, IdlTypeDefTyStruct } from "@coral-xyz/anchor/dist/esm/idl.js";
import type { AccountMeta, PublicKey, Transaction, TransactionInstruction, TransactionSignature } from "@solana/web3.js";
export type IdlWithState = Idl & {
    state?: {
        methods: IdlInstruction[];
        struct: IdlTypeDef;
    };
};
type InstructionsParsed = Record<string, {
    accounts: IdlAccountItem[];
    args: Array<unknown>;
}>;
export type ContextAccounts<A extends IdlAccountItem[]> = {
    [K in A[number]["name"]]: A[number] & {
        name: K;
    } extends IdlAccounts ? ContextAccounts<NonNullable<(A[number] & {
        name: K;
    } & IdlAccounts)["accounts"]>> : Address;
};
type Context<A extends IdlAccountItem[]> = Omit<AnchorContext, "accounts"> & {
    accounts: ContextAccounts<A>;
};
type MakeInstructionsNamespace<R extends InstructionsParsed, Ret, Mk extends {
    [M in keyof R]: unknown;
} = {
    [M in keyof R]: unknown;
}> = {
    [M in keyof R]: ((...args: [...R[M]["args"], Context<R[M]["accounts"]>]) => Ret) & Mk[M];
};
type RpcNamespace<R extends InstructionsParsed> = MakeInstructionsNamespace<R, Promise<TransactionSignature>>;
type InstructionNamespace<R extends InstructionsParsed> = MakeInstructionsNamespace<R, TransactionInstruction, {
    [M in keyof R]: {
        accounts: (ctx: ContextAccounts<R[M]["accounts"]>) => AccountMeta[];
    };
}>;
type TransactionNamespace<R extends InstructionsParsed> = MakeInstructionsNamespace<R, Transaction>;
type AccountsNamespace<A> = {
    [K in keyof A]: Omit<AccountClient, "fetch" | "fetchNullable" | "all" | "associated"> & {
        /**
         * Returns a deserialized account.
         *
         * @param address The address of the account to fetch.
         */
        fetch: (address: PublicKey) => Promise<A[K]>;
        /**
         * Returns a deserialized account, returning null if it doesn't exist.
         *
         * @param address The address of the account to fetch.
         */
        fetchNullable: (address: PublicKey) => Promise<A[K] | null>;
        /**
         * Returns all instances of this account type for the program.
         */
        all: (...args: Parameters<AccountClient["all"]>) => Promise<ProgramAccount<A[K]>[]>;
        /**
         * @deprecated since version 14.0.
         *
         * Function returning the associated account. Args are keys to associate.
         * Order matters.
         */
        associated: (...args: PublicKey[]) => Promise<A[K]>;
    };
};
type TypeMap = {
    publicKey: PublicKey;
    bool: boolean;
    string: string;
    bytes: Uint8Array;
} & {
    [K in "u8" | "i8" | "u16" | "i16" | "u32" | "i32"]: number;
} & {
    [K in "u64" | "i64" | "u128" | "i128"]: BN;
};
type DecodeType<T extends IdlType, Defined> = T extends keyof TypeMap ? TypeMap[T] : T extends {
    defined: keyof Defined;
} ? Defined[T["defined"]] : T extends {
    option: {
        defined: keyof Defined;
    };
} ? Defined[T["option"]["defined"]] | null : T extends {
    option: keyof TypeMap;
} ? TypeMap[T["option"]] | null : T extends {
    vec: {
        defined: keyof Defined;
    };
} ? Defined[T["vec"]["defined"]][] : T extends {
    vec: keyof TypeMap;
} ? TypeMap[T["vec"]][] : T extends {
    array: [idlType: keyof TypeMap, size: number];
} ? TypeMap[T["array"][0]][] : unknown;
type MakeArgs<A extends IdlField[], Defined> = {
    [K in keyof A]: A[K] extends IdlField ? DecodeType<A[K]["type"], Defined> : unknown;
};
type MakeNamedArgs<A extends IdlField, Defined> = {
    [K in A["name"]]: DecodeType<(A & {
        name: K;
    })["type"], Defined>;
};
type MakeInstructions<I extends IdlInstruction[], Defined> = {
    [K in I[number]["name"]]: {
        accounts: (I[number] & {
            name: K;
        })["accounts"];
        args: MakeArgs<(I[number] & {
            name: K;
        })["args"], Defined> & unknown[];
        namedArgs: MakeNamedArgs<(I[number] & {
            name: K;
        })["args"][number], Defined>;
    };
};
export type AnchorProgram<IDL extends IdlWithState, A, Defined = AnchorDefined<IDL>, RPCInstructions extends MakeInstructions<IDL["instructions"], Defined> = MakeInstructions<IDL["instructions"], Defined>, Methods extends MakeInstructions<NonNullable<IDL["state"]>["methods"], Defined> = MakeInstructions<NonNullable<IDL["state"]>["methods"], Defined>> = Omit<AProgram, "rpc" | "state" | "account" | "transaction" | "instruction"> & {
    rpc: RpcNamespace<RPCInstructions>;
    state: MethodsNamespace<IDL>;
    account: AccountsNamespace<A>;
    transaction: TransactionNamespace<RPCInstructions & Methods>;
    instruction: InstructionNamespace<RPCInstructions & Methods>;
};
export type AnchorError<T extends Idl> = NonNullable<T["errors"]>[number];
type FieldsOfType<I extends IdlTypeDef> = I extends {
    type: IdlTypeDefTyStruct;
} ? NonNullable<I["type"]["fields"]>[number] : never;
type AnchorTypeDef<I extends IdlTypeDef, Defined> = {
    [F in FieldsOfType<I>["name"]]: DecodeType<(FieldsOfType<I> & {
        name: F;
    })["type"], Defined>;
};
type AnchorTypeDefs<T extends IdlTypeDef[], Defined> = {
    [K in T[number]["name"]]: AnchorTypeDef<T[number] & {
        name: K;
    }, Defined>;
};
export type AnchorDefined<T extends Idl, D = Record<string, never>> = AnchorTypeDefs<NonNullable<T["types"]>, D>;
export type AnchorAccounts<T extends Idl, Defined> = AnchorTypeDefs<NonNullable<T["accounts"]>, Defined>;
export type AnchorState<T extends IdlWithState, Defined> = AnchorTypeDef<NonNullable<T["state"]>["struct"], Defined>;
export type AnchorTypes<T extends IdlWithState, AccountMap = Record<string, never>, D = Record<string, never>, DEF = AnchorDefined<T, D>> = {
    Defined: DEF;
    Accounts: AnchorAccounts<T, DEF>;
    State: AnchorState<T, DEF>;
    Error: AnchorError<T>;
    Program: AnchorProgram<T, AccountMap, DEF>;
    Instructions: MakeInstructions<T["instructions"], DEF>;
    Methods: MakeInstructions<NonNullable<T["state"]>["methods"], DEF>;
    Events: AnchorEvents<NonNullable<T["events"]>[number], DEF>;
    AccountMap: AccountMap;
    IDL: T;
};
type AnchorEvent<T extends IdlEventField, Defined> = {
    [N in T["name"]]: DecodeType<(T & {
        name: N;
    })["type"], Defined>;
};
type AnchorEvents<T extends IdlEvent, Defined> = {
    [K in T["name"]]: {
        name: K;
        data: AnchorEvent<(T & {
            name: K;
        })["fields"][number], Defined>;
    };
};
export {};
//# sourceMappingURL=types.d.ts.map