Interface EntryTreesPoi

interface EntryTreesPoi {
    deserialize: ((value) => TxUnpackedBySchema<{
        balance: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        nonce: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        tag: {
            constValue: Account;
            constValueOptional: boolean;
            deserialize: ((value) => Account);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value) => Buffer);
        };
    } | {
        balance: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        flags: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        gaAuthFun: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        gaContract: {
            deserialize: ((value) => `ct_${string}` | `nm_${string}`);
            serialize: ((value) => Buffer);
        };
        nonce: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        tag: {
            constValue: Account;
            constValueOptional: boolean;
            deserialize: ((value) => Account);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 2;
            constValueOptional: boolean;
            deserialize: ((value) => 2);
            serialize: ((value?) => Buffer);
        };
    } | {
        encodedTx: EntryAny;
        signatures: {
            deserialize: ((value, params) => Buffer[]);
            serialize: ((value, params) => Buffer[]);
        };
        tag: {
            constValue: SignedTx;
            constValueOptional: boolean;
            deserialize: ((value) => SignedTx);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        amount: {
            deserialize(value): string;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value, params, options): string;
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        payload: {
            deserialize: ((value) => `ba_${string}`);
            serialize: ((value?) => Buffer);
        };
        recipientId: {
            deserialize: ((value) => `ct_${string}` | `ak_${string}` | `nm_${string}`);
            serialize: ((value) => Buffer);
        };
        senderId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: SpendTx;
            constValueOptional: boolean;
            deserialize: ((value) => SpendTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        accountId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        clientTtl: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        nameTtl: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        pointers: {
            deserialize(pointers): NamePointer[];
            serialize(pointers): Buffer[][];
        };
        status: {
            deserialize(buffer): Buffer;
            serialize(buffer): Buffer;
        };
        tag: {
            constValue: Name;
            constValueOptional: boolean;
            deserialize: ((value) => Name);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        accountId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        commitmentId: {
            deserialize: ((value) => `cm_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: NamePreclaimTx;
            constValueOptional: boolean;
            deserialize: ((value) => NamePreclaimTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        accountId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        name: {
            deserialize(value): `${string}.chain`;
            serialize(value): Buffer;
        };
        nameFee: {
            deserialize(value): string;
            serialize(value, txFields, parameters): Buffer;
            serializeAettos(_value, txFields): string;
        };
        nameSalt: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: NameClaimTx;
            constValueOptional: boolean;
            deserialize: ((value) => NameClaimTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 2;
            constValueOptional: boolean;
            deserialize: ((value) => 2);
            serialize: ((value?) => Buffer);
        };
    } | {
        accountId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        clientTtl: {
            deserialize: ((value, params) => number);
            serialize: ((value, params) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nameId: {
            deserialize: ((value) => `nm_${string}`);
            serialize(value): Buffer;
        };
        nameTtl: {
            deserialize: ((value) => number);
            serialize: ((value, params, options) => Buffer);
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        pointers: {
            deserialize(pointers): NamePointer[];
            serialize(pointers): Buffer[][];
        };
        tag: {
            constValue: NameUpdateTx;
            constValueOptional: boolean;
            deserialize: ((value) => NameUpdateTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        accountId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        clientTtl: {
            deserialize: ((value, params) => number);
            serialize: ((value, params) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nameId: {
            deserialize: ((value) => `nm_${string}`);
            serialize(value): Buffer;
        };
        nameTtl: {
            deserialize: ((value) => number);
            serialize: ((value, params, options) => Buffer);
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        pointers: {
            deserialize(pointers): NamePointer[];
            serialize(pointers): Buffer[][];
        };
        tag: {
            constValue: NameUpdateTx;
            constValueOptional: boolean;
            deserialize: ((value) => NameUpdateTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 2;
            constValueOptional: boolean;
            deserialize: ((value) => 2);
            serialize: ((value) => Buffer);
        };
    } | {
        accountId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nameId: {
            deserialize: ((value) => `nm_${string}`);
            serialize(value): Buffer;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        recipientId: {
            deserialize: ((value) => `ak_${string}` | `nm_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: NameTransferTx;
            constValueOptional: boolean;
            deserialize: ((value) => NameTransferTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        accountId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nameId: {
            deserialize: ((value) => `nm_${string}`);
            serialize(value): Buffer;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: NameRevokeTx;
            constValueOptional: boolean;
            deserialize: ((value) => NameRevokeTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        active: {
            deserialize(buffer): boolean;
            serialize(value): Buffer;
        };
        code: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        ctVersion: {
            deserialize(buffer): CtVersion;
            prepare(value, params, options): Promise<undefined | CtVersion>;
            serialize(value, params, __namedParameters): Buffer;
        };
        deposit: {
            deserialize(value): string;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value, params, options): string;
        };
        log: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        owner: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        referers: {
            deserialize: ((value, params) => `ak_${string}`[]);
            serialize: ((value, params) => Buffer[]);
        };
        tag: {
            constValue: Contract;
            constValueOptional: boolean;
            deserialize: ((value) => Contract);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        amount: {
            deserialize(value): string;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value, params, options): string;
        };
        callData: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        code: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        ctVersion: {
            deserialize(buffer): CtVersion;
            prepare(value, params, options): Promise<undefined | CtVersion>;
            serialize(value, params, __namedParameters): Buffer;
        };
        deposit: {
            deserialize: ((value) => string);
            serialize: ((value, params, options) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        gasLimit: {
            deserialize(value): number;
            serialize(_value, __namedParameters, __namedParameters): Buffer;
        };
        gasPrice: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value?): string;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        ownerId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ContractCreateTx;
            constValueOptional: boolean;
            deserialize: ((value) => ContractCreateTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        abiVersion: {
            _getProtocolDetails(c, tag): AbiVersion;
            deserialize(buffer): AbiVersion;
            prepare(value, __namedParameters, options): Promise<(AbiVersion | undefined)>;
            serialize(value, __namedParameters, __namedParameters): Buffer;
        };
        amount: {
            deserialize(value): string;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value, params, options): string;
        };
        callData: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        callerId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        contractId: {
            deserialize: ((value) => `ct_${string}` | `nm_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        gasLimit: {
            deserialize(value): number;
            serialize(_value, __namedParameters, __namedParameters): Buffer;
        };
        gasPrice: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value?): string;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ContractCallTx;
            constValueOptional: boolean;
            deserialize: ((value) => ContractCallTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        callerId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        callerNonce: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        contractId: {
            deserialize: ((value) => `ct_${string}`);
            serialize: ((value) => Buffer);
        };
        gasPrice: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        gasUsed: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        height: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        log: {
            deserialize: ((value, params) => Buffer[]);
            serialize: ((value, params) => Buffer[]);
        };
        returnType: {
            deserialize: ((value) => CallReturnType);
            serialize: ((value) => Buffer);
        };
        returnValue: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ContractCall;
            constValueOptional: boolean;
            deserialize: ((value) => ContractCall);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 2;
            constValueOptional: boolean;
            deserialize: ((value) => 2);
            serialize: ((value?) => Buffer);
        };
    } | {
        abiVersion: {
            _getProtocolDetails(c, tag): AbiVersion;
            deserialize(buffer): AbiVersion;
            prepare(value, __namedParameters, options): Promise<(AbiVersion | undefined)>;
            serialize(value, __namedParameters, __namedParameters): Buffer;
        };
        accountId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        oracleTtlValue: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        queryFee: {
            deserialize(value): string;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value, params, options): string;
        };
        queryFormat: {
            deserialize(buffer): string;
            serialize(string): Buffer;
        };
        responseFormat: {
            deserialize(buffer): string;
            serialize(string): Buffer;
        };
        tag: {
            constValue: Oracle;
            constValueOptional: boolean;
            deserialize: ((value) => Oracle);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        abiVersion: {
            _getProtocolDetails(c, tag): AbiVersion;
            deserialize(buffer): AbiVersion;
            prepare(value, __namedParameters, options): Promise<(AbiVersion | undefined)>;
            serialize(value, __namedParameters, __namedParameters): Buffer;
        };
        accountId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        oracleTtlType: {
            deserialize: ((value, params) => ORACLE_TTL_TYPES);
            serialize: ((value, params) => Buffer);
        };
        oracleTtlValue: {
            deserialize: ((value, params) => number);
            serialize: ((value, params) => Buffer);
        };
        queryFee: {
            deserialize(value): string;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value, params, options): string;
        };
        queryFormat: {
            deserialize(buffer): string;
            serialize(string): Buffer;
        };
        responseFormat: {
            deserialize(buffer): string;
            serialize(string): Buffer;
        };
        tag: {
            constValue: OracleRegisterTx;
            constValueOptional: boolean;
            deserialize: ((value) => OracleRegisterTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        oracleId: {
            deserialize: ((value) => `ok_${string}` | `nm_${string}`);
            serialize: ((value) => Buffer);
        };
        oracleTtlType: {
            deserialize: ((value, params) => ORACLE_TTL_TYPES);
            serialize: ((value, params) => Buffer);
        };
        oracleTtlValue: {
            deserialize: ((value, params) => number);
            serialize: ((value, params) => Buffer);
        };
        tag: {
            constValue: OracleExtendTx;
            constValueOptional: boolean;
            deserialize: ((value) => OracleExtendTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        oracleId: {
            deserialize: ((value) => `ok_${string}` | `nm_${string}`);
            serialize: ((value) => Buffer);
        };
        query: {
            deserialize(buffer): string;
            serialize(string): Buffer;
        };
        queryFee: {
            deserialize(value): string;
            prepare(value, params, options): Promise<Int>;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value, params, options): string;
        };
        queryTtlType: {
            deserialize: ((value, params) => ORACLE_TTL_TYPES);
            serialize: ((value, params) => Buffer);
        };
        queryTtlValue: {
            deserialize: ((value, params) => number);
            serialize: ((value, params) => Buffer);
        };
        responseTtlType: {
            deserialize: ((value, params) => ORACLE_TTL_TYPES);
            serialize: ((value, params) => Buffer);
        };
        responseTtlValue: {
            deserialize: ((value, params) => number);
            serialize: ((value, params) => Buffer);
        };
        senderId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: OracleQueryTx;
            constValueOptional: boolean;
            deserialize: ((value) => OracleQueryTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        oracleId: {
            deserialize: ((value) => `ok_${string}`);
            serialize: ((value) => Buffer);
        };
        queryId: {
            deserialize: ((value) => `oq_${string}`);
            serialize: ((value) => Buffer);
        };
        response: {
            deserialize(buffer): string;
            serialize(string): Buffer;
        };
        responseTtlType: {
            deserialize: ((value, params) => ORACLE_TTL_TYPES);
            serialize: ((value, params) => Buffer);
        };
        responseTtlValue: {
            deserialize: ((value, params) => number);
            serialize: ((value, params) => Buffer);
        };
        tag: {
            constValue: OracleResponseTx;
            constValueOptional: boolean;
            deserialize: ((value) => OracleResponseTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        channelReserve: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        initiator: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        initiatorAmount: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        initiatorDelegateIds: {
            deserialize: ((value, params) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
            serialize: ((value, params) => Buffer[]);
        };
        lockPeriod: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        responder: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        responderAmount: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        responderDelegateIds: {
            deserialize: ((value, params) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
            serialize: ((value, params) => Buffer[]);
        };
        stateHash: {
            deserialize: ((value) => `st_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ChannelCreateTx;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelCreateTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 2;
            constValueOptional: boolean;
            deserialize: ((value) => 2);
            serialize: ((value?) => Buffer);
        };
    } | {
        channelId: {
            deserialize: ((value) => `ch_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        fromId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        initiatorAmountFinal: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        responderAmountFinal: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        tag: {
            constValue: ChannelCloseMutualTx;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelCloseMutualTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        channelId: {
            deserialize: ((value) => `ch_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        fromId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        payload: {
            deserialize: ((value) => `tx_${string}`);
            serialize: ((value) => Buffer);
        };
        poi: EntryTreesPoi;
        tag: {
            constValue: ChannelCloseSoloTx;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelCloseSoloTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        channelId: {
            deserialize: ((value) => `ch_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        fromId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        payload: {
            deserialize: ((value) => `tx_${string}`);
            serialize: ((value) => Buffer);
        };
        poi: EntryTreesPoi;
        tag: {
            constValue: ChannelSlashTx;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelSlashTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        amount: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        channelId: {
            deserialize: ((value) => `ch_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        fromId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        round: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        stateHash: {
            deserialize: ((value) => `st_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ChannelDepositTx;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelDepositTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        amount: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        channelId: {
            deserialize: ((value) => `ch_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        round: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        stateHash: {
            deserialize: ((value) => `st_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ChannelWithdrawTx;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelWithdrawTx);
            serialize: ((value) => Buffer);
        };
        toId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        channelId: {
            deserialize: ((value) => `ch_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        fromId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        initiatorAmountFinal: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        responderAmountFinal: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        tag: {
            constValue: ChannelSettleTx;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelSettleTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        channelId: {
            deserialize: ((value) => `ch_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        fromId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        offChainTrees: {
            deserialize: ((value) => `ss_${string}`);
            serialize: ((value) => Buffer);
        };
        payload: {
            deserialize: ((value) => `tx_${string}`);
            serialize: ((value) => Buffer);
        };
        round: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        stateHash: {
            deserialize: ((value) => `st_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ChannelForceProgressTx;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelForceProgressTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        update: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        channelId: {
            deserialize: ((value) => `ch_${string}`);
            serialize: ((value) => Buffer);
        };
        round: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        stateHash: {
            deserialize: ((value) => `st_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ChannelOffChainTx;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelOffChainTx);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 2;
            constValueOptional: boolean;
            deserialize: ((value) => 2);
            serialize: ((value?) => Buffer);
        };
    } | {
        channelAmount: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        channelReserve: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        initiator: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        initiatorAmount: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        initiatorAuth: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        initiatorDelegateIds: {
            deserialize: ((value, params) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
            serialize: ((value, params) => Buffer[]);
        };
        lockPeriod: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        lockedUntil: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        responder: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        responderAmount: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        responderAuth: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        responderDelegateIds: {
            deserialize: ((value, params) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
            serialize: ((value, params) => Buffer[]);
        };
        round: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        soloRound: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        stateHash: {
            deserialize: ((value) => `st_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: Channel;
            constValueOptional: boolean;
            deserialize: ((value) => Channel);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 3;
            constValueOptional: boolean;
            deserialize: ((value) => 3);
            serialize: ((value?) => Buffer);
        };
    } | {
        channelId: {
            deserialize: ((value) => `ch_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        fromId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        payload: {
            deserialize: ((value) => `tx_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ChannelSnapshotSoloTx;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelSnapshotSoloTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        amount: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        from: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ChannelOffChainUpdateTransfer;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelOffChainUpdateTransfer);
            serialize: ((value) => Buffer);
        };
        to: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        amount: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        from: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ChannelOffChainUpdateDeposit;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelOffChainUpdateDeposit);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        amount: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        from: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ChannelOffChainUpdateWithdraw;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelOffChainUpdateWithdraw);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        callData: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        code: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        ctVersion: {
            deserialize(buffer): CtVersion;
            prepare(value, params, options): Promise<undefined | CtVersion>;
            serialize(value, params, __namedParameters): Buffer;
        };
        deposit: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        owner: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: ChannelOffChainUpdateCreateContract;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelOffChainUpdateCreateContract);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        abiVersion: {
            _getProtocolDetails(c, tag): AbiVersion;
            deserialize(buffer): AbiVersion;
            prepare(value, __namedParameters, options): Promise<(AbiVersion | undefined)>;
            serialize(value, __namedParameters, __namedParameters): Buffer;
        };
        amount: {
            deserialize(value): string;
            serialize(value): Buffer;
        };
        callData: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        callStack: {
            deserialize(buffer): Buffer;
            serialize(buffer): Buffer;
        };
        caller: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        contract: {
            deserialize: ((value) => `ct_${string}`);
            serialize: ((value) => Buffer);
        };
        gasLimit: {
            deserialize(value): number;
            serialize(_value, __namedParameters, __namedParameters): Buffer;
        };
        gasPrice: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value?): string;
        };
        tag: {
            constValue: ChannelOffChainUpdateCallContract;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelOffChainUpdateCallContract);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        channelId: {
            deserialize: ((value) => `ch_${string}`);
            serialize: ((value) => Buffer);
        };
        pubkey: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        role: {
            deserialize(buffer): string;
            serialize(string): Buffer;
        };
        round: {
            deserialize(value): number;
            serialize(value): Buffer;
        };
        tag: {
            constValue: ChannelClientReconnectTx;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelClientReconnectTx);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        accounts: {
            deserialize: ((value, params) => MPTree<AccountAddress, Account>[]);
            serialize: ((value, params) => MPTreeBinary[]);
        };
        calls: {
            deserialize: ((value, params) => MPTree<Bytearray, ContractCall>[]);
            serialize: ((value, params) => MPTreeBinary[]);
        };
        channels: {
            deserialize: ((value, params) => MPTree<Channel, Channel>[]);
            serialize: ((value, params) => MPTreeBinary[]);
        };
        contracts: {
            deserialize: ((value, params) => MPTree<ContractAddress, Contract>[]);
            serialize: ((value, params) => MPTreeBinary[]);
        };
        ns: {
            deserialize: ((value, params) => MPTree<Name, Name>[]);
            serialize: ((value, params) => MPTreeBinary[]);
        };
        oracles: {
            deserialize: ((value, params) => MPTree<OracleAddress, Oracle>[]);
            serialize: ((value, params) => MPTreeBinary[]);
        };
        tag: {
            constValue: TreesPoi;
            constValueOptional: boolean;
            deserialize: ((value) => TreesPoi);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        accounts: MapAccounts;
        calls: MapCalls;
        channels: MapChannels;
        contracts: MapContracts;
        ns: MapNames;
        oracles: MapOracles;
        tag: {
            constValue: StateTrees;
            constValueOptional: boolean;
            deserialize: ((value) => StateTrees);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 0;
            constValueOptional: boolean;
            deserialize: ((value) => 0);
            serialize: ((value?) => Buffer);
        };
    } | {
        tag: {
            constValue: Mtree;
            constValueOptional: boolean;
            deserialize: ((value) => Mtree);
            serialize: ((value) => Buffer);
        };
        values: EntryMtreeValueArray;
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        key: {
            deserialize(buffer): Buffer;
            serialize(buffer): Buffer;
        };
        tag: {
            constValue: MtreeValue;
            constValueOptional: boolean;
            deserialize: ((value) => MtreeValue);
            serialize: ((value) => Buffer);
        };
        value: {
            deserialize(buffer): Buffer;
            serialize(buffer): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        payload: MapContracts;
        tag: {
            constValue: ContractsMtree;
            constValueOptional: boolean;
            deserialize: ((value) => ContractsMtree);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        payload: MapCalls;
        tag: {
            constValue: CallsMtree;
            constValueOptional: boolean;
            deserialize: ((value) => CallsMtree);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        payload: MapChannels;
        tag: {
            constValue: ChannelsMtree;
            constValueOptional: boolean;
            deserialize: ((value) => ChannelsMtree);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        payload: MapNames;
        tag: {
            constValue: NameserviceMtree;
            constValueOptional: boolean;
            deserialize: ((value) => NameserviceMtree);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        payload: MapOracles;
        tag: {
            constValue: OraclesMtree;
            constValueOptional: boolean;
            deserialize: ((value) => OraclesMtree);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        payload: MapAccounts;
        tag: {
            constValue: AccountsMtree;
            constValueOptional: boolean;
            deserialize: ((value) => AccountsMtree);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        authFun: {
            deserialize(buffer): Buffer;
            serialize(buffer): Buffer;
        };
        callData: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        code: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        ctVersion: {
            deserialize(buffer): CtVersion;
            prepare(value, params, options): Promise<undefined | CtVersion>;
            serialize(value, params, __namedParameters): Buffer;
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        gasLimit: {
            deserialize(value): number;
            serialize(_value, __namedParameters, __namedParameters): Buffer;
        };
        gasPrice: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value?): string;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        ownerId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: GaAttachTx;
            constValueOptional: boolean;
            deserialize: ((value) => GaAttachTx);
            serialize: ((value) => Buffer);
        };
        ttl: {
            deserialize(value): number;
            prepare(value, params, __namedParameters): Promise<undefined | number>;
            serialize(value): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        abiVersion: {
            _getProtocolDetails(c, tag): AbiVersion;
            deserialize(buffer): AbiVersion;
            prepare(value, __namedParameters, options): Promise<(AbiVersion | undefined)>;
            serialize(value, __namedParameters, __namedParameters): Buffer;
        };
        authData: {
            deserialize: ((value) => `cb_${string}`);
            serialize: ((value) => Buffer);
        };
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        gaId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        gasLimit: {
            deserialize(value): number;
            serialize(_value, __namedParameters, __namedParameters): Buffer;
        };
        gasPrice: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value?): string;
        };
        tag: {
            constValue: GaMetaTx;
            constValueOptional: boolean;
            deserialize: ((value) => GaMetaTx);
            serialize: ((value) => Buffer);
        };
        tx: EntrySignedTx;
        version: {
            constValue: 2;
            constValueOptional: boolean;
            deserialize: ((value) => 2);
            serialize: ((value?) => Buffer);
        };
    } | {
        fee: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, options): Buffer;
            serializeAettos(_value, __namedParameters, __namedParameters): string;
        };
        nonce: {
            deserialize: ((value) => number);
            prepare: ((value, params, options) => Promise<number>);
            senderKey: string;
            serialize: ((value) => Buffer);
        };
        payerId: {
            deserialize: ((value) => `ak_${string}`);
            serialize: ((value) => Buffer);
        };
        tag: {
            constValue: PayingForTx;
            constValueOptional: boolean;
            deserialize: ((value) => PayingForTx);
            serialize: ((value) => Buffer);
        };
        tx: EntrySignedTx;
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    } | {
        fee: {
            deserialize(value): string;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value, params, options): string;
        };
        gasPrice: {
            deserialize(value): string;
            prepare(value, params, __namedParameters): Promise<(Int | undefined)>;
            serialize(value, params, __namedParameters): Buffer;
            serializeAettos(value?): string;
        };
        tag: {
            constValue: GaMetaTxAuthData;
            constValueOptional: boolean;
            deserialize: ((value) => GaMetaTxAuthData);
            serialize: ((value) => Buffer);
        };
        txHash: {
            deserialize: ((value) => `th_${string}`);
            serialize: ((value) => Buffer);
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: ((value) => 1);
            serialize: ((value?) => Buffer);
        };
    }> & {
        tag: TreesPoi;
    });
    recursiveType: true;
    serialize: ((value) => Buffer);
}