@hazae41/jsonrpc/dist/types/mods/rpc/err.d.ts

Rust-like JSON-RPC for TypeScript

import { Err } from '@hazae41/result';
import { RpcId } from './request.js';

interface RpcErrorInit {
    readonly code: number;
    readonly message: string;
    readonly data: unknown;
}
interface RpcErrInit {
    readonly jsonrpc: "2.0";
    readonly id: RpcId;
    readonly error: RpcErrorInit;
}
declare namespace RpcErrInit {
    function from(response: RpcErr): RpcErrInit;
}
declare class RpcError extends Error {
    #private;
    readonly code: number;
    readonly message: string;
    readonly data: unknown;
    readonly name: string;
    static readonly codes: {
        readonly ParseError: -32700;
        readonly InvalidRequest: -32600;
        readonly MethodNotFound: -32601;
        readonly InvalidParams: -32602;
        readonly InternalError: -32603;
    };
    static readonly messages: {
        readonly ParseError: "Parse error";
        readonly InvalidRequest: "Invalid Request";
        readonly MethodNotFound: "Method not found";
        readonly InvalidParams: "Invalid params";
        readonly InternalError: "Internal error";
        readonly ServerError: "Server error";
    };
    constructor(code: number, message: string, data?: unknown);
    static from(init: RpcErrorInit): RpcError;
    static rewrap(error: unknown): RpcError;
    toJSON(): {
        code: number;
        message: string;
        data: unknown;
    };
}
declare class RpcParseError extends RpcError {
    #private;
    readonly name: string;
    static readonly code: -32700;
    static readonly message: "Parse error";
    constructor(message?: string);
}
declare class RpcInvalidRequestError extends RpcError {
    #private;
    readonly name: string;
    static readonly code: -32600;
    static readonly message: "Invalid Request";
    constructor(message?: string);
}
declare class RpcMethodNotFoundError extends RpcError {
    #private;
    readonly name: string;
    static readonly code: -32601;
    static readonly message: "Method not found";
    constructor(message?: string);
}
declare class RpcInvalidParamsError extends RpcError {
    #private;
    readonly name: string;
    static readonly code: -32602;
    static readonly message: "Invalid params";
    constructor(message?: string);
}
declare class RpcInternalError extends RpcError {
    #private;
    readonly name: string;
    static readonly code: -32603;
    static readonly message: "Internal error";
    constructor(message?: string);
}
declare class RpcErr extends Err<RpcError> {
    readonly id: RpcId;
    readonly error: RpcError;
    readonly jsonrpc = "2.0";
    constructor(id: RpcId, error: RpcError);
    static from(init: RpcErrInit): RpcErr;
    static rewrap<T extends Err.Infer<T>>(id: RpcId, result: T): RpcErr;
    toJSON(): {
        readonly jsonrpc: "2.0";
        readonly id: RpcId;
        readonly error: {
            code: number;
            message: string;
            data: unknown;
        };
    };
}

export { RpcErr, RpcErrInit, RpcError, type RpcErrorInit, RpcInternalError, RpcInvalidParamsError, RpcInvalidRequestError, RpcMethodNotFoundError, RpcParseError };