// package: emerald
// file: blockchain.proto

/* tslint:disable */
/* eslint-disable */

import * as jspb from "google-protobuf";
import * as common_pb from "./common_pb";

export class NativeCallRequest extends jspb.Message { 
    getChain(): common_pb.ChainRef;
    setChain(value: common_pb.ChainRef): NativeCallRequest;
    clearItemsList(): void;
    getItemsList(): Array<NativeCallItem>;
    setItemsList(value: Array<NativeCallItem>): NativeCallRequest;
    addItems(value?: NativeCallItem, index?: number): NativeCallItem;

    hasSelector(): boolean;
    clearSelector(): void;
    getSelector(): Selector | undefined;
    setSelector(value?: Selector): NativeCallRequest;
    getQuorum(): number;
    setQuorum(value: number): NativeCallRequest;
    getMinAvailability(): AvailabilityEnum;
    setMinAvailability(value: AvailabilityEnum): NativeCallRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NativeCallRequest.AsObject;
    static toObject(includeInstance: boolean, msg: NativeCallRequest): NativeCallRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NativeCallRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NativeCallRequest;
    static deserializeBinaryFromReader(message: NativeCallRequest, reader: jspb.BinaryReader): NativeCallRequest;
}

export namespace NativeCallRequest {
    export type AsObject = {
        chain: common_pb.ChainRef,
        itemsList: Array<NativeCallItem.AsObject>,
        selector?: Selector.AsObject,
        quorum: number,
        minAvailability: AvailabilityEnum,
    }
}

export class NativeCallItem extends jspb.Message { 
    getId(): number;
    setId(value: number): NativeCallItem;
    getMethod(): string;
    setMethod(value: string): NativeCallItem;
    getPayload(): Uint8Array | string;
    getPayload_asU8(): Uint8Array;
    getPayload_asB64(): string;
    setPayload(value: Uint8Array | string): NativeCallItem;
    getNonce(): number;
    setNonce(value: number): NativeCallItem;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NativeCallItem.AsObject;
    static toObject(includeInstance: boolean, msg: NativeCallItem): NativeCallItem.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NativeCallItem, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NativeCallItem;
    static deserializeBinaryFromReader(message: NativeCallItem, reader: jspb.BinaryReader): NativeCallItem;
}

export namespace NativeCallItem {
    export type AsObject = {
        id: number,
        method: string,
        payload: Uint8Array | string,
        nonce: number,
    }
}

export class NativeCallReplySignature extends jspb.Message { 
    getNonce(): number;
    setNonce(value: number): NativeCallReplySignature;
    getSignature(): Uint8Array | string;
    getSignature_asU8(): Uint8Array;
    getSignature_asB64(): string;
    setSignature(value: Uint8Array | string): NativeCallReplySignature;
    getKeyId(): number;
    setKeyId(value: number): NativeCallReplySignature;
    getUpstreamId(): string;
    setUpstreamId(value: string): NativeCallReplySignature;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NativeCallReplySignature.AsObject;
    static toObject(includeInstance: boolean, msg: NativeCallReplySignature): NativeCallReplySignature.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NativeCallReplySignature, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NativeCallReplySignature;
    static deserializeBinaryFromReader(message: NativeCallReplySignature, reader: jspb.BinaryReader): NativeCallReplySignature;
}

export namespace NativeCallReplySignature {
    export type AsObject = {
        nonce: number,
        signature: Uint8Array | string,
        keyId: number,
        upstreamId: string,
    }
}

export class NativeCallReplyItem extends jspb.Message { 
    getId(): number;
    setId(value: number): NativeCallReplyItem;
    getSucceed(): boolean;
    setSucceed(value: boolean): NativeCallReplyItem;
    getPayload(): Uint8Array | string;
    getPayload_asU8(): Uint8Array;
    getPayload_asB64(): string;
    setPayload(value: Uint8Array | string): NativeCallReplyItem;
    getErrormessage(): string;
    setErrormessage(value: string): NativeCallReplyItem;

    hasSignature(): boolean;
    clearSignature(): void;
    getSignature(): NativeCallReplySignature | undefined;
    setSignature(value?: NativeCallReplySignature): NativeCallReplyItem;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NativeCallReplyItem.AsObject;
    static toObject(includeInstance: boolean, msg: NativeCallReplyItem): NativeCallReplyItem.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NativeCallReplyItem, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NativeCallReplyItem;
    static deserializeBinaryFromReader(message: NativeCallReplyItem, reader: jspb.BinaryReader): NativeCallReplyItem;
}

export namespace NativeCallReplyItem {
    export type AsObject = {
        id: number,
        succeed: boolean,
        payload: Uint8Array | string,
        errormessage: string,
        signature?: NativeCallReplySignature.AsObject,
    }
}

export class NativeSubscribeRequest extends jspb.Message { 
    getChain(): common_pb.ChainRef;
    setChain(value: common_pb.ChainRef): NativeSubscribeRequest;
    getMethod(): string;
    setMethod(value: string): NativeSubscribeRequest;
    getPayload(): Uint8Array | string;
    getPayload_asU8(): Uint8Array;
    getPayload_asB64(): string;
    setPayload(value: Uint8Array | string): NativeSubscribeRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NativeSubscribeRequest.AsObject;
    static toObject(includeInstance: boolean, msg: NativeSubscribeRequest): NativeSubscribeRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NativeSubscribeRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NativeSubscribeRequest;
    static deserializeBinaryFromReader(message: NativeSubscribeRequest, reader: jspb.BinaryReader): NativeSubscribeRequest;
}

export namespace NativeSubscribeRequest {
    export type AsObject = {
        chain: common_pb.ChainRef,
        method: string,
        payload: Uint8Array | string,
    }
}

export class NativeSubscribeReplyItem extends jspb.Message { 
    getPayload(): Uint8Array | string;
    getPayload_asU8(): Uint8Array;
    getPayload_asB64(): string;
    setPayload(value: Uint8Array | string): NativeSubscribeReplyItem;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NativeSubscribeReplyItem.AsObject;
    static toObject(includeInstance: boolean, msg: NativeSubscribeReplyItem): NativeSubscribeReplyItem.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NativeSubscribeReplyItem, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NativeSubscribeReplyItem;
    static deserializeBinaryFromReader(message: NativeSubscribeReplyItem, reader: jspb.BinaryReader): NativeSubscribeReplyItem;
}

export namespace NativeSubscribeReplyItem {
    export type AsObject = {
        payload: Uint8Array | string,
    }
}

export class ChainHead extends jspb.Message { 
    getChain(): common_pb.ChainRef;
    setChain(value: common_pb.ChainRef): ChainHead;
    getHeight(): number;
    setHeight(value: number): ChainHead;
    getBlockId(): string;
    setBlockId(value: string): ChainHead;
    getTimestamp(): number;
    setTimestamp(value: number): ChainHead;
    getWeight(): Uint8Array | string;
    getWeight_asU8(): Uint8Array;
    getWeight_asB64(): string;
    setWeight(value: Uint8Array | string): ChainHead;
    getReorg(): number;
    setReorg(value: number): ChainHead;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ChainHead.AsObject;
    static toObject(includeInstance: boolean, msg: ChainHead): ChainHead.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ChainHead, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ChainHead;
    static deserializeBinaryFromReader(message: ChainHead, reader: jspb.BinaryReader): ChainHead;
}

export namespace ChainHead {
    export type AsObject = {
        chain: common_pb.ChainRef,
        height: number,
        blockId: string,
        timestamp: number,
        weight: Uint8Array | string,
        reorg: number,
    }
}

export class TxStatusRequest extends jspb.Message { 
    getChain(): common_pb.ChainRef;
    setChain(value: common_pb.ChainRef): TxStatusRequest;
    getTxId(): string;
    setTxId(value: string): TxStatusRequest;
    getConfirmationLimit(): number;
    setConfirmationLimit(value: number): TxStatusRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): TxStatusRequest.AsObject;
    static toObject(includeInstance: boolean, msg: TxStatusRequest): TxStatusRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: TxStatusRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): TxStatusRequest;
    static deserializeBinaryFromReader(message: TxStatusRequest, reader: jspb.BinaryReader): TxStatusRequest;
}

export namespace TxStatusRequest {
    export type AsObject = {
        chain: common_pb.ChainRef,
        txId: string,
        confirmationLimit: number,
    }
}

export class TxStatus extends jspb.Message { 
    getTxId(): string;
    setTxId(value: string): TxStatus;
    getBroadcasted(): boolean;
    setBroadcasted(value: boolean): TxStatus;
    getMined(): boolean;
    setMined(value: boolean): TxStatus;

    hasBlock(): boolean;
    clearBlock(): void;
    getBlock(): common_pb.BlockInfo | undefined;
    setBlock(value?: common_pb.BlockInfo): TxStatus;
    getConfirmations(): number;
    setConfirmations(value: number): TxStatus;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): TxStatus.AsObject;
    static toObject(includeInstance: boolean, msg: TxStatus): TxStatus.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: TxStatus, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): TxStatus;
    static deserializeBinaryFromReader(message: TxStatus, reader: jspb.BinaryReader): TxStatus;
}

export namespace TxStatus {
    export type AsObject = {
        txId: string,
        broadcasted: boolean,
        mined: boolean,
        block?: common_pb.BlockInfo.AsObject,
        confirmations: number,
    }
}

export class BalanceRequest extends jspb.Message { 

    hasAsset(): boolean;
    clearAsset(): void;
    getAsset(): common_pb.Asset | undefined;
    setAsset(value?: common_pb.Asset): BalanceRequest;

    hasErc20Asset(): boolean;
    clearErc20Asset(): void;
    getErc20Asset(): common_pb.Erc20Asset | undefined;
    setErc20Asset(value?: common_pb.Erc20Asset): BalanceRequest;

    hasAddress(): boolean;
    clearAddress(): void;
    getAddress(): common_pb.AnyAddress | undefined;
    setAddress(value?: common_pb.AnyAddress): BalanceRequest;
    getIncludeUtxo(): boolean;
    setIncludeUtxo(value: boolean): BalanceRequest;

    getBalanceTypeCase(): BalanceRequest.BalanceTypeCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): BalanceRequest.AsObject;
    static toObject(includeInstance: boolean, msg: BalanceRequest): BalanceRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: BalanceRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): BalanceRequest;
    static deserializeBinaryFromReader(message: BalanceRequest, reader: jspb.BinaryReader): BalanceRequest;
}

export namespace BalanceRequest {
    export type AsObject = {
        asset?: common_pb.Asset.AsObject,
        erc20Asset?: common_pb.Erc20Asset.AsObject,
        address?: common_pb.AnyAddress.AsObject,
        includeUtxo: boolean,
    }

    export enum BalanceTypeCase {
        BALANCE_TYPE_NOT_SET = 0,
        ASSET = 1,
        ERC20_ASSET = 4,
    }

}

export class AddressBalance extends jspb.Message { 

    hasAsset(): boolean;
    clearAsset(): void;
    getAsset(): common_pb.Asset | undefined;
    setAsset(value?: common_pb.Asset): AddressBalance;

    hasErc20Asset(): boolean;
    clearErc20Asset(): void;
    getErc20Asset(): common_pb.Erc20Asset | undefined;
    setErc20Asset(value?: common_pb.Erc20Asset): AddressBalance;

    hasAddress(): boolean;
    clearAddress(): void;
    getAddress(): common_pb.SingleAddress | undefined;
    setAddress(value?: common_pb.SingleAddress): AddressBalance;
    getBalance(): string;
    setBalance(value: string): AddressBalance;
    getConfirmed(): boolean;
    setConfirmed(value: boolean): AddressBalance;
    clearUtxoList(): void;
    getUtxoList(): Array<Utxo>;
    setUtxoList(value: Array<Utxo>): AddressBalance;
    addUtxo(value?: Utxo, index?: number): Utxo;

    getBalanceTypeCase(): AddressBalance.BalanceTypeCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AddressBalance.AsObject;
    static toObject(includeInstance: boolean, msg: AddressBalance): AddressBalance.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AddressBalance, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AddressBalance;
    static deserializeBinaryFromReader(message: AddressBalance, reader: jspb.BinaryReader): AddressBalance;
}

export namespace AddressBalance {
    export type AsObject = {
        asset?: common_pb.Asset.AsObject,
        erc20Asset?: common_pb.Erc20Asset.AsObject,
        address?: common_pb.SingleAddress.AsObject,
        balance: string,
        confirmed: boolean,
        utxoList: Array<Utxo.AsObject>,
    }

    export enum BalanceTypeCase {
        BALANCE_TYPE_NOT_SET = 0,
        ASSET = 1,
        ERC20_ASSET = 6,
    }

}

export class AddressAllowanceRequest extends jspb.Message { 
    getChain(): common_pb.ChainRef;
    setChain(value: common_pb.ChainRef): AddressAllowanceRequest;

    hasAddress(): boolean;
    clearAddress(): void;
    getAddress(): common_pb.AnyAddress | undefined;
    setAddress(value?: common_pb.AnyAddress): AddressAllowanceRequest;
    clearContractAddressesList(): void;
    getContractAddressesList(): Array<common_pb.SingleAddress>;
    setContractAddressesList(value: Array<common_pb.SingleAddress>): AddressAllowanceRequest;
    addContractAddresses(value?: common_pb.SingleAddress, index?: number): common_pb.SingleAddress;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AddressAllowanceRequest.AsObject;
    static toObject(includeInstance: boolean, msg: AddressAllowanceRequest): AddressAllowanceRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AddressAllowanceRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AddressAllowanceRequest;
    static deserializeBinaryFromReader(message: AddressAllowanceRequest, reader: jspb.BinaryReader): AddressAllowanceRequest;
}

export namespace AddressAllowanceRequest {
    export type AsObject = {
        chain: common_pb.ChainRef,
        address?: common_pb.AnyAddress.AsObject,
        contractAddressesList: Array<common_pb.SingleAddress.AsObject>,
    }
}

export class AddressAllowance extends jspb.Message { 
    getChain(): common_pb.ChainRef;
    setChain(value: common_pb.ChainRef): AddressAllowance;

    hasAddress(): boolean;
    clearAddress(): void;
    getAddress(): common_pb.SingleAddress | undefined;
    setAddress(value?: common_pb.SingleAddress): AddressAllowance;

    hasContractAddress(): boolean;
    clearContractAddress(): void;
    getContractAddress(): common_pb.SingleAddress | undefined;
    setContractAddress(value?: common_pb.SingleAddress): AddressAllowance;

    hasOwnerAddress(): boolean;
    clearOwnerAddress(): void;
    getOwnerAddress(): common_pb.SingleAddress | undefined;
    setOwnerAddress(value?: common_pb.SingleAddress): AddressAllowance;

    hasSpenderAddress(): boolean;
    clearSpenderAddress(): void;
    getSpenderAddress(): common_pb.SingleAddress | undefined;
    setSpenderAddress(value?: common_pb.SingleAddress): AddressAllowance;
    getAllowance(): string;
    setAllowance(value: string): AddressAllowance;
    getAvailable(): string;
    setAvailable(value: string): AddressAllowance;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AddressAllowance.AsObject;
    static toObject(includeInstance: boolean, msg: AddressAllowance): AddressAllowance.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AddressAllowance, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AddressAllowance;
    static deserializeBinaryFromReader(message: AddressAllowance, reader: jspb.BinaryReader): AddressAllowance;
}

export namespace AddressAllowance {
    export type AsObject = {
        chain: common_pb.ChainRef,
        address?: common_pb.SingleAddress.AsObject,
        contractAddress?: common_pb.SingleAddress.AsObject,
        ownerAddress?: common_pb.SingleAddress.AsObject,
        spenderAddress?: common_pb.SingleAddress.AsObject,
        allowance: string,
        available: string,
    }
}

export class Utxo extends jspb.Message { 
    getTxId(): string;
    setTxId(value: string): Utxo;
    getIndex(): number;
    setIndex(value: number): Utxo;
    getBalance(): string;
    setBalance(value: string): Utxo;
    getSpent(): boolean;
    setSpent(value: boolean): Utxo;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Utxo.AsObject;
    static toObject(includeInstance: boolean, msg: Utxo): Utxo.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Utxo, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Utxo;
    static deserializeBinaryFromReader(message: Utxo, reader: jspb.BinaryReader): Utxo;
}

export namespace Utxo {
    export type AsObject = {
        txId: string,
        index: number,
        balance: string,
        spent: boolean,
    }
}

export class DescribeRequest extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): DescribeRequest.AsObject;
    static toObject(includeInstance: boolean, msg: DescribeRequest): DescribeRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: DescribeRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): DescribeRequest;
    static deserializeBinaryFromReader(message: DescribeRequest, reader: jspb.BinaryReader): DescribeRequest;
}

export namespace DescribeRequest {
    export type AsObject = {
    }
}

export class DescribeResponse extends jspb.Message { 
    clearChainsList(): void;
    getChainsList(): Array<DescribeChain>;
    setChainsList(value: Array<DescribeChain>): DescribeResponse;
    addChains(value?: DescribeChain, index?: number): DescribeChain;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): DescribeResponse.AsObject;
    static toObject(includeInstance: boolean, msg: DescribeResponse): DescribeResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: DescribeResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): DescribeResponse;
    static deserializeBinaryFromReader(message: DescribeResponse, reader: jspb.BinaryReader): DescribeResponse;
}

export namespace DescribeResponse {
    export type AsObject = {
        chainsList: Array<DescribeChain.AsObject>,
    }
}

export class DescribeChain extends jspb.Message { 
    getChain(): common_pb.ChainRef;
    setChain(value: common_pb.ChainRef): DescribeChain;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): ChainStatus | undefined;
    setStatus(value?: ChainStatus): DescribeChain;
    clearNodesList(): void;
    getNodesList(): Array<NodeDetails>;
    setNodesList(value: Array<NodeDetails>): DescribeChain;
    addNodes(value?: NodeDetails, index?: number): NodeDetails;
    clearSupportedmethodsList(): void;
    getSupportedmethodsList(): Array<string>;
    setSupportedmethodsList(value: Array<string>): DescribeChain;
    addSupportedmethods(value: string, index?: number): string;
    clearExcludedmethodsList(): void;
    getExcludedmethodsList(): Array<string>;
    setExcludedmethodsList(value: Array<string>): DescribeChain;
    addExcludedmethods(value: string, index?: number): string;
    clearCapabilitiesList(): void;
    getCapabilitiesList(): Array<Capabilities>;
    setCapabilitiesList(value: Array<Capabilities>): DescribeChain;
    addCapabilities(value: Capabilities, index?: number): Capabilities;
    clearSupportedsubscriptionsList(): void;
    getSupportedsubscriptionsList(): Array<string>;
    setSupportedsubscriptionsList(value: Array<string>): DescribeChain;
    addSupportedsubscriptions(value: string, index?: number): string;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): DescribeChain.AsObject;
    static toObject(includeInstance: boolean, msg: DescribeChain): DescribeChain.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: DescribeChain, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): DescribeChain;
    static deserializeBinaryFromReader(message: DescribeChain, reader: jspb.BinaryReader): DescribeChain;
}

export namespace DescribeChain {
    export type AsObject = {
        chain: common_pb.ChainRef,
        status?: ChainStatus.AsObject,
        nodesList: Array<NodeDetails.AsObject>,
        supportedmethodsList: Array<string>,
        excludedmethodsList: Array<string>,
        capabilitiesList: Array<Capabilities>,
        supportedsubscriptionsList: Array<string>,
    }
}

export class StatusRequest extends jspb.Message { 
    clearChainsList(): void;
    getChainsList(): Array<common_pb.ChainRef>;
    setChainsList(value: Array<common_pb.ChainRef>): StatusRequest;
    addChains(value: common_pb.ChainRef, index?: number): common_pb.ChainRef;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): StatusRequest.AsObject;
    static toObject(includeInstance: boolean, msg: StatusRequest): StatusRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: StatusRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): StatusRequest;
    static deserializeBinaryFromReader(message: StatusRequest, reader: jspb.BinaryReader): StatusRequest;
}

export namespace StatusRequest {
    export type AsObject = {
        chainsList: Array<common_pb.ChainRef>,
    }
}

export class ChainStatus extends jspb.Message { 
    getChain(): common_pb.ChainRef;
    setChain(value: common_pb.ChainRef): ChainStatus;
    getAvailability(): AvailabilityEnum;
    setAvailability(value: AvailabilityEnum): ChainStatus;
    getQuorum(): number;
    setQuorum(value: number): ChainStatus;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ChainStatus.AsObject;
    static toObject(includeInstance: boolean, msg: ChainStatus): ChainStatus.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ChainStatus, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ChainStatus;
    static deserializeBinaryFromReader(message: ChainStatus, reader: jspb.BinaryReader): ChainStatus;
}

export namespace ChainStatus {
    export type AsObject = {
        chain: common_pb.ChainRef,
        availability: AvailabilityEnum,
        quorum: number,
    }
}

export class NodeDetails extends jspb.Message { 
    getQuorum(): number;
    setQuorum(value: number): NodeDetails;
    clearLabelsList(): void;
    getLabelsList(): Array<Label>;
    setLabelsList(value: Array<Label>): NodeDetails;
    addLabels(value?: Label, index?: number): Label;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NodeDetails.AsObject;
    static toObject(includeInstance: boolean, msg: NodeDetails): NodeDetails.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NodeDetails, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NodeDetails;
    static deserializeBinaryFromReader(message: NodeDetails, reader: jspb.BinaryReader): NodeDetails;
}

export namespace NodeDetails {
    export type AsObject = {
        quorum: number,
        labelsList: Array<Label.AsObject>,
    }
}

export class Label extends jspb.Message { 
    getName(): string;
    setName(value: string): Label;
    getValue(): string;
    setValue(value: string): Label;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Label.AsObject;
    static toObject(includeInstance: boolean, msg: Label): Label.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Label, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Label;
    static deserializeBinaryFromReader(message: Label, reader: jspb.BinaryReader): Label;
}

export namespace Label {
    export type AsObject = {
        name: string,
        value: string,
    }
}

export class Selector extends jspb.Message { 

    hasLabelselector(): boolean;
    clearLabelselector(): void;
    getLabelselector(): LabelSelector | undefined;
    setLabelselector(value?: LabelSelector): Selector;

    hasOrselector(): boolean;
    clearOrselector(): void;
    getOrselector(): OrSelector | undefined;
    setOrselector(value?: OrSelector): Selector;

    hasAndselector(): boolean;
    clearAndselector(): void;
    getAndselector(): AndSelector | undefined;
    setAndselector(value?: AndSelector): Selector;

    hasNotselector(): boolean;
    clearNotselector(): void;
    getNotselector(): NotSelector | undefined;
    setNotselector(value?: NotSelector): Selector;

    hasExistsselector(): boolean;
    clearExistsselector(): void;
    getExistsselector(): ExistsSelector | undefined;
    setExistsselector(value?: ExistsSelector): Selector;

    getSelectorTypeCase(): Selector.SelectorTypeCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Selector.AsObject;
    static toObject(includeInstance: boolean, msg: Selector): Selector.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Selector, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Selector;
    static deserializeBinaryFromReader(message: Selector, reader: jspb.BinaryReader): Selector;
}

export namespace Selector {
    export type AsObject = {
        labelselector?: LabelSelector.AsObject,
        orselector?: OrSelector.AsObject,
        andselector?: AndSelector.AsObject,
        notselector?: NotSelector.AsObject,
        existsselector?: ExistsSelector.AsObject,
    }

    export enum SelectorTypeCase {
        SELECTOR_TYPE_NOT_SET = 0,
        LABELSELECTOR = 1,
        ORSELECTOR = 2,
        ANDSELECTOR = 3,
        NOTSELECTOR = 4,
        EXISTSSELECTOR = 5,
    }

}

export class LabelSelector extends jspb.Message { 
    getName(): string;
    setName(value: string): LabelSelector;
    clearValueList(): void;
    getValueList(): Array<string>;
    setValueList(value: Array<string>): LabelSelector;
    addValue(value: string, index?: number): string;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): LabelSelector.AsObject;
    static toObject(includeInstance: boolean, msg: LabelSelector): LabelSelector.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: LabelSelector, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): LabelSelector;
    static deserializeBinaryFromReader(message: LabelSelector, reader: jspb.BinaryReader): LabelSelector;
}

export namespace LabelSelector {
    export type AsObject = {
        name: string,
        valueList: Array<string>,
    }
}

export class OrSelector extends jspb.Message { 
    clearSelectorsList(): void;
    getSelectorsList(): Array<Selector>;
    setSelectorsList(value: Array<Selector>): OrSelector;
    addSelectors(value?: Selector, index?: number): Selector;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): OrSelector.AsObject;
    static toObject(includeInstance: boolean, msg: OrSelector): OrSelector.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: OrSelector, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): OrSelector;
    static deserializeBinaryFromReader(message: OrSelector, reader: jspb.BinaryReader): OrSelector;
}

export namespace OrSelector {
    export type AsObject = {
        selectorsList: Array<Selector.AsObject>,
    }
}

export class AndSelector extends jspb.Message { 
    clearSelectorsList(): void;
    getSelectorsList(): Array<Selector>;
    setSelectorsList(value: Array<Selector>): AndSelector;
    addSelectors(value?: Selector, index?: number): Selector;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AndSelector.AsObject;
    static toObject(includeInstance: boolean, msg: AndSelector): AndSelector.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AndSelector, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AndSelector;
    static deserializeBinaryFromReader(message: AndSelector, reader: jspb.BinaryReader): AndSelector;
}

export namespace AndSelector {
    export type AsObject = {
        selectorsList: Array<Selector.AsObject>,
    }
}

export class NotSelector extends jspb.Message { 

    hasSelector(): boolean;
    clearSelector(): void;
    getSelector(): Selector | undefined;
    setSelector(value?: Selector): NotSelector;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NotSelector.AsObject;
    static toObject(includeInstance: boolean, msg: NotSelector): NotSelector.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NotSelector, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NotSelector;
    static deserializeBinaryFromReader(message: NotSelector, reader: jspb.BinaryReader): NotSelector;
}

export namespace NotSelector {
    export type AsObject = {
        selector?: Selector.AsObject,
    }
}

export class ExistsSelector extends jspb.Message { 
    getName(): string;
    setName(value: string): ExistsSelector;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ExistsSelector.AsObject;
    static toObject(includeInstance: boolean, msg: ExistsSelector): ExistsSelector.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ExistsSelector, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ExistsSelector;
    static deserializeBinaryFromReader(message: ExistsSelector, reader: jspb.BinaryReader): ExistsSelector;
}

export namespace ExistsSelector {
    export type AsObject = {
        name: string,
    }
}

export class EstimateFeeRequest extends jspb.Message { 
    getChain(): common_pb.ChainRef;
    setChain(value: common_pb.ChainRef): EstimateFeeRequest;
    getMode(): FeeEstimationMode;
    setMode(value: FeeEstimationMode): EstimateFeeRequest;
    getBlocks(): number;
    setBlocks(value: number): EstimateFeeRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): EstimateFeeRequest.AsObject;
    static toObject(includeInstance: boolean, msg: EstimateFeeRequest): EstimateFeeRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: EstimateFeeRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): EstimateFeeRequest;
    static deserializeBinaryFromReader(message: EstimateFeeRequest, reader: jspb.BinaryReader): EstimateFeeRequest;
}

export namespace EstimateFeeRequest {
    export type AsObject = {
        chain: common_pb.ChainRef,
        mode: FeeEstimationMode,
        blocks: number,
    }
}

export class EstimateFeeResponse extends jspb.Message { 

    hasEthereumstd(): boolean;
    clearEthereumstd(): void;
    getEthereumstd(): EthereumStdFees | undefined;
    setEthereumstd(value?: EthereumStdFees): EstimateFeeResponse;

    hasEthereumextended(): boolean;
    clearEthereumextended(): void;
    getEthereumextended(): EthereumExtFees | undefined;
    setEthereumextended(value?: EthereumExtFees): EstimateFeeResponse;

    hasBitcoinstd(): boolean;
    clearBitcoinstd(): void;
    getBitcoinstd(): BitcoinStdFees | undefined;
    setBitcoinstd(value?: BitcoinStdFees): EstimateFeeResponse;

    getFeeTypeCase(): EstimateFeeResponse.FeeTypeCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): EstimateFeeResponse.AsObject;
    static toObject(includeInstance: boolean, msg: EstimateFeeResponse): EstimateFeeResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: EstimateFeeResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): EstimateFeeResponse;
    static deserializeBinaryFromReader(message: EstimateFeeResponse, reader: jspb.BinaryReader): EstimateFeeResponse;
}

export namespace EstimateFeeResponse {
    export type AsObject = {
        ethereumstd?: EthereumStdFees.AsObject,
        ethereumextended?: EthereumExtFees.AsObject,
        bitcoinstd?: BitcoinStdFees.AsObject,
    }

    export enum FeeTypeCase {
        FEE_TYPE_NOT_SET = 0,
        ETHEREUMSTD = 1,
        ETHEREUMEXTENDED = 2,
        BITCOINSTD = 3,
    }

}

export class EthereumStdFees extends jspb.Message { 
    getFee(): string;
    setFee(value: string): EthereumStdFees;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): EthereumStdFees.AsObject;
    static toObject(includeInstance: boolean, msg: EthereumStdFees): EthereumStdFees.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: EthereumStdFees, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): EthereumStdFees;
    static deserializeBinaryFromReader(message: EthereumStdFees, reader: jspb.BinaryReader): EthereumStdFees;
}

export namespace EthereumStdFees {
    export type AsObject = {
        fee: string,
    }
}

export class EthereumExtFees extends jspb.Message { 
    getExpect(): string;
    setExpect(value: string): EthereumExtFees;
    getPriority(): string;
    setPriority(value: string): EthereumExtFees;
    getMax(): string;
    setMax(value: string): EthereumExtFees;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): EthereumExtFees.AsObject;
    static toObject(includeInstance: boolean, msg: EthereumExtFees): EthereumExtFees.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: EthereumExtFees, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): EthereumExtFees;
    static deserializeBinaryFromReader(message: EthereumExtFees, reader: jspb.BinaryReader): EthereumExtFees;
}

export namespace EthereumExtFees {
    export type AsObject = {
        expect: string,
        priority: string,
        max: string,
    }
}

export class BitcoinStdFees extends jspb.Message { 
    getSatperkb(): number;
    setSatperkb(value: number): BitcoinStdFees;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): BitcoinStdFees.AsObject;
    static toObject(includeInstance: boolean, msg: BitcoinStdFees): BitcoinStdFees.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: BitcoinStdFees, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): BitcoinStdFees;
    static deserializeBinaryFromReader(message: BitcoinStdFees, reader: jspb.BinaryReader): BitcoinStdFees;
}

export namespace BitcoinStdFees {
    export type AsObject = {
        satperkb: number,
    }
}

export enum AvailabilityEnum {
    AVAIL_UNKNOWN = 0,
    AVAIL_OK = 1,
    AVAIL_LAGGING = 2,
    AVAIL_IMMATURE = 3,
    AVAIL_SYNCING = 4,
    AVAIL_UNAVAILABLE = 5,
}

export enum Capabilities {
    CAP_NONE = 0,
    CAP_CALLS = 1,
    CAP_BALANCE = 2,
    CAP_ALLOWANCE = 3,
}

export enum FeeEstimationMode {
    INVALID = 0,
    AVG_LAST = 1,
    AVG_T5 = 2,
    AVG_T20 = 3,
    AVG_T50 = 4,
    MIN_ALWAYS = 5,
    AVG_MIDDLE = 6,
    AVG_TOP = 7,
}