import { HexString, Enum, Binary, Descriptors, QueryFromDescriptors, TxFromDescriptors, EventsFromDescriptors, ConstFromDescriptors, BlockHeader, RuntimeDescriptor } from '@polkadot-api/substrate-bindings';
export { AccountId, AssetDescriptor, Binary, Codec, ConstFromDescriptors, Enum, ErrorsFromDescriptors, EventsFromDescriptors, FixedSizeBinary, GetEnum, HexString, PlainDescriptor, QueryFromDescriptors, ResultPayload, RuntimeDescriptor, SS58String, StorageDescriptor, TxDescriptor, TxFromDescriptors, _Enum } from '@polkadot-api/substrate-bindings';
import { Observable } from 'rxjs';
import { BlockInfo, SystemEvent as SystemEvent$1 } from '@polkadot-api/observable-client';
import { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
export { PolkadotSigner } from '@polkadot-api/polkadot-signer';

declare class Runtime {
    protected _ctx: unknown;
    protected _checksums: string[];
    private constructor();
}
type RuntimeApi = Observable<Runtime> & {
    latest: () => Promise<Runtime>;
};
interface IsCompatible {
    (): Promise<boolean>;
    (runtime: Runtime): boolean;
}

type EventPhase = {
    type: "ApplyExtrinsic";
    value: number;
} | {
    type: "Finalization";
} | {
    type: "Initialization";
};
type EvWatch<T> = (filter?: (value: T) => boolean) => Observable<{
    meta: {
        block: BlockInfo;
        phase: EventPhase;
    };
    payload: T;
}>;
type EvPull<T> = () => Promise<Array<{
    meta: {
        block: BlockInfo;
        phase: EventPhase;
    };
    payload: T;
}>>;
type EvFilter<T> = (collection: SystemEvent["event"][]) => Array<T>;
type EvClient<T> = {
    watch: EvWatch<T>;
    pull: EvPull<T>;
    filter: EvFilter<T>;
    isCompatible: IsCompatible;
};
type SystemEvent = {
    phase: EventPhase;
    event: {
        type: string;
        value: {
            type: string;
            value: any;
        };
    };
    topics: Array<any>;
};

type CallOptions$1 = Partial<{
    at: string;
    signal: AbortSignal;
}>;
type WithCallOptions$1<Args extends Array<any>> = [
    ...args: Args,
    options?: CallOptions$1
];
type PossibleParents<A extends Array<any>> = A extends [...infer Left, any] ? Left | PossibleParents<Left> : [];
type StorageEntryWithoutKeys<Payload> = {
    isCompatible: IsCompatible;
    getValue: (options?: CallOptions$1) => Promise<Payload>;
    watchValue: (bestOrFinalized?: "best" | "finalized") => Observable<Payload>;
};
type StorageEntryWithKeys<Args extends Array<any>, Payload> = {
    isCompatible: IsCompatible;
    getValue: (...args: [...WithCallOptions$1<Args>]) => Promise<Payload>;
    watchValue: (...args: [...Args, bestOrFinalized?: "best" | "finalized"]) => Observable<Payload>;
    getValues: (keys: Array<[...Args]>, options?: CallOptions$1) => Promise<Array<Payload>>;
    getEntries: (...args: WithCallOptions$1<PossibleParents<Args>>) => Promise<Array<{
        keyArgs: Args;
        value: NonNullable<Payload>;
    }>>;
};
type StorageEntry<Args extends Array<any>, Payload> = Args extends [] ? StorageEntryWithoutKeys<Payload> : StorageEntryWithKeys<Args, Payload>;

interface PolkadotSigner {
    publicKey: Uint8Array;
    sign: (callData: Uint8Array, signedExtensions: Record<string, {
        identifier: string;
        value: Uint8Array;
        additionalSigned: Uint8Array;
    }>, metadata: Uint8Array, atBlockNumber: number, hasher?: (data: Uint8Array) => Uint8Array) => Promise<Uint8Array>;
}

type TxBroadcastEvent = {
    type: "broadcasted";
} | {
    type: "bestChainBlockIncluded";
    block: {
        hash: string;
        index: number;
    };
} | ({
    type: "finalized";
} & TxFinalizedPayload);
type TxEvent = TxBroadcastEvent | {
    type: "signed";
    tx: HexString;
};
type TxFinalizedPayload = {
    ok: boolean;
    events: Array<SystemEvent$1["event"]>;
    block: {
        hash: string;
        index: number;
    };
};
type TxFunction<Asset> = (from: PolkadotSigner, hintedSignExtensions?: Partial<void extends Asset ? {
    tip: bigint;
    mortal: {
        mortal: false;
    } | {
        mortal: true;
        period: number;
    };
} : {
    tip: bigint;
    mortal: {
        mortal: false;
    } | {
        mortal: true;
        period: number;
    };
    asset: Asset;
}>) => Promise<TxFinalizedPayload>;
type TxObservable<Asset> = (from: PolkadotSigner, hintedSignExtensions?: Partial<void extends Asset ? {
    tip: bigint;
    mortal: {
        mortal: false;
    } | {
        mortal: true;
        period: number;
    };
} : {
    tip: bigint;
    mortal: {
        mortal: false;
    } | {
        mortal: true;
        period: number;
    };
    asset: Asset;
}>) => Observable<TxEvent>;
interface TxCall {
    (): Promise<Binary>;
    (runtime: Runtime): Binary;
}
type TxSigned<Asset> = (from: PolkadotSigner, hintedSignExtensions?: Partial<void extends Asset ? {
    tip: bigint;
    mortal: {
        mortal: false;
    } | {
        mortal: true;
        period: number;
    };
} : {
    tip: bigint;
    mortal: {
        mortal: false;
    } | {
        mortal: true;
        period: number;
    };
    asset: Asset;
}>) => Promise<string>;
type Transaction<Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> = {
    sign: TxSigned<Asset>;
    signSubmitAndWatch: TxObservable<Asset>;
    signAndSubmit: TxFunction<Asset>;
    getEncodedData: TxCall;
    decodedCall: Enum<{
        type: Pallet;
        value: Enum<{
            type: Name;
            value: Arg;
        }>;
    }>;
};
interface TxEntry<Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> {
    (...args: Arg extends undefined ? [] : [data: Arg]): Transaction<Arg, Pallet, Name, Asset>;
    isCompatible: IsCompatible;
}

interface ConstantEntry<T> {
    (): Promise<T>;
    (runtime: Runtime): T;
    isCompatible: IsCompatible;
}

type CallOptions = Partial<{
    at: string;
    signal: AbortSignal;
}>;
type WithCallOptions<Args extends Array<any>> = Args["length"] extends 0 ? [options?: CallOptions] : [...args: Args, options?: CallOptions];
interface RuntimeCall<Args extends Array<any>, Payload> {
    (...args: WithCallOptions<Args>): Promise<Payload>;
    isCompatible: IsCompatible;
}

type StorageApi<A extends Record<string, Record<string, {
    KeyArgs: Array<any>;
    Value: any;
    IsOptional: false | true;
} | unknown>>> = {
    [K in keyof A]: {
        [KK in keyof A[K]]: A[K][KK] extends {
            KeyArgs: Array<any>;
            Value: any;
            IsOptional: false | true;
        } ? StorageEntry<A[K][KK]["KeyArgs"], A[K][KK]["IsOptional"] extends true ? A[K][KK]["Value"] | undefined : A[K][KK]["Value"]> : unknown;
    };
};
type RuntimeCallsApi<A extends Record<string, Record<string, RuntimeDescriptor<Array<any>, any>>>> = {
    [K in keyof A]: {
        [KK in keyof A[K]]: A[K][KK] extends RuntimeDescriptor<infer Args, infer Value> ? RuntimeCall<Args, Value> : unknown;
    };
};
type TxApi<A extends Record<string, Record<string, any>>, Asset> = {
    [K in keyof A]: {
        [KK in keyof A[K]]: A[K][KK] extends {} | undefined ? TxEntry<A[K][KK], K & string, KK & string, Asset> : unknown;
    };
};
type EvApi<A extends Record<string, Record<string, any>>> = {
    [K in keyof A]: {
        [KK in keyof A[K]]: EvClient<A[K][KK]>;
    };
};
type ConstApi<A extends Record<string, Record<string, any>>> = {
    [K in keyof A]: {
        [KK in keyof A[K]]: ConstantEntry<A[K][KK]>;
    };
};
type TypedApi<D extends Descriptors> = {
    query: StorageApi<QueryFromDescriptors<D>>;
    tx: TxApi<TxFromDescriptors<D>, D["asset"]["_type"]>;
    event: EvApi<EventsFromDescriptors<D>>;
    apis: RuntimeCallsApi<D["apis"]>;
    constants: ConstApi<ConstFromDescriptors<D>>;
    runtime: RuntimeApi;
};
interface PolkadotClient {
    finalized$: Observable<BlockInfo>;
    bestBlocks$: Observable<BlockInfo[]>;
    getBlockHeader: (hash?: string) => Promise<BlockHeader>;
    getBlockBody: (hash: string) => Observable<HexString[]>;
    getTypedApi: <D extends Descriptors>(descriptors: D) => TypedApi<D>;
    destroy: () => void;
    submit: (transaction: HexString) => Promise<TxFinalizedPayload>;
    submitAndWatch: (transaction: HexString) => Observable<TxBroadcastEvent>;
}
type FixedSizeArray<L extends number, T> = Array<T> & {
    length: L;
};

declare function createClient(provider: JsonRpcProvider): PolkadotClient;

export { type EventPhase, type FixedSizeArray, type PolkadotClient, type TxBroadcastEvent, type TxEvent, type TxFinalizedPayload, type TypedApi, createClient };