chia-agent/api/ws/daemon/index.d.ts

chia rpc/websocket client library

import { GetMessageType } from "../../types";
import { TDaemon } from "../../../daemon/index";
import { bool, False, None, Optional, str, True } from "../../chia/types/_python_types_";
import { G1Element } from "../../chia_rs/chia-bls/lib";
import { int, uint32 } from "../../chia_rs/wheel/python/sized_ints";
import { chiapos_install_info } from "../../chia/plotters/chiapos";
import { bladebit_install_info } from "../../chia/plotters/bladebit";
import { madmax_install_info } from "../../chia/plotters/maxmax";
import { KeyData } from "../../chia/util/keychain";
export declare const daemon_service = "daemon";
export type daemon_service = typeof daemon_service;
export declare const ping_command = "ping";
export type ping_command = typeof ping_command;
export type TPingRequest = Record<string, never>;
export type TPingResponse = {
    success: True;
    value: str;
};
export type WsPingMessage = GetMessageType<daemon_service, ping_command, TPingResponse>;
export declare function ping(daemon: TDaemon): Promise<WsPingMessage>;
export type TService = "chia" | "chia_wallet" | "chia_full_node" | "chia_harvester" | "chia_farmer" | "chia_introducer" | "chia_timelord" | "chia_timelord_launcher" | "chia_full_node_simulator";
export declare const start_service_command = "start_service";
export type start_service_command = typeof start_service_command;
export type TStartServiceRequest = {
    service: TService;
    testing?: bool;
};
export type TStartServiceResponse = {
    success: bool;
    service: TService;
    error: Optional<str>;
};
export type WsStartServiceMessage = GetMessageType<daemon_service, start_service_command, TStartServiceResponse>;
export declare function start_service(daemon: TDaemon, data: TStartServiceRequest): Promise<WsStartServiceMessage>;
export declare const start_plotting_command = "start_plotting";
export type start_plotting_command = typeof start_plotting_command;
export type TCommonPlottingParams = {
    service: "chia_plotter";
    delay?: int;
    parallel?: bool;
    k: int;
    t: str;
    d: str;
    x?: bool;
    n?: int;
    queue?: str;
    r: int;
    f?: str;
    p?: str;
    c?: str;
};
export type TChiaPosParams = {
    plotter: "chiapos";
    t2?: str;
    b: int;
    u: int;
    a?: int;
    e: bool;
    overrideK: bool;
};
export type TBladeBitRamParams = {
    plotter: "bladebit";
    plot_type: "ramplot";
    w?: bool;
    m?: bool;
    no_cpu_affinity?: bool;
    compress?: int;
};
export type TBladeBitDiskParams = {
    plotter: "bladebit";
    plot_type: "diskplot";
    w?: bool;
    m?: bool;
    no_cpu_affinity?: bool;
    compress?: int;
    t1: str;
    t2?: str;
    u?: int;
    cache?: str;
    f1_threads?: int;
    fp_threads?: int;
    c_threads?: int;
    p2_threads?: int;
    p3_threads?: int;
    alternate?: bool;
    no_t1_direct?: bool;
    no_t2_direct?: bool;
};
export type TBladeBitCudaParams = {
    plotter: "bladebit";
    plot_type: "cudaplot";
    w?: bool;
    m?: bool;
    no_cpu_affinity?: bool;
    compress?: int;
    device?: int;
    t?: str;
    t2?: str;
    disk_128?: bool;
    disk_16?: bool;
};
export type TMadMaxParams = {
    plotter: "madmax";
    t2: str;
    b: int;
    u: int;
    v: int;
    K?: int;
    G?: bool;
};
export type TStartPlottingRequest = TCommonPlottingParams & (TChiaPosParams | TBladeBitRamParams | TBladeBitDiskParams | TBladeBitCudaParams | TMadMaxParams);
export type TStartPlottingResponse = {
    success: bool;
    ids: str[];
    service_name: str;
};
export type WsStartPlottingMessage = GetMessageType<daemon_service, start_plotting_command, TStartPlottingResponse>;
export declare function start_plotting(daemon: TDaemon, data: TStartPlottingRequest): Promise<WsStartPlottingMessage>;
export declare const stop_plotting_command = "stop_plotting";
export type stop_plotting_command = typeof stop_plotting_command;
export type TStopPlottingRequest = {
    id: str;
};
export type TStopPlottingResponse = {
    success: bool;
};
export type WsStopPlottingMessage = GetMessageType<daemon_service, stop_plotting_command, TStopPlottingResponse>;
export declare function stop_plotting(daemon: TDaemon, data: TStopPlottingRequest): Promise<WsStopPlottingMessage>;
export declare const stop_service_command = "stop_service";
export type stop_service_command = typeof stop_service_command;
export type TStopServiceRequest = {
    service: str;
};
export type TStopServiceResponse = {
    success: bool;
    service_name: str;
};
export type WsStopServiceMessage = GetMessageType<daemon_service, stop_service_command, TStopServiceResponse>;
export declare function stop_service(daemon: TDaemon, data: TStopServiceRequest): Promise<WsStopServiceMessage>;
export declare const running_services_command = "running_services";
export type running_services_command = typeof running_services_command;
export type TRunningServicesResponse = {
    success: bool;
    running_services: str[];
};
export type WsRunningServicesMessage = GetMessageType<daemon_service, running_services_command, TRunningServicesResponse>;
export declare function running_services(daemon: TDaemon): Promise<WsRunningServicesMessage>;
export declare const is_running_command = "is_running";
export type is_running_command = typeof is_running_command;
export type TIsRunningRequest = {
    service: str;
};
export type TIsRunningResponse = {
    success: bool;
    service_name: str;
    is_running: bool;
};
export type WsIsRunningMessage = GetMessageType<daemon_service, is_running_command, TIsRunningResponse>;
export declare function is_running(daemon: TDaemon, data: TIsRunningRequest): Promise<WsIsRunningMessage>;
export declare const add_private_key_command = "add_private_key";
export type add_private_key_command = typeof add_private_key_command;
export type TAddPrivateKeyRequest = {
    kc_user?: str;
    kc_service?: str;
    mnemonic?: str;
    label?: str;
};
export type TAddPrivateKeyResponse = {
    success: True;
    fingerprint: G1Element;
} | {
    success: False;
    error: str;
    error_details?: {
        message: str;
    };
};
export type WsAddPrivateKeyMessage = GetMessageType<daemon_service, add_private_key_command, TAddPrivateKeyResponse>;
export declare function add_private_key(daemon: TDaemon, data: TAddPrivateKeyRequest): Promise<WsAddPrivateKeyMessage>;
export declare const add_key_command = "add_key";
export type add_key_command = typeof add_key_command;
export type TAddKeyRequest = {
    kc_user?: str;
    kc_service?: str;
    mnemonic_or_pk?: str;
    label?: str;
    private?: bool;
};
export type TAddKeyResponse = {
    success: True;
    fingerprint: G1Element;
} | {
    success: False;
    error: str;
    error_details?: {
        message: str;
    };
};
export type WsAddKeyMessage = GetMessageType<daemon_service, add_key_command, TAddKeyResponse>;
export declare function add_key(daemon: TDaemon, data: TAddKeyRequest): Promise<WsAddKeyMessage>;
export declare const check_keys_command = "check_keys";
export type check_keys_command = typeof check_keys_command;
export type TCheckKeysRequest = {
    kc_user?: str;
    kc_service?: str;
    root_path: str;
};
export type TCheckKeysResponse = {
    success: bool;
    error?: str;
    error_details?: {
        message: str;
    };
};
export type WsCheckKeysMessage = GetMessageType<daemon_service, check_keys_command, TCheckKeysResponse>;
export declare function check_keys(daemon: TDaemon, data: TCheckKeysRequest): Promise<WsCheckKeysMessage>;
export declare const delete_all_keys_command = "delete_all_keys";
export type delete_all_keys_command = typeof delete_all_keys_command;
export type TDeleteAllKeysRequest = {
    kc_user?: str;
    kc_service?: str;
};
export type TDeleteAllKeysResponse = {
    success: bool;
    error?: str;
    error_details?: {
        message: str;
    };
};
export type WsDeleteAllKeysMessage = GetMessageType<daemon_service, delete_all_keys_command, TDeleteAllKeysResponse>;
export declare function delete_all_keys(daemon: TDaemon, data: TDeleteAllKeysRequest): Promise<WsDeleteAllKeysMessage>;
export declare const delete_key_by_fingerprint_command = "delete_key_by_fingerprint";
export type delete_key_by_fingerprint_command = typeof delete_key_by_fingerprint_command;
export type TDeleteKeyByFingerprintRequest = {
    kc_user?: str;
    kc_service?: str;
    fingerprint: int;
};
export type TDeleteKeyByFingerprintResponse = {
    success: bool;
    error?: str;
    error_details?: {
        message: str;
    };
};
export type WsDeleteKeyByFingerprintMessage = GetMessageType<daemon_service, delete_key_by_fingerprint_command, TDeleteKeyByFingerprintResponse>;
export declare function delete_key_by_fingerprint(daemon: TDaemon, data: TDeleteKeyByFingerprintRequest): Promise<WsDeleteKeyByFingerprintMessage>;
export declare const get_all_private_keys_command = "get_all_private_keys";
export type get_all_private_keys_command = typeof get_all_private_keys_command;
export type TGetAllPrivateKeysRequest = {
    kc_user?: str;
    kc_service?: str;
};
export type TGetAllPrivateKeysResponse = {
    success: bool;
    error?: str;
    private_keys: Array<{
        pk: str;
        entropy: str;
    }>;
};
export type WsGetAllPrivateKeysMessage = GetMessageType<daemon_service, get_all_private_keys_command, TGetAllPrivateKeysResponse>;
export declare function get_all_private_keys(daemon: TDaemon, data: TGetAllPrivateKeysRequest): Promise<WsGetAllPrivateKeysMessage>;
export declare const get_first_private_key_command = "get_first_private_key";
export type get_first_private_key_command = typeof get_first_private_key_command;
export type TGetFirstPrivateKeyRequest = {
    kc_user?: str;
    kc_service?: str;
};
export type TGetFirstPrivateKeyResponse = {
    success: bool;
    error?: str;
    private_key: {
        pk: str;
        entropy: str;
    };
};
export type WsGetFirstPrivateKeyMessage = GetMessageType<daemon_service, get_first_private_key_command, TGetFirstPrivateKeyResponse>;
export declare function get_first_private_key(daemon: TDaemon, data: TGetFirstPrivateKeyRequest): Promise<WsGetFirstPrivateKeyMessage>;
export declare const get_key_for_fingerprint_command = "get_key_for_fingerprint";
export type get_key_for_fingerprint_command = typeof get_key_for_fingerprint_command;
export type TGetKeyForFingerprintRequest = {
    kc_user?: str;
    kc_service?: str;
    private?: bool;
    fingerprint?: int;
};
export type TGetKeyForFingerprintResponse = {
    success: False;
    error: str;
} | {
    success: True;
    pk: str;
    entropy: str;
};
export type WsGetKeyForFingerprintMessage = GetMessageType<daemon_service, get_key_for_fingerprint_command, TGetKeyForFingerprintResponse>;
export declare function get_key_for_fingerprint(daemon: TDaemon, data: TGetKeyForFingerprintRequest): Promise<WsGetKeyForFingerprintMessage>;
export declare const get_key_command = "get_key";
export type get_key_command = typeof get_key_command;
export type TGetKeyRequest = {
    fingerprint: uint32;
    include_secrets?: bool;
    kc_user?: str;
    kc_service?: str;
};
export type TGetKeyResponse = {
    success: True;
    key: KeyData;
} | {
    success: False;
    error: "keyring is locked" | "key not found" | "malformed request";
    error_details?: {
        message: str;
    } | {
        fingerprint: int;
    };
};
export type WsGetKeyMessage = GetMessageType<daemon_service, get_key_command, TGetKeyResponse>;
export declare function get_key(daemon: TDaemon, data: TGetKeyRequest): Promise<WsGetKeyMessage>;
export declare const get_keys_command = "get_keys";
export type get_keys_command = typeof get_keys_command;
export type TGetKeysRequest = {
    include_secrets?: bool;
    kc_user?: str;
    kc_service?: str;
};
export type TGetKeysResponse = {
    success: True;
    keys: KeyData[];
} | {
    success: False;
    error: "keyring is locked" | "key not found" | "malformed request";
    error_details?: {
        message: str;
    } | {
        fingerprint: int;
    };
};
export type WsGetKeysMessage = GetMessageType<daemon_service, get_keys_command, TGetKeysResponse>;
export declare function get_keys(daemon: TDaemon, data: TGetKeysRequest): Promise<WsGetKeysMessage>;
export declare const get_public_key_command = "get_public_key";
export type get_public_key_command = typeof get_public_key_command;
export type TGetPublicKeyRequest = {
    fingerprint: uint32;
    kc_user?: str;
    kc_service?: str;
};
export type TGetPublicKeyResponse = {
    success: True;
    key: Omit<KeyData, "secrets">;
} | {
    success: False;
    error: "keyring is locked" | "key not found" | "malformed request";
    error_details?: {
        message: str;
    } | {
        fingerprint: int;
    };
};
export type WsGetPublicKeyMessage = GetMessageType<daemon_service, get_public_key_command, TGetPublicKeyResponse>;
export declare function get_public_key(daemon: TDaemon, data: TGetPublicKeyRequest): Promise<WsGetPublicKeyMessage>;
export declare const get_public_keys_command = "get_public_keys";
export type get_public_keys_command = typeof get_public_keys_command;
export type TGetPublicKeysRequest = {
    kc_user?: str;
    kc_service?: str;
};
export type TGetPublicKeysResponse = {
    success: True;
    keys: Array<Omit<KeyData, "secrets">>;
} | {
    success: False;
    error: "keyring is locked" | "key not found" | "malformed request";
    error_details?: {
        message: str;
    } | {
        fingerprint: int;
    };
};
export type WsGetPublicKeysMessage = GetMessageType<daemon_service, get_public_keys_command, TGetPublicKeysResponse>;
export declare function get_public_keys(daemon: TDaemon, data: TGetPublicKeysRequest): Promise<WsGetPublicKeysMessage>;
export declare const set_label_command = "set_label";
export type set_label_command = typeof set_label_command;
export type TSetLabelRequest = {
    fingerprint: uint32;
    label: str;
    kc_user?: str;
    kc_service?: str;
};
export type TSetLabelResponse = {
    success: True;
} | {
    success: False;
    error: "keyring is locked" | "key not found" | "malformed request";
    error_details?: {
        message: str;
    } | {
        fingerprint: int;
    };
};
export type WsSetLabelMessage = GetMessageType<daemon_service, set_label_command, TSetLabelResponse>;
export declare function set_label(daemon: TDaemon, data: TSetLabelRequest): Promise<WsSetLabelMessage>;
export declare const delete_label_command = "delete_label";
export type delete_label_command = typeof delete_label_command;
export type TDeleteLabelRequest = {
    fingerprint: uint32;
    kc_user?: str;
    kc_service?: str;
};
export type TDeleteLabelResponse = {
    success: True;
} | {
    success: False;
    error: "keyring is locked" | "key not found" | "malformed request";
    error_details?: {
        message: str;
    } | {
        fingerprint: int;
    };
};
export type WsDeleteLabelMessage = GetMessageType<daemon_service, delete_label_command, TDeleteLabelResponse>;
export declare function delete_label(daemon: TDaemon, data: TDeleteLabelRequest): Promise<WsDeleteLabelMessage>;
export declare const is_keyring_locked_command = "is_keyring_locked";
export type is_keyring_locked_command = typeof is_keyring_locked_command;
export type TIsKeyringLockedResponse = {
    success: bool;
    is_keyring_locked: bool;
};
export type WsIsKeyringLockedMessage = GetMessageType<daemon_service, is_keyring_locked_command, TIsKeyringLockedResponse>;
export declare function is_keyring_locked(daemon: TDaemon): Promise<WsIsKeyringLockedMessage>;
export declare const keyring_status_command = "keyring_status";
export type keyring_status_command = typeof keyring_status_command;
export type TKeyringStatusResponse = {
    success: bool;
    is_keyring_locked: bool;
    passphrase_support_enabled: bool;
    can_save_passphrase: bool;
    user_passphrase_is_set: bool;
    can_set_passphrase_hint: bool;
    passphrase_hint: str;
    passphrase_requirements: Record<string, never> | {
        is_optional: True;
        min_length: int;
    };
};
export type WsKeyringStateMessage = GetMessageType<daemon_service, keyring_status_command, TKeyringStatusResponse>;
export declare function keyring_status(daemon: TDaemon): Promise<WsKeyringStateMessage>;
export declare const unlock_keyring_command = "unlock_keyring";
export type unlock_keyring_command = typeof unlock_keyring_command;
export type TUnlockKeyringRequest = {
    key: string;
};
export type TUnlockKeyringResponse = {
    success: bool;
    error: str | None;
};
export type WsUnlockKeyringMessage = GetMessageType<daemon_service, unlock_keyring_command, TUnlockKeyringResponse>;
export declare function unlock_keyring(daemon: TDaemon, data: TUnlockKeyringRequest): Promise<WsUnlockKeyringMessage>;
export declare const validate_keyring_passphrase_command = "validate_keyring_passphrase";
export type validate_keyring_passphrase_command = typeof validate_keyring_passphrase_command;
export type TValidateKeyringPassphraseRequest = {
    key: string;
};
export type TValidateKeyringPassphraseResponse = {
    success: bool;
    error: str | None;
};
export type WsValidateKeyringPassphraseMessage = GetMessageType<daemon_service, validate_keyring_passphrase_command, TValidateKeyringPassphraseResponse>;
export declare function validate_keyring_passphrase(daemon: TDaemon, data: TValidateKeyringPassphraseRequest): Promise<WsValidateKeyringPassphraseMessage>;
export declare const migrate_keyring_command = "migrate_keyring";
export type migrate_keyring_command = typeof migrate_keyring_command;
export type TMigrateKeyringRequest = {
    passphrase?: str;
    passphrase_hint?: str;
    save_passphrase?: bool;
    cleanup_legacy_keyring?: bool;
};
export type TMigrateKeyringResponse = {
    success: bool;
    error: str | None;
};
export type WsMigrateKeyringMessage = GetMessageType<daemon_service, migrate_keyring_command, TMigrateKeyringResponse>;
export declare function migrate_keyring(daemon: TDaemon, data: TMigrateKeyringRequest): Promise<WsMigrateKeyringMessage>;
export declare const set_keyring_passphrase_command = "set_keyring_passphrase";
export type set_keyring_passphrase_command = typeof set_keyring_passphrase_command;
export type TSetKeyringPassphraseRequest = {
    current_passphrase: str;
    new_passphrase: str;
    passphrase_hint?: str;
    save_passphrase?: bool;
};
export type TSetKeyringPassphraseResponse = {
    success: bool;
    error: str;
};
export type WsSetKeyringPassphraseMessage = GetMessageType<daemon_service, set_keyring_passphrase_command, TSetKeyringPassphraseResponse>;
export declare function set_keyring_passphrase(daemon: TDaemon, data: TSetKeyringPassphraseRequest): Promise<WsSetKeyringPassphraseMessage>;
export declare const remove_keyring_passphrase_command = "remove_keyring_passphrase";
export type remove_keyring_passphrase_command = typeof remove_keyring_passphrase_command;
export type TRemoveKeyringPassphraseRequest = {
    current_passphrase: str;
};
export type TRemoveKeyringPassphraseResponse = {
    success: bool;
    error: str;
};
export type WsRemoveKeyringPassphraseMessage = GetMessageType<daemon_service, remove_keyring_passphrase_command, TRemoveKeyringPassphraseResponse>;
export declare function remove_keyring_passphrase(daemon: TDaemon, data: TRemoveKeyringPassphraseRequest): Promise<WsRemoveKeyringPassphraseMessage>;
export declare const notify_keyring_migration_completed_command = "notify_keyring_migration_completed";
export type notify_keyring_migration_completed_command = typeof notify_keyring_migration_completed_command;
export type TNotifyKeyringMigrationCompletedRequest = {
    key: str;
};
export type TNotifyKeyringMigrationCompletedResponse = {
    success: bool;
    error: str;
};
export type WsNotifyKeyringMigrationCompletedMessage = GetMessageType<daemon_service, notify_keyring_migration_completed_command, TNotifyKeyringMigrationCompletedResponse>;
export declare function notify_keyring_migration_completed(daemon: TDaemon, data: TNotifyKeyringMigrationCompletedRequest): Promise<WsNotifyKeyringMigrationCompletedMessage>;
export declare const exit_command = "exit";
export type exit_command = typeof exit_command;
export type TExitResponse = {
    success: bool;
};
export type WsExitMessage = GetMessageType<daemon_service, exit_command, TExitResponse>;
export declare function exit(daemon: TDaemon): Promise<WsExitMessage>;
export type TPlotQueue = {
    id: str;
    queue: str;
    size: int;
    parallel: bool;
    delay: int;
    state: str;
    error: Optional<str>;
    deleted: bool;
    log_new: str;
    log?: str;
};
export declare const register_service_command = "register_service";
export type register_service_command = typeof register_service_command;
export type TRegisterServiceRequest = {
    service: str;
};
export type TRegisterServiceResponse = {
    success: bool;
} | {
    success: bool;
    service: str;
    queue: TPlotQueue[];
};
export type WsRegisterServiceMessage = GetMessageType<daemon_service, register_service_command, TRegisterServiceResponse>;
export declare function register_service(daemon: TDaemon, data: TRegisterServiceRequest): Promise<WsRegisterServiceMessage>;
export declare const get_status_command = "get_status";
export type get_status_command = typeof get_status_command;
export type TGetStatusResponse = {
    success: True;
    genesis_initialized: True;
};
export type WsGetStatusMessage = GetMessageType<daemon_service, get_status_command, TGetStatusResponse>;
export declare function get_status(daemon: TDaemon): Promise<WsGetStatusMessage>;
export declare const get_version_command = "get_version";
export type get_version_command = typeof get_version_command;
export type TGetVersionResponse = {
    success: bool;
    version: string;
};
export type WsGetVersionMessage = GetMessageType<daemon_service, get_version_command, TGetVersionResponse>;
export declare function get_version(daemon: TDaemon): Promise<WsGetVersionMessage>;
export declare const get_plotters_command = "get_plotters";
export type get_plotters_command = typeof get_plotters_command;
export type TGetPlottersResponse = {
    success: True;
    plotters: {
        chiapos?: chiapos_install_info;
        bladebit?: bladebit_install_info;
        madmax?: madmax_install_info;
    };
};
export type WsGetPlottersMessage = GetMessageType<daemon_service, get_plotters_command, TGetPlottersResponse>;
export declare function get_plotters(daemon: TDaemon): Promise<WsGetPlottersMessage>;
export declare const get_routes_command = "get_routes";
export type get_routes_command = typeof get_routes_command;
export type TGetRoutesResponse = {
    success: True;
    routes: str[];
};
export type WsGetRoutesMessage = GetMessageType<daemon_service, get_routes_command, TGetRoutesResponse>;
export declare function get_routes(daemon: TDaemon): Promise<WsGetRoutesMessage>;
export declare const get_wallet_addresses_command = "get_wallet_addresses";
export type get_wallet_addresses_command = typeof get_wallet_addresses_command;
export type TGetWalletAddressesRequest = {
    fingerprints?: uint32[];
    index?: int;
    count?: int;
    non_observer_derivation?: bool;
};
export type TGetWalletAddressesResponse = {
    success: False;
    error: str;
} | {
    success: True;
    wallet_addresses: Record<str, Array<{
        address: str;
        hd_path: str;
    }>>;
};
export type WsGetWalletAddressesMessage = GetMessageType<daemon_service, get_wallet_addresses_command, TGetWalletAddressesResponse>;
export declare function get_wallet_addresses(daemon: TDaemon, data: TGetWalletAddressesRequest): Promise<WsGetWalletAddressesMessage>;
export declare const get_keys_for_plotting_command = "get_keys_for_plotting";
export type get_keys_for_plotting_command = typeof get_keys_for_plotting_command;
export type TGetKeysForPlottingRequest = {
    fingerprints?: uint32[];
};
export type TGetKeysForPlottingResponse = {
    success: False;
    error: str;
} | {
    success: True;
    keys: Record<str, {
        farmer_public_key: str;
        pool_public_key: str;
    }>;
};
export type WsGetKeysForPlottingMessage = GetMessageType<daemon_service, get_keys_for_plotting_command, TGetKeysForPlottingResponse>;
export declare function get_keys_for_plotting(daemon: TDaemon, data: TGetKeysForPlottingRequest): Promise<WsGetKeysForPlottingMessage>;
export declare const get_network_info_command = "get_network_info";
export type get_network_info_command = typeof get_network_info_command;
export type TGetNetworkInfoResponse = {
    success: True;
    network_name: str;
    network_prefix: str;
};
export type WsGetNetworkInfoMessage = GetMessageType<daemon_service, get_network_info_command, TGetNetworkInfoResponse>;
export declare function get_network_info(daemon: TDaemon): Promise<WsGetNetworkInfoMessage>;
export declare const keyring_status_changed_command = "keyring_status_changed";
export type keyring_status_changed_command = typeof keyring_status_changed_command;
export type TKeyringStatusChangedBroadCast = {
    keyring_status_changed: TKeyringStatusResponse;
};
export type WsKeyringStatusChangedMessage = GetMessageType<daemon_service, keyring_status_changed_command, TKeyringStatusChangedBroadCast>;
export declare function on_keyring_status_changed(daemon: TDaemon, callback: (e: WsKeyringStatusChangedMessage) => unknown): Promise<() => void>;
export type WsDaemonMessage = WsExitMessage | WsGetStatusMessage | WsGetVersionMessage | WsGetPlottersMessage | WsRunningServicesMessage | WsIsRunningMessage | WsPingMessage | WsRegisterServiceMessage | WsStartPlottingMessage | WsStartServiceMessage | WsStopPlottingMessage | WsStopServiceMessage | WsAddPrivateKeyMessage | WsAddKeyMessage | WsCheckKeysMessage | WsDeleteAllKeysMessage | WsDeleteKeyByFingerprintMessage | WsGetAllPrivateKeysMessage | WsGetFirstPrivateKeyMessage | WsGetKeyForFingerprintMessage | WsGetKeyMessage | WsGetKeysMessage | WsGetPublicKeyMessage | WsGetPublicKeysMessage | WsSetLabelMessage | WsDeleteLabelMessage | WsIsKeyringLockedMessage | WsKeyringStateMessage | WsUnlockKeyringMessage | WsValidateKeyringPassphraseMessage | WsMigrateKeyringMessage | WsSetKeyringPassphraseMessage | WsRemoveKeyringPassphraseMessage | WsNotifyKeyringMigrationCompletedMessage | WsGetRoutesMessage | WsGetWalletAddressesMessage | WsGetKeysForPlottingMessage | WsGetNetworkInfoMessage | WsKeyringStatusChangedMessage;