Interface EntUnpackedAccountsMtree1

interface EntUnpackedAccountsMtree1 {
    payload: Record<
        `ak_${string}`,
        TxUnpackedBySchema<
            | {
                balance: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                nonce: {
                    deserialize(value: Buffer): number;
                    serialize(value: number): Buffer;
                };
                tag: {
                    constValue: Account;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => Account;
                    serialize: (value: Account) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value: 1) => Buffer;
                };
            }
            | {
                balance: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                flags: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                gaAuthFun: {
                    deserialize: (value: Buffer) => `cb_${string}`;
                    serialize: (value: `cb_${string}`) => Buffer;
                };
                gaContract: {
                    deserialize: (value: Buffer) => `ct_${string}` | `nm_${string}`;
                    serialize: (value: `ct_${string}` | `nm_${string}`) => Buffer;
                };
                nonce: {
                    deserialize(value: Buffer): number;
                    serialize(value: number): Buffer;
                };
                tag: {
                    constValue: Account;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => Account;
                    serialize: (value: Account) => Buffer;
                };
                version: {
                    constValue: 2;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 2;
                    serialize: (value?: 2) => Buffer;
                };
            }
            | {
                accountId: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                clientTtl: {
                    deserialize(value: Buffer): number;
                    serialize(value: number): Buffer;
                };
                nameTtl: {
                    deserialize(value: Buffer): number;
                    serialize(value: number): Buffer;
                };
                pointers: <AllowRaw extends boolean>(
                    allowRaw: AllowRaw,
                ) => {
                    deserialize: (
                        pointers: [key: Buffer, id: Buffer][],
                    ) => (AllowRaw extends true ? NamePointerRaw : NamePointer)[];
                    serialize: (
                        pointers: (AllowRaw extends true ? NamePointerRaw : NamePointer)[],
                    ) => Buffer[][];
                };
                status: {
                    deserialize(buffer: Buffer): Buffer;
                    serialize(buffer: Uint8Array): Buffer;
                };
                tag: {
                    constValue: Name;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => Name;
                    serialize: (value: Name) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                active: {
                    deserialize(buffer: Buffer): boolean;
                    serialize(value: boolean): Buffer;
                };
                code: {
                    deserialize: (value: Buffer) => `cb_${string}`;
                    serialize: (value: `cb_${string}`) => Buffer;
                };
                ctVersion: {
                    deserialize(buffer: Buffer): CtVersion;
                    prepare(
                        value: undefined | CtVersion,
                        params: {},
                        options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                    ): Promise<undefined | CtVersion>;
                    serialize(
                        value: undefined | CtVersion,
                        params: {},
                        __namedParameters: { consensusProtocolVersion?: Ceres },
                    ): Buffer;
                };
                deposit: {
                    deserialize(value: Buffer): string;
                    serialize(
                        value: Int | undefined,
                        params: {},
                        __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
                    ): Buffer;
                    serializeAettos(
                        value: undefined | string,
                        params: {},
                        options: {},
                    ): string;
                };
                log: {
                    deserialize: (value: Buffer) => `cb_${string}`;
                    serialize: (value: `cb_${string}`) => Buffer;
                };
                owner: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                referers: {
                    deserialize: (value: Buffer[], params: unknown) => `ak_${string}`[];
                    serialize: (
                        value: readonly `ak_${string}`[],
                        params: unknown,
                    ) => Buffer[];
                };
                tag: {
                    constValue: Contract;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => Contract;
                    serialize: (value: Contract) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                callerId: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                callerNonce: {
                    deserialize(value: Buffer): number;
                    serialize(value: number): Buffer;
                };
                contractId: {
                    deserialize: (value: Buffer) => `ct_${string}`;
                    serialize: (value: `ct_${string}`) => Buffer;
                };
                gasPrice: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                gasUsed: {
                    deserialize(value: Buffer): number;
                    serialize(value: number): Buffer;
                };
                height: {
                    deserialize(value: Buffer): number;
                    serialize(value: number): Buffer;
                };
                log: {
                    deserialize: (value: Buffer[], params: unknown) => Buffer[];
                    serialize: (value: readonly Uint8Array[], params: unknown) => Buffer[];
                };
                returnType: {
                    deserialize: (value: Buffer) => CallReturnType;
                    serialize: (value: CallReturnType) => Buffer;
                };
                returnValue: {
                    deserialize: (value: Buffer) => `cb_${string}`;
                    serialize: (value: `cb_${string}`) => Buffer;
                };
                tag: {
                    constValue: ContractCall;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => ContractCall;
                    serialize: (value: ContractCall) => Buffer;
                };
                version: {
                    constValue: 2;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 2;
                    serialize: (value?: 2) => Buffer;
                };
            }
            | {
                abiVersion: {
                    _getProtocolDetails(c: Ceres, tag: Tag): AbiVersion;
                    deserialize(buffer: Buffer): AbiVersion;
                    prepare(
                        value: AbiVersion | undefined,
                        __namedParameters: { tag: Tag },
                        options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                    ): Promise<(AbiVersion | undefined)>;
                    serialize(
                        value: AbiVersion | undefined,
                        __namedParameters: { tag: Tag },
                        __namedParameters: { consensusProtocolVersion?: Ceres },
                    ): Buffer;
                };
                accountId: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                oracleTtlValue: {
                    deserialize(value: Buffer): number;
                    serialize(value: number): Buffer;
                };
                queryFee: {
                    deserialize(value: Buffer): string;
                    serialize(
                        value: Int | undefined,
                        params: {},
                        __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
                    ): Buffer;
                    serializeAettos(
                        value: undefined | string,
                        params: {},
                        options: {},
                    ): string;
                };
                queryFormat: {
                    deserialize(buffer: Buffer): string;
                    serialize(string: string): Buffer;
                };
                responseFormat: {
                    deserialize(buffer: Buffer): string;
                    serialize(string: string): Buffer;
                };
                tag: {
                    constValue: Oracle;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => Oracle;
                    serialize: (value: Oracle) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                channelAmount: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                channelReserve: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                initiator: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                initiatorAmount: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                initiatorAuth: {
                    deserialize: (value: Buffer) => `cb_${string}`;
                    serialize: (value: `cb_${string}`) => Buffer;
                };
                initiatorDelegateIds: {
                    deserialize: (
                        value: Buffer[],
                        params: unknown,
                    ) => (
                        | `ch_${string}`
                        | `ct_${string}`
                        | `ok_${string}`
                        | `ak_${string}`
                        | `cm_${string}`
                        | `nm_${string}`
                    )[];
                    serialize: (
                        value: readonly (
                            | `ch_${string}`
                            | `ct_${string}`
                            | `ok_${string}`
                            | `ak_${string}`
                            | `cm_${string}`
                            | `nm_${string}`
                        )[],
                        params: unknown,
                    ) => Buffer[];
                };
                lockedUntil: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                lockPeriod: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                responder: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                responderAmount: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                responderAuth: {
                    deserialize: (value: Buffer) => `cb_${string}`;
                    serialize: (value: `cb_${string}`) => Buffer;
                };
                responderDelegateIds: {
                    deserialize: (
                        value: Buffer[],
                        params: unknown,
                    ) => (
                        | `ch_${string}`
                        | `ct_${string}`
                        | `ok_${string}`
                        | `ak_${string}`
                        | `cm_${string}`
                        | `nm_${string}`
                    )[];
                    serialize: (
                        value: readonly (
                            | `ch_${string}`
                            | `ct_${string}`
                            | `ok_${string}`
                            | `ak_${string}`
                            | `cm_${string}`
                            | `nm_${string}`
                        )[],
                        params: unknown,
                    ) => Buffer[];
                };
                round: {
                    deserialize(value: Buffer): number;
                    serialize(value: number): Buffer;
                };
                soloRound: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                stateHash: {
                    deserialize: (value: Buffer) => `st_${string}`;
                    serialize: (value: `st_${string}`) => Buffer;
                };
                tag: {
                    constValue: Channel;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => Channel;
                    serialize: (value: Channel) => Buffer;
                };
                version: {
                    constValue: 3;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 3;
                    serialize: (value?: 3) => Buffer;
                };
            }
            | {
                amount: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                from: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                tag: {
                    constValue: ChannelOffChainUpdateTransfer;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => ChannelOffChainUpdateTransfer;
                    serialize: (value: ChannelOffChainUpdateTransfer) => Buffer;
                };
                to: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                amount: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                from: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                tag: {
                    constValue: ChannelOffChainUpdateDeposit;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => ChannelOffChainUpdateDeposit;
                    serialize: (value: ChannelOffChainUpdateDeposit) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                amount: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                from: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                tag: {
                    constValue: ChannelOffChainUpdateWithdraw;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => ChannelOffChainUpdateWithdraw;
                    serialize: (value: ChannelOffChainUpdateWithdraw) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                callData: {
                    deserialize: (value: Buffer) => `cb_${string}`;
                    serialize: (value: `cb_${string}`) => Buffer;
                };
                code: {
                    deserialize: (value: Buffer) => `cb_${string}`;
                    serialize: (value: `cb_${string}`) => Buffer;
                };
                ctVersion: {
                    deserialize(buffer: Buffer): CtVersion;
                    prepare(
                        value: undefined | CtVersion,
                        params: {},
                        options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                    ): Promise<undefined | CtVersion>;
                    serialize(
                        value: undefined | CtVersion,
                        params: {},
                        __namedParameters: { consensusProtocolVersion?: Ceres },
                    ): Buffer;
                };
                deposit: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                owner: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                tag: {
                    constValue: ChannelOffChainUpdateCreateContract;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => ChannelOffChainUpdateCreateContract;
                    serialize: (value: ChannelOffChainUpdateCreateContract) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                abiVersion: {
                    _getProtocolDetails(c: Ceres, tag: Tag): AbiVersion;
                    deserialize(buffer: Buffer): AbiVersion;
                    prepare(
                        value: AbiVersion | undefined,
                        __namedParameters: { tag: Tag },
                        options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                    ): Promise<(AbiVersion | undefined)>;
                    serialize(
                        value: AbiVersion | undefined,
                        __namedParameters: { tag: Tag },
                        __namedParameters: { consensusProtocolVersion?: Ceres },
                    ): Buffer;
                };
                amount: {
                    deserialize(value: Buffer): string;
                    serialize(value: Int): Buffer;
                };
                callData: {
                    deserialize: (value: Buffer) => `cb_${string}`;
                    serialize: (value: `cb_${string}`) => Buffer;
                };
                caller: {
                    deserialize: (value: Buffer) => `ak_${string}`;
                    serialize: (value: `ak_${string}`) => Buffer;
                };
                callStack: {
                    deserialize(buffer: Buffer): Buffer;
                    serialize(buffer: Uint8Array): Buffer;
                };
                contract: {
                    deserialize: (value: Buffer) => `ct_${string}`;
                    serialize: (value: `ct_${string}`) => Buffer;
                };
                gasLimit: {
                    deserialize(value: Buffer): number;
                    serialize(
                        _value: undefined | number,
                        __namedParameters: {
                            _computingGasLimit?: number;
                            buildTx: (params: TxParams) => `tx_${string}`;
                            rebuildTx: (params: any) => any;
                            tag: Tag;
                            unpackTx: <TxType extends Tag>(
                                encodedTx:
                                    | `tx_${string}`
                                    | `pi_${string}`
                                    | `ss_${string}`
                                    | `cs_${string}`,
                                txType?: TxType,
                            ) => TxUnpacked & { tag: TxType; };
                        },
                        __namedParameters: { gasMax?: number },
                    ): Buffer;
                };
                gasPrice: {
                    deserialize(value: Buffer): string;
                    prepare(
                        value: Int | undefined,
                        params: {},
                        __namedParameters: {
                            denomination?: AE_AMOUNT_FORMATS | undefined;
                            onNode?: Node;
                        },
                    ): Promise<(Int | undefined)>;
                    serialize(
                        value: Int | undefined,
                        params: {},
                        __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
                    ): Buffer;
                    serializeAettos(value?: undefined | string): string;
                };
                tag: {
                    constValue: ChannelOffChainUpdateCallContract;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => ChannelOffChainUpdateCallContract;
                    serialize: (value: ChannelOffChainUpdateCallContract) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                accounts: {
                    deserialize: (
                        value: MPTreeBinary[],
                        params: unknown,
                    ) => MPTree<AccountAddress, Account>[];
                    serialize: (
                        value: readonly MPTree<AccountAddress, Account>[],
                        params: unknown,
                    ) => MPTreeBinary[];
                };
                calls: {
                    deserialize: (
                        value: MPTreeBinary[],
                        params: unknown,
                    ) => MPTree<Bytearray, ContractCall>[];
                    serialize: (
                        value: readonly MPTree<Bytearray, ContractCall>[],
                        params: unknown,
                    ) => MPTreeBinary[];
                };
                channels: {
                    deserialize: (
                        value: MPTreeBinary[],
                        params: unknown,
                    ) => MPTree<Channel, Channel>[];
                    serialize: (
                        value: readonly MPTree<Channel, Channel>[],
                        params: unknown,
                    ) => MPTreeBinary[];
                };
                contracts: {
                    deserialize: (
                        value: MPTreeBinary[],
                        params: unknown,
                    ) => MPTree<ContractAddress, Contract>[];
                    serialize: (
                        value: readonly MPTree<ContractAddress, Contract>[],
                        params: unknown,
                    ) => MPTreeBinary[];
                };
                ns: {
                    deserialize: (
                        value: MPTreeBinary[],
                        params: unknown,
                    ) => MPTree<Name, Name>[];
                    serialize: (
                        value: readonly MPTree<Name, Name>[],
                        params: unknown,
                    ) => MPTreeBinary[];
                };
                oracles: {
                    deserialize: (
                        value: MPTreeBinary[],
                        params: unknown,
                    ) => MPTree<OracleAddress, Oracle>[];
                    serialize: (
                        value: readonly MPTree<OracleAddress, Oracle>[],
                        params: unknown,
                    ) => MPTreeBinary[];
                };
                tag: {
                    constValue: TreesPoi;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => TreesPoi;
                    serialize: (value: TreesPoi) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                accounts: MapAccounts;
                calls: MapCalls;
                channels: MapChannels;
                contracts: MapContracts;
                ns: MapNames;
                oracles: MapOracles;
                tag: {
                    constValue: StateTrees;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => StateTrees;
                    serialize: (value: StateTrees) => Buffer;
                };
                version: {
                    constValue: 0;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 0;
                    serialize: (value?: 0) => Buffer;
                };
            }
            | {
                tag: {
                    constValue: Mtree;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => Mtree;
                    serialize: (value: Mtree) => Buffer;
                };
                values: EntryMtreeValueArray;
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                key: {
                    deserialize(buffer: Buffer): Buffer;
                    serialize(buffer: Uint8Array): Buffer;
                };
                tag: {
                    constValue: MtreeValue;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => MtreeValue;
                    serialize: (value: MtreeValue) => Buffer;
                };
                value: {
                    deserialize(buffer: Buffer): Buffer;
                    serialize(buffer: Uint8Array): Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                payload: MapContracts;
                tag: {
                    constValue: ContractsMtree;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => ContractsMtree;
                    serialize: (value: ContractsMtree) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                payload: MapCalls;
                tag: {
                    constValue: CallsMtree;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => CallsMtree;
                    serialize: (value: CallsMtree) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                payload: MapChannels;
                tag: {
                    constValue: ChannelsMtree;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => ChannelsMtree;
                    serialize: (value: ChannelsMtree) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                payload: MapNames;
                tag: {
                    constValue: NameserviceMtree;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => NameserviceMtree;
                    serialize: (value: NameserviceMtree) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                payload: MapOracles;
                tag: {
                    constValue: OraclesMtree;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => OraclesMtree;
                    serialize: (value: OraclesMtree) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                payload: MapAccounts;
                tag: {
                    constValue: AccountsMtree;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => AccountsMtree;
                    serialize: (value: AccountsMtree) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            }
            | {
                fee: {
                    deserialize(value: Buffer): string;
                    serialize(
                        value: Int | undefined,
                        params: {},
                        __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
                    ): Buffer;
                    serializeAettos(
                        value: undefined | string,
                        params: {},
                        options: {},
                    ): string;
                };
                gasPrice: {
                    deserialize(value: Buffer): string;
                    prepare(
                        value: Int | undefined,
                        params: {},
                        __namedParameters: {
                            denomination?: AE_AMOUNT_FORMATS | undefined;
                            onNode?: Node;
                        },
                    ): Promise<(Int | undefined)>;
                    serialize(
                        value: Int | undefined,
                        params: {},
                        __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
                    ): Buffer;
                    serializeAettos(value?: undefined | string): string;
                };
                tag: {
                    constValue: GaMetaTxAuthData;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => GaMetaTxAuthData;
                    serialize: (value: GaMetaTxAuthData) => Buffer;
                };
                txHash: {
                    deserialize: (value: Buffer) => `th_${string}`;
                    serialize: (value: `th_${string}`) => Buffer;
                };
                version: {
                    constValue: 1;
                    constValueOptional: boolean;
                    deserialize: (value: Buffer) => 1;
                    serialize: (value?: 1) => Buffer;
                };
            },
        > & { tag: Account },
    >;
    tag: AccountsMtree;
    version: 1;
}