import type { Prettify } from '../types/utils.js';
import { BaseError } from './base.js';
export type RpcErrorCode = -1 | -32700 | -32600 | -32601 | -32602 | -32603 | -32000 | -32001 | -32002 | -32003 | -32004 | -32005 | -32006 | -32042;
type RpcErrorOptions<code extends number = RpcErrorCode> = {
    code?: code | (number & {}) | undefined;
    docsPath?: string | undefined;
    metaMessages?: string[] | undefined;
    name?: string | undefined;
    shortMessage: string;
};
export type RpcErrorType = RpcError & {
    name: 'RpcError';
};
export declare class RpcError<code_ extends number = RpcErrorCode> extends BaseError {
    code: code_ | (number & {});
    constructor(cause: Error, { code, docsPath, metaMessages, name, shortMessage, }: RpcErrorOptions<code_>);
}
export type ProviderRpcErrorCode = 4001 | 4100 | 4200 | 4900 | 4901 | 4902;
export type ProviderRpcErrorType = ProviderRpcError & {
    name: 'ProviderRpcError';
};
export declare class ProviderRpcError<T = undefined> extends RpcError<ProviderRpcErrorCode> {
    data?: T | undefined;
    constructor(cause: Error, options: Prettify<RpcErrorOptions<ProviderRpcErrorCode> & {
        data?: T | undefined;
    }>);
}
export type ParseRpcErrorType = ParseRpcError & {
    code: -32700;
    name: 'ParseRpcError';
};
export declare class ParseRpcError extends RpcError {
    static code: -32700;
    constructor(cause: Error);
}
export type InvalidRequestRpcErrorType = InvalidRequestRpcError & {
    code: -32600;
    name: 'InvalidRequestRpcError';
};
export declare class InvalidRequestRpcError extends RpcError {
    static code: -32600;
    constructor(cause: Error);
}
export type MethodNotFoundRpcErrorType = MethodNotFoundRpcError & {
    code: -32601;
    name: 'MethodNotFoundRpcError';
};
export declare class MethodNotFoundRpcError extends RpcError {
    static code: -32601;
    constructor(cause: Error, { method }?: {
        method?: string;
    });
}
export type InvalidParamsRpcErrorType = InvalidParamsRpcError & {
    code: -32602;
    name: 'InvalidParamsRpcError';
};
export declare class InvalidParamsRpcError extends RpcError {
    static code: -32602;
    constructor(cause: Error);
}
export type InternalRpcErrorType = InternalRpcError & {
    code: -32603;
    name: 'InternalRpcError';
};
export declare class InternalRpcError extends RpcError {
    static code: -32603;
    constructor(cause: Error);
}
export type InvalidInputRpcErrorType = InvalidInputRpcError & {
    code: -32000;
    name: 'InvalidInputRpcError';
};
export declare class InvalidInputRpcError extends RpcError {
    static code: -32000;
    constructor(cause: Error);
}
export type ResourceNotFoundRpcErrorType = ResourceNotFoundRpcError & {
    code: -32001;
};
export declare class ResourceNotFoundRpcError extends RpcError {
    name: string;
    static code: -32001;
    constructor(cause: Error);
}
export type ResourceUnavailableRpcErrorType = ResourceUnavailableRpcError & {
    code: -32002;
    name: 'ResourceUnavailableRpcError';
};
export declare class ResourceUnavailableRpcError extends RpcError {
    static code: -32002;
    constructor(cause: Error);
}
export type TransactionRejectedRpcErrorType = TransactionRejectedRpcError & {
    code: -32003;
    name: 'TransactionRejectedRpcError';
};
export declare class TransactionRejectedRpcError extends RpcError {
    static code: -32003;
    constructor(cause: Error);
}
export type MethodNotSupportedRpcErrorType = MethodNotSupportedRpcError & {
    code: -32004;
    name: 'MethodNotSupportedRpcError';
};
export declare class MethodNotSupportedRpcError extends RpcError {
    static code: -32004;
    constructor(cause: Error, { method }?: {
        method?: string;
    });
}
export type LimitExceededRpcErrorType = LimitExceededRpcError & {
    code: -32005;
    name: 'LimitExceededRpcError';
};
export declare class LimitExceededRpcError extends RpcError {
    static code: -32005;
    constructor(cause: Error);
}
export type JsonRpcVersionUnsupportedErrorType = JsonRpcVersionUnsupportedError & {
    code: -32006;
    name: 'JsonRpcVersionUnsupportedError';
};
export declare class JsonRpcVersionUnsupportedError extends RpcError {
    static code: -32006;
    constructor(cause: Error);
}
export type UserRejectedRequestErrorType = UserRejectedRequestError & {
    code: 4001;
    name: 'UserRejectedRequestError';
};
export declare class UserRejectedRequestError extends ProviderRpcError {
    static code: 4001;
    constructor(cause: Error);
}
export type UnauthorizedProviderErrorType = UnauthorizedProviderError & {
    code: 4100;
    name: 'UnauthorizedProviderError';
};
export declare class UnauthorizedProviderError extends ProviderRpcError {
    static code: 4100;
    constructor(cause: Error);
}
export type UnsupportedProviderMethodErrorType = UnsupportedProviderMethodError & {
    code: 4200;
    name: 'UnsupportedProviderMethodError';
};
export declare class UnsupportedProviderMethodError extends ProviderRpcError {
    static code: 4200;
    constructor(cause: Error, { method }?: {
        method?: string;
    });
}
export type ProviderDisconnectedErrorType = ProviderDisconnectedError & {
    code: 4900;
    name: 'ProviderDisconnectedError';
};
export declare class ProviderDisconnectedError extends ProviderRpcError {
    static code: 4900;
    constructor(cause: Error);
}
export type ChainDisconnectedErrorType = ChainDisconnectedError & {
    code: 4901;
    name: 'ChainDisconnectedError';
};
export declare class ChainDisconnectedError extends ProviderRpcError {
    static code: 4901;
    constructor(cause: Error);
}
export type SwitchChainErrorType = SwitchChainError & {
    code: 4902;
    name: 'SwitchChainError';
};
export declare class SwitchChainError extends ProviderRpcError {
    static code: 4902;
    constructor(cause: Error);
}
export type UnknownRpcErrorType = UnknownRpcError & {
    name: 'UnknownRpcError';
};
export declare class UnknownRpcError extends RpcError {
    constructor(cause: Error);
}
export {};
//# sourceMappingURL=rpc.d.ts.map