interface TransactionSignedTx {
    deserialize: (
        value: Buffer,
    ) => TxUnpackedBySchema<
        | {
            encodedTx: TransactionAny;
            signatures: {
                deserialize: (value: Buffer[], params: unknown) => Buffer[];
                serialize: (value: readonly Uint8Array[], params: unknown) => Buffer[];
            };
            tag: {
                constValue: SignedTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => SignedTx;
                serialize: (value: SignedTx) => Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            amount: {
                deserialize(value: Buffer): string;
                serialize(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
                ): Buffer;
                serializeAettos(
                    value: undefined | string,
                    params: {},
                    options: {},
                ): string;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { senderId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            payload: {
                deserialize: (value: Buffer) => `ba_${string}`;
                serialize: (value?: `ba_${string}`) => Buffer;
            };
            recipientId: {
                deserialize: (
                    value: Buffer,
                ) => `ct_${string}` | `ak_${string}` | `nm_${string}`;
                serialize: (
                    value: `ct_${string}` | `ak_${string}` | `nm_${string}`,
                ) => Buffer;
            };
            senderId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            tag: {
                constValue: SpendTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => SpendTx;
                serialize: (value: SpendTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            accountId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            commitmentId: {
                deserialize: (value: Buffer) => `cm_${string}`;
                serialize: (value: `cm_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { accountId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            tag: {
                constValue: NamePreclaimTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => NamePreclaimTx;
                serialize: (value: NamePreclaimTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            accountId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            name: {
                deserialize(value: Buffer): `${string}.chain`;
                serialize(value: `${string}.chain`): Buffer;
            };
            nameFee: {
                deserialize(value: Buffer): string;
                serialize(
                    value: Int | undefined,
                    txFields: { name: `${string}.chain` },
                    parameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    txFields: { name: `${string}.chain` },
                ): string;
            };
            nameSalt: {
                deserialize: (value: Buffer, params: unknown) => string;
                serialize: (value: Int | undefined, params: unknown) => Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { accountId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            tag: {
                constValue: NameClaimTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => NameClaimTx;
                serialize: (value: NameClaimTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): 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, params: unknown) => number;
                serialize: (value: undefined | number, params: unknown) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nameId: {
                deserialize: (value: Buffer) => `nm_${string}`;
                serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
            };
            nameTtl: {
                deserialize: (value: Buffer) => number;
                serialize: (
                    value: undefined | number,
                    params: unknown,
                    options: unknown,
                ) => Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { accountId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            pointers: {
                deserialize: (pointers: [key: Buffer, id: Buffer][]) => NamePointer[];
                serialize: (pointers: NamePointer[]) => Buffer[][];
            };
            tag: {
                constValue: NameUpdateTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => NameUpdateTx;
                serialize: (value: NameUpdateTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            accountId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            clientTtl: {
                deserialize: (value: Buffer, params: unknown) => number;
                serialize: (value: undefined | number, params: unknown) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nameId: {
                deserialize: (value: Buffer) => `nm_${string}`;
                serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
            };
            nameTtl: {
                deserialize: (value: Buffer) => number;
                serialize: (
                    value: undefined | number,
                    params: unknown,
                    options: unknown,
                ) => Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { accountId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            pointers: {
                deserialize: (
                    pointers: [key: Buffer, id: Buffer][],
                ) => NamePointerRaw[];
                serialize: (pointers: NamePointerRaw[]) => Buffer[][];
            };
            tag: {
                constValue: NameUpdateTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => NameUpdateTx;
                serialize: (value: NameUpdateTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): 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;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nameId: {
                deserialize: (value: Buffer) => `nm_${string}`;
                serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { accountId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            recipientId: {
                deserialize: (value: Buffer) => `ak_${string}` | `nm_${string}`;
                serialize: (value: `ak_${string}` | `nm_${string}`) => Buffer;
            };
            tag: {
                constValue: NameTransferTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => NameTransferTx;
                serialize: (value: NameTransferTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            accountId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nameId: {
                deserialize: (value: Buffer) => `nm_${string}`;
                serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { accountId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            tag: {
                constValue: NameRevokeTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => NameRevokeTx;
                serialize: (value: NameRevokeTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            amount: {
                deserialize(value: Buffer): string;
                serialize(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
                ): Buffer;
                serializeAettos(
                    value: undefined | string,
                    params: {},
                    options: {},
                ): string;
            };
            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 | undefined,
                    params: {},
                    options: { denomination?: AE_AMOUNT_FORMATS | undefined },
                ) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            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;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { ownerId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            ownerId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            tag: {
                constValue: ContractCreateTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ContractCreateTx;
                serialize: (value: ContractCreateTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): 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 | undefined,
                    params: {},
                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
                ): Buffer;
                serializeAettos(
                    value: undefined | string,
                    params: {},
                    options: {},
                ): string;
            };
            callData: {
                deserialize: (value: Buffer) => `cb_${string}`;
                serialize: (value: `cb_${string}`) => Buffer;
            };
            callerId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            contractId: {
                deserialize: (value: Buffer) => `ct_${string}` | `nm_${string}`;
                serialize: (value: `ct_${string}` | `nm_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            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;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { callerId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            tag: {
                constValue: ContractCallTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ContractCallTx;
                serialize: (value: ContractCallTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): 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;
            };
            accountId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { accountId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            oracleTtlType: {
                deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
                serialize: (value: undefined | delta | block, params: unknown) => Buffer;
            };
            oracleTtlValue: {
                deserialize: (value: Buffer, params: unknown) => number;
                serialize: (value: undefined | number, params: unknown) => 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: OracleRegisterTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => OracleRegisterTx;
                serialize: (value: OracleRegisterTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { oracleId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            oracleId: {
                deserialize: (value: Buffer) => `ok_${string}` | `nm_${string}`;
                serialize: (value: `ok_${string}` | `nm_${string}`) => Buffer;
            };
            oracleTtlType: {
                deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
                serialize: (value: undefined | delta | block, params: unknown) => Buffer;
            };
            oracleTtlValue: {
                deserialize: (value: Buffer, params: unknown) => number;
                serialize: (value: undefined | number, params: unknown) => Buffer;
            };
            tag: {
                constValue: OracleExtendTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => OracleExtendTx;
                serialize: (value: OracleExtendTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { senderId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            oracleId: {
                deserialize: (value: Buffer) => `ok_${string}` | `nm_${string}`;
                serialize: (value: `ok_${string}` | `nm_${string}`) => Buffer;
            };
            query: {
                deserialize(buffer: Buffer): string;
                serialize(string: string): Buffer;
            };
            queryFee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    options: { onNode?: Node; oracleId?: `ok_${string}` },
                ): Promise<Int>;
                serialize(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
                ): Buffer;
                serializeAettos(
                    value: undefined | string,
                    params: {},
                    options: {},
                ): string;
            };
            queryTtlType: {
                deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
                serialize: (value: undefined | delta | block, params: unknown) => Buffer;
            };
            queryTtlValue: {
                deserialize: (value: Buffer, params: unknown) => number;
                serialize: (value: undefined | number, params: unknown) => Buffer;
            };
            responseTtlType: {
                deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
                serialize: (value: undefined | delta | block, params: unknown) => Buffer;
            };
            responseTtlValue: {
                deserialize: (value: Buffer, params: unknown) => number;
                serialize: (value: undefined | number, params: unknown) => Buffer;
            };
            senderId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            tag: {
                constValue: OracleQueryTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => OracleQueryTx;
                serialize: (value: OracleQueryTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { oracleId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            oracleId: {
                deserialize: (value: Buffer) => `ok_${string}`;
                serialize: (value: `ok_${string}`) => Buffer;
            };
            queryId: {
                deserialize: (value: Buffer) => `oq_${string}`;
                serialize: (value: `oq_${string}`) => Buffer;
            };
            response: {
                deserialize(buffer: Buffer): string;
                serialize(string: string): Buffer;
            };
            responseTtlType: {
                deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
                serialize: (value: undefined | delta | block, params: unknown) => Buffer;
            };
            responseTtlValue: {
                deserialize: (value: Buffer, params: unknown) => number;
                serialize: (value: undefined | number, params: unknown) => Buffer;
            };
            tag: {
                constValue: OracleResponseTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => OracleResponseTx;
                serialize: (value: OracleResponseTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            channelReserve: {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            initiator: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            initiatorAmount: {
                deserialize(value: Buffer): string;
                serialize(value: Int): 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[];
            };
            lockPeriod: {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { initiator: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            responder: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            responderAmount: {
                deserialize(value: Buffer): string;
                serialize(value: Int): 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[];
            };
            stateHash: {
                deserialize: (value: Buffer) => `st_${string}`;
                serialize: (value: `st_${string}`) => Buffer;
            };
            tag: {
                constValue: ChannelCreateTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ChannelCreateTx;
                serialize: (value: ChannelCreateTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 2;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 2;
                serialize: (value?: 2) => Buffer;
            };
        }
        | {
            channelId: {
                deserialize: (value: Buffer) => `ch_${string}`;
                serialize: (value: `ch_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            fromId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            initiatorAmountFinal: {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { fromId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            responderAmountFinal: {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            };
            tag: {
                constValue: ChannelCloseMutualTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ChannelCloseMutualTx;
                serialize: (value: ChannelCloseMutualTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            channelId: {
                deserialize: (value: Buffer) => `ch_${string}`;
                serialize: (value: `ch_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            fromId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { fromId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            payload: {
                deserialize: (value: Buffer) => `tx_${string}`;
                serialize: (value: `tx_${string}`) => Buffer;
            };
            poi: EntryTreesPoi;
            tag: {
                constValue: ChannelCloseSoloTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ChannelCloseSoloTx;
                serialize: (value: ChannelCloseSoloTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            channelId: {
                deserialize: (value: Buffer) => `ch_${string}`;
                serialize: (value: `ch_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            fromId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { fromId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            payload: {
                deserialize: (value: Buffer) => `tx_${string}`;
                serialize: (value: `tx_${string}`) => Buffer;
            };
            poi: EntryTreesPoi;
            tag: {
                constValue: ChannelSlashTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ChannelSlashTx;
                serialize: (value: ChannelSlashTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            amount: {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            };
            channelId: {
                deserialize: (value: Buffer) => `ch_${string}`;
                serialize: (value: `ch_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            fromId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { fromId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            round: {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            };
            stateHash: {
                deserialize: (value: Buffer) => `st_${string}`;
                serialize: (value: `st_${string}`) => Buffer;
            };
            tag: {
                constValue: ChannelDepositTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ChannelDepositTx;
                serialize: (value: ChannelDepositTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            amount: {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            };
            channelId: {
                deserialize: (value: Buffer) => `ch_${string}`;
                serialize: (value: `ch_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { fromId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            round: {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            };
            stateHash: {
                deserialize: (value: Buffer) => `st_${string}`;
                serialize: (value: `st_${string}`) => Buffer;
            };
            tag: {
                constValue: ChannelWithdrawTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ChannelWithdrawTx;
                serialize: (value: ChannelWithdrawTx) => Buffer;
            };
            toId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            channelId: {
                deserialize: (value: Buffer) => `ch_${string}`;
                serialize: (value: `ch_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            fromId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            initiatorAmountFinal: {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { fromId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            responderAmountFinal: {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            };
            tag: {
                constValue: ChannelSettleTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ChannelSettleTx;
                serialize: (value: ChannelSettleTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            channelId: {
                deserialize: (value: Buffer) => `ch_${string}`;
                serialize: (value: `ch_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            fromId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { fromId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            offChainTrees: {
                deserialize: (value: Buffer) => `ss_${string}`;
                serialize: (value: `ss_${string}`) => Buffer;
            };
            payload: {
                deserialize: (value: Buffer) => `tx_${string}`;
                serialize: (value: `tx_${string}`) => Buffer;
            };
            round: {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            };
            stateHash: {
                deserialize: (value: Buffer) => `st_${string}`;
                serialize: (value: `st_${string}`) => Buffer;
            };
            tag: {
                constValue: ChannelForceProgressTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ChannelForceProgressTx;
                serialize: (value: ChannelForceProgressTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            update: {
                deserialize: (value: Buffer) => `cb_${string}`;
                serialize: (value: `cb_${string}`) => Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            channelId: {
                deserialize: (value: Buffer) => `ch_${string}`;
                serialize: (value: `ch_${string}`) => Buffer;
            };
            round: {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            };
            stateHash: {
                deserialize: (value: Buffer) => `st_${string}`;
                serialize: (value: `st_${string}`) => Buffer;
            };
            tag: {
                constValue: ChannelOffChainTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ChannelOffChainTx;
                serialize: (value: ChannelOffChainTx) => Buffer;
            };
            version: {
                constValue: 2;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 2;
                serialize: (value?: 2) => Buffer;
            };
        }
        | {
            channelId: {
                deserialize: (value: Buffer) => `ch_${string}`;
                serialize: (value: `ch_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            fromId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { fromId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            payload: {
                deserialize: (value: Buffer) => `tx_${string}`;
                serialize: (value: `tx_${string}`) => Buffer;
            };
            tag: {
                constValue: ChannelSnapshotSoloTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => ChannelSnapshotSoloTx;
                serialize: (value: ChannelSnapshotSoloTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): Buffer;
            };
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        }
        | {
            authFun: {
                deserialize(buffer: Buffer): Buffer;
                serialize(buffer: Uint8Array): 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;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            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;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { ownerId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            ownerId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            tag: {
                constValue: GaAttachTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => GaAttachTx;
                serialize: (value: GaAttachTx) => Buffer;
            };
            ttl: {
                deserialize(value: Buffer): number;
                prepare(
                    value: undefined | number,
                    params: {},
                    __namedParameters: {
                        _isInternalBuild?: boolean;
                        absoluteTtl?: boolean;
                        onNode?: Node;
                    } & Omit<
                        {
                            _expectedMineRate?: number;
                            _microBlockCycle?: number;
                            onNode: Node;
                        },
                        "onNode",
                    >,
                ): Promise<undefined | number>;
                serialize(value: undefined | number): 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;
            };
            authData: {
                deserialize: (value: Buffer) => `cb_${string}`;
                serialize: (value: `cb_${string}`) => Buffer;
            };
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            gaId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${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: GaMetaTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => GaMetaTx;
                serialize: (value: GaMetaTx) => Buffer;
            };
            tx: TransactionSignedTx;
            version: {
                constValue: 2;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 2;
                serialize: (value?: 2) => Buffer;
            };
        }
        | {
            fee: {
                deserialize(value: Buffer): string;
                prepare(
                    value: Int | undefined,
                    params: {},
                    __namedParameters: { onNode?: Node },
                ): Promise<(Int | undefined)>;
                serialize(
                    value: Int | undefined,
                    params: SerializeAettosParams,
                    options: { _canIncreaseFee?: boolean } & {
                        denomination?: AE_AMOUNT_FORMATS | undefined;
                    },
                ): Buffer;
                serializeAettos(
                    _value: undefined | string,
                    __namedParameters: SerializeAettosParams,
                    __namedParameters: { _canIncreaseFee?: boolean },
                ): string;
            };
            nonce: {
                deserialize: (value: Buffer) => number;
                prepare: (
                    value: undefined | number,
                    params: {},
                    options: { payerId: string } & {
                        _isInternalBuild?: boolean;
                        onNode?: Node;
                        strategy?: Enum1 | undefined;
                    },
                ) => Promise<number>;
                senderKey: string;
                serialize: (value: number, params: { tag: Tag }) => Buffer;
            };
            payerId: {
                deserialize: (value: Buffer) => `ak_${string}`;
                serialize: (value: `ak_${string}`) => Buffer;
            };
            tag: {
                constValue: PayingForTx;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => PayingForTx;
                serialize: (value: PayingForTx) => Buffer;
            };
            tx: TransactionSignedTx;
            version: {
                constValue: 1;
                constValueOptional: boolean;
                deserialize: (value: Buffer) => 1;
                serialize: (value?: 1) => Buffer;
            };
        },
    > & { tag: SignedTx };
    recursiveType: true;
    serialize: (
        value:
            | Uint8Array
            | `tx_${string}`
            | (
                ((TxParamsBySchemaInternal<PickIsRec<{ readonly tag: { serialize: (value: Tag.SignedTx) => Buffer; deserialize: (value: Buffer) => Tag.SignedTx; constValue: Tag.SignedTx; constValueOptional: boolean; }; readonly version: { ...; }; readonly signatures: { ...; }; readonly encodedTx: TransactionAny; }, true>> & Partial...
            ),
    ) => Buffer;
}

Properties

deserialize: (
    value: Buffer,
) => TxUnpackedBySchema<
    | {
        encodedTx: TransactionAny;
        signatures: {
            deserialize: (value: Buffer[], params: unknown) => Buffer[];
            serialize: (value: readonly Uint8Array[], params: unknown) => Buffer[];
        };
        tag: {
            constValue: SignedTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => SignedTx;
            serialize: (value: SignedTx) => Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        amount: {
            deserialize(value: Buffer): string;
            serialize(
                value: Int | undefined,
                params: {},
                __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
            ): Buffer;
            serializeAettos(
                value: undefined | string,
                params: {},
                options: {},
            ): string;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { senderId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        payload: {
            deserialize: (value: Buffer) => `ba_${string}`;
            serialize: (value?: `ba_${string}`) => Buffer;
        };
        recipientId: {
            deserialize: (
                value: Buffer,
            ) => `ct_${string}` | `ak_${string}` | `nm_${string}`;
            serialize: (
                value: `ct_${string}` | `ak_${string}` | `nm_${string}`,
            ) => Buffer;
        };
        senderId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        tag: {
            constValue: SpendTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => SpendTx;
            serialize: (value: SpendTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        accountId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        commitmentId: {
            deserialize: (value: Buffer) => `cm_${string}`;
            serialize: (value: `cm_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { accountId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        tag: {
            constValue: NamePreclaimTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => NamePreclaimTx;
            serialize: (value: NamePreclaimTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        accountId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        name: {
            deserialize(value: Buffer): `${string}.chain`;
            serialize(value: `${string}.chain`): Buffer;
        };
        nameFee: {
            deserialize(value: Buffer): string;
            serialize(
                value: Int | undefined,
                txFields: { name: `${string}.chain` },
                parameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                txFields: { name: `${string}.chain` },
            ): string;
        };
        nameSalt: {
            deserialize: (value: Buffer, params: unknown) => string;
            serialize: (value: Int | undefined, params: unknown) => Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { accountId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        tag: {
            constValue: NameClaimTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => NameClaimTx;
            serialize: (value: NameClaimTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): 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, params: unknown) => number;
            serialize: (value: undefined | number, params: unknown) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nameId: {
            deserialize: (value: Buffer) => `nm_${string}`;
            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
        };
        nameTtl: {
            deserialize: (value: Buffer) => number;
            serialize: (
                value: undefined | number,
                params: unknown,
                options: unknown,
            ) => Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { accountId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        pointers: {
            deserialize: (pointers: [key: Buffer, id: Buffer][]) => NamePointer[];
            serialize: (pointers: NamePointer[]) => Buffer[][];
        };
        tag: {
            constValue: NameUpdateTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => NameUpdateTx;
            serialize: (value: NameUpdateTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        accountId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        clientTtl: {
            deserialize: (value: Buffer, params: unknown) => number;
            serialize: (value: undefined | number, params: unknown) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nameId: {
            deserialize: (value: Buffer) => `nm_${string}`;
            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
        };
        nameTtl: {
            deserialize: (value: Buffer) => number;
            serialize: (
                value: undefined | number,
                params: unknown,
                options: unknown,
            ) => Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { accountId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        pointers: {
            deserialize: (
                pointers: [key: Buffer, id: Buffer][],
            ) => NamePointerRaw[];
            serialize: (pointers: NamePointerRaw[]) => Buffer[][];
        };
        tag: {
            constValue: NameUpdateTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => NameUpdateTx;
            serialize: (value: NameUpdateTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): 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;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nameId: {
            deserialize: (value: Buffer) => `nm_${string}`;
            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { accountId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        recipientId: {
            deserialize: (value: Buffer) => `ak_${string}` | `nm_${string}`;
            serialize: (value: `ak_${string}` | `nm_${string}`) => Buffer;
        };
        tag: {
            constValue: NameTransferTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => NameTransferTx;
            serialize: (value: NameTransferTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        accountId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nameId: {
            deserialize: (value: Buffer) => `nm_${string}`;
            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { accountId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        tag: {
            constValue: NameRevokeTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => NameRevokeTx;
            serialize: (value: NameRevokeTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        amount: {
            deserialize(value: Buffer): string;
            serialize(
                value: Int | undefined,
                params: {},
                __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
            ): Buffer;
            serializeAettos(
                value: undefined | string,
                params: {},
                options: {},
            ): string;
        };
        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 | undefined,
                params: {},
                options: { denomination?: AE_AMOUNT_FORMATS | undefined },
            ) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        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;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { ownerId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        ownerId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        tag: {
            constValue: ContractCreateTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ContractCreateTx;
            serialize: (value: ContractCreateTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): 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 | undefined,
                params: {},
                __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
            ): Buffer;
            serializeAettos(
                value: undefined | string,
                params: {},
                options: {},
            ): string;
        };
        callData: {
            deserialize: (value: Buffer) => `cb_${string}`;
            serialize: (value: `cb_${string}`) => Buffer;
        };
        callerId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        contractId: {
            deserialize: (value: Buffer) => `ct_${string}` | `nm_${string}`;
            serialize: (value: `ct_${string}` | `nm_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        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;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { callerId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        tag: {
            constValue: ContractCallTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ContractCallTx;
            serialize: (value: ContractCallTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): 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;
        };
        accountId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { accountId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        oracleTtlType: {
            deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
            serialize: (value: undefined | delta | block, params: unknown) => Buffer;
        };
        oracleTtlValue: {
            deserialize: (value: Buffer, params: unknown) => number;
            serialize: (value: undefined | number, params: unknown) => 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: OracleRegisterTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => OracleRegisterTx;
            serialize: (value: OracleRegisterTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { oracleId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        oracleId: {
            deserialize: (value: Buffer) => `ok_${string}` | `nm_${string}`;
            serialize: (value: `ok_${string}` | `nm_${string}`) => Buffer;
        };
        oracleTtlType: {
            deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
            serialize: (value: undefined | delta | block, params: unknown) => Buffer;
        };
        oracleTtlValue: {
            deserialize: (value: Buffer, params: unknown) => number;
            serialize: (value: undefined | number, params: unknown) => Buffer;
        };
        tag: {
            constValue: OracleExtendTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => OracleExtendTx;
            serialize: (value: OracleExtendTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { senderId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        oracleId: {
            deserialize: (value: Buffer) => `ok_${string}` | `nm_${string}`;
            serialize: (value: `ok_${string}` | `nm_${string}`) => Buffer;
        };
        query: {
            deserialize(buffer: Buffer): string;
            serialize(string: string): Buffer;
        };
        queryFee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                options: { onNode?: Node; oracleId?: `ok_${string}` },
            ): Promise<Int>;
            serialize(
                value: Int | undefined,
                params: {},
                __namedParameters: { denomination?: AE_AMOUNT_FORMATS | undefined },
            ): Buffer;
            serializeAettos(
                value: undefined | string,
                params: {},
                options: {},
            ): string;
        };
        queryTtlType: {
            deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
            serialize: (value: undefined | delta | block, params: unknown) => Buffer;
        };
        queryTtlValue: {
            deserialize: (value: Buffer, params: unknown) => number;
            serialize: (value: undefined | number, params: unknown) => Buffer;
        };
        responseTtlType: {
            deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
            serialize: (value: undefined | delta | block, params: unknown) => Buffer;
        };
        responseTtlValue: {
            deserialize: (value: Buffer, params: unknown) => number;
            serialize: (value: undefined | number, params: unknown) => Buffer;
        };
        senderId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        tag: {
            constValue: OracleQueryTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => OracleQueryTx;
            serialize: (value: OracleQueryTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { oracleId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        oracleId: {
            deserialize: (value: Buffer) => `ok_${string}`;
            serialize: (value: `ok_${string}`) => Buffer;
        };
        queryId: {
            deserialize: (value: Buffer) => `oq_${string}`;
            serialize: (value: `oq_${string}`) => Buffer;
        };
        response: {
            deserialize(buffer: Buffer): string;
            serialize(string: string): Buffer;
        };
        responseTtlType: {
            deserialize: (value: Buffer, params: unknown) => ORACLE_TTL_TYPES;
            serialize: (value: undefined | delta | block, params: unknown) => Buffer;
        };
        responseTtlValue: {
            deserialize: (value: Buffer, params: unknown) => number;
            serialize: (value: undefined | number, params: unknown) => Buffer;
        };
        tag: {
            constValue: OracleResponseTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => OracleResponseTx;
            serialize: (value: OracleResponseTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        channelReserve: {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        initiator: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        initiatorAmount: {
            deserialize(value: Buffer): string;
            serialize(value: Int): 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[];
        };
        lockPeriod: {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { initiator: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        responder: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        responderAmount: {
            deserialize(value: Buffer): string;
            serialize(value: Int): 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[];
        };
        stateHash: {
            deserialize: (value: Buffer) => `st_${string}`;
            serialize: (value: `st_${string}`) => Buffer;
        };
        tag: {
            constValue: ChannelCreateTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ChannelCreateTx;
            serialize: (value: ChannelCreateTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 2;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 2;
            serialize: (value?: 2) => Buffer;
        };
    }
    | {
        channelId: {
            deserialize: (value: Buffer) => `ch_${string}`;
            serialize: (value: `ch_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        fromId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        initiatorAmountFinal: {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { fromId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        responderAmountFinal: {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        };
        tag: {
            constValue: ChannelCloseMutualTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ChannelCloseMutualTx;
            serialize: (value: ChannelCloseMutualTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        channelId: {
            deserialize: (value: Buffer) => `ch_${string}`;
            serialize: (value: `ch_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        fromId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { fromId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        payload: {
            deserialize: (value: Buffer) => `tx_${string}`;
            serialize: (value: `tx_${string}`) => Buffer;
        };
        poi: EntryTreesPoi;
        tag: {
            constValue: ChannelCloseSoloTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ChannelCloseSoloTx;
            serialize: (value: ChannelCloseSoloTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        channelId: {
            deserialize: (value: Buffer) => `ch_${string}`;
            serialize: (value: `ch_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        fromId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { fromId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        payload: {
            deserialize: (value: Buffer) => `tx_${string}`;
            serialize: (value: `tx_${string}`) => Buffer;
        };
        poi: EntryTreesPoi;
        tag: {
            constValue: ChannelSlashTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ChannelSlashTx;
            serialize: (value: ChannelSlashTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        amount: {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        };
        channelId: {
            deserialize: (value: Buffer) => `ch_${string}`;
            serialize: (value: `ch_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        fromId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { fromId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        round: {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        };
        stateHash: {
            deserialize: (value: Buffer) => `st_${string}`;
            serialize: (value: `st_${string}`) => Buffer;
        };
        tag: {
            constValue: ChannelDepositTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ChannelDepositTx;
            serialize: (value: ChannelDepositTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        amount: {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        };
        channelId: {
            deserialize: (value: Buffer) => `ch_${string}`;
            serialize: (value: `ch_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { fromId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        round: {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        };
        stateHash: {
            deserialize: (value: Buffer) => `st_${string}`;
            serialize: (value: `st_${string}`) => Buffer;
        };
        tag: {
            constValue: ChannelWithdrawTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ChannelWithdrawTx;
            serialize: (value: ChannelWithdrawTx) => Buffer;
        };
        toId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        channelId: {
            deserialize: (value: Buffer) => `ch_${string}`;
            serialize: (value: `ch_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        fromId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        initiatorAmountFinal: {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { fromId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        responderAmountFinal: {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        };
        tag: {
            constValue: ChannelSettleTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ChannelSettleTx;
            serialize: (value: ChannelSettleTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        channelId: {
            deserialize: (value: Buffer) => `ch_${string}`;
            serialize: (value: `ch_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        fromId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { fromId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        offChainTrees: {
            deserialize: (value: Buffer) => `ss_${string}`;
            serialize: (value: `ss_${string}`) => Buffer;
        };
        payload: {
            deserialize: (value: Buffer) => `tx_${string}`;
            serialize: (value: `tx_${string}`) => Buffer;
        };
        round: {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        };
        stateHash: {
            deserialize: (value: Buffer) => `st_${string}`;
            serialize: (value: `st_${string}`) => Buffer;
        };
        tag: {
            constValue: ChannelForceProgressTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ChannelForceProgressTx;
            serialize: (value: ChannelForceProgressTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        update: {
            deserialize: (value: Buffer) => `cb_${string}`;
            serialize: (value: `cb_${string}`) => Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        channelId: {
            deserialize: (value: Buffer) => `ch_${string}`;
            serialize: (value: `ch_${string}`) => Buffer;
        };
        round: {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        };
        stateHash: {
            deserialize: (value: Buffer) => `st_${string}`;
            serialize: (value: `st_${string}`) => Buffer;
        };
        tag: {
            constValue: ChannelOffChainTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ChannelOffChainTx;
            serialize: (value: ChannelOffChainTx) => Buffer;
        };
        version: {
            constValue: 2;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 2;
            serialize: (value?: 2) => Buffer;
        };
    }
    | {
        channelId: {
            deserialize: (value: Buffer) => `ch_${string}`;
            serialize: (value: `ch_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        fromId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { fromId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        payload: {
            deserialize: (value: Buffer) => `tx_${string}`;
            serialize: (value: `tx_${string}`) => Buffer;
        };
        tag: {
            constValue: ChannelSnapshotSoloTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => ChannelSnapshotSoloTx;
            serialize: (value: ChannelSnapshotSoloTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): Buffer;
        };
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    }
    | {
        authFun: {
            deserialize(buffer: Buffer): Buffer;
            serialize(buffer: Uint8Array): 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;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        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;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { ownerId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        ownerId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        tag: {
            constValue: GaAttachTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => GaAttachTx;
            serialize: (value: GaAttachTx) => Buffer;
        };
        ttl: {
            deserialize(value: Buffer): number;
            prepare(
                value: undefined | number,
                params: {},
                __namedParameters: {
                    _isInternalBuild?: boolean;
                    absoluteTtl?: boolean;
                    onNode?: Node;
                } & Omit<
                    {
                        _expectedMineRate?: number;
                        _microBlockCycle?: number;
                        onNode: Node;
                    },
                    "onNode",
                >,
            ): Promise<undefined | number>;
            serialize(value: undefined | number): 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;
        };
        authData: {
            deserialize: (value: Buffer) => `cb_${string}`;
            serialize: (value: `cb_${string}`) => Buffer;
        };
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        gaId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${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: GaMetaTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => GaMetaTx;
            serialize: (value: GaMetaTx) => Buffer;
        };
        tx: TransactionSignedTx;
        version: {
            constValue: 2;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 2;
            serialize: (value?: 2) => Buffer;
        };
    }
    | {
        fee: {
            deserialize(value: Buffer): string;
            prepare(
                value: Int | undefined,
                params: {},
                __namedParameters: { onNode?: Node },
            ): Promise<(Int | undefined)>;
            serialize(
                value: Int | undefined,
                params: SerializeAettosParams,
                options: { _canIncreaseFee?: boolean } & {
                    denomination?: AE_AMOUNT_FORMATS | undefined;
                },
            ): Buffer;
            serializeAettos(
                _value: undefined | string,
                __namedParameters: SerializeAettosParams,
                __namedParameters: { _canIncreaseFee?: boolean },
            ): string;
        };
        nonce: {
            deserialize: (value: Buffer) => number;
            prepare: (
                value: undefined | number,
                params: {},
                options: { payerId: string } & {
                    _isInternalBuild?: boolean;
                    onNode?: Node;
                    strategy?: Enum1 | undefined;
                },
            ) => Promise<number>;
            senderKey: string;
            serialize: (value: number, params: { tag: Tag }) => Buffer;
        };
        payerId: {
            deserialize: (value: Buffer) => `ak_${string}`;
            serialize: (value: `ak_${string}`) => Buffer;
        };
        tag: {
            constValue: PayingForTx;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => PayingForTx;
            serialize: (value: PayingForTx) => Buffer;
        };
        tx: TransactionSignedTx;
        version: {
            constValue: 1;
            constValueOptional: boolean;
            deserialize: (value: Buffer) => 1;
            serialize: (value?: 1) => Buffer;
        };
    },
> & { tag: SignedTx }
recursiveType: true
serialize: (
    value:
        | Uint8Array
        | `tx_${string}`
        | (
            ((TxParamsBySchemaInternal<PickIsRec<{ readonly tag: { serialize: (value: Tag.SignedTx) => Buffer; deserialize: (value: Buffer) => Tag.SignedTx; constValue: Tag.SignedTx; constValueOptional: boolean; }; readonly version: { ...; }; readonly signatures: { ...; }; readonly encodedTx: TransactionAny; }, true>> & Partial...
        ),
) => Buffer