Interface TxParamsSignedTx1

interface TxParamsSignedTx1 {
    encodedTx:
        | Uint8Array
        | `tx_${string}`
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            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;
                            };
                        },
                        false,
                    >,
                >,
                "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        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;
                        };
                    },
                    false,
                >,
            >,
            "version",
        >
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    amount: {
                        deserialize(value: Buffer): string;
                        serialize(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                        ): Buffer;
                        serializeAettos(
                            value: undefined | string,
                            params: {},
                            options: {},
                        ): string;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            amount: {
                                deserialize(value: Buffer): string;
                                serialize(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                                ): Buffer;
                                serializeAettos(
                                    value: undefined | string,
                                    params: {},
                                    options: {},
                                ): string;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): Buffer;
                                serializeAettos(
                                    _value: undefined | string,
                                    __namedParameters: SerializeAettosParams,
                                    __namedParameters: { _canIncreaseFee?: boolean },
                                ): string;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { senderId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => Promise<number>;
                                senderKey: string;
                                serialize: (value: number, params: { tag: Tag }) => Buffer;
                            };
                            payload: {
                                deserialize: (value: Buffer) => `ba_${string}`;
                                serialize: (value?: `ba_${(...)}`) => Buffer;
                            };
                            recipientId: {
                                deserialize: (
                                    value: Buffer,
                                ) => `ct_${(...)}` | `ak_${(...)}` | `nm_${(...)}`;
                                serialize: (
                                    value: `ct_${(...)}` | `ak_${(...)}` | `nm_${(...)}`,
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "amount"
                | "fee"
                | "ttl"
                | "payload"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        amount: {
                            deserialize(value: Buffer): string;
                            serialize(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                            ): Buffer;
                            serializeAettos(
                                value: undefined | string,
                                params: {},
                                options: {},
                            ): string;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "amount"
            | "fee"
            | "ttl"
            | "payload"
            | "version",
        > & { denomination?: AE_AMOUNT_FORMATS } & { _canIncreaseFee?: boolean }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    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: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            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: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): Buffer;
                                serializeAettos(
                                    _value: undefined | string,
                                    __namedParameters: SerializeAettosParams,
                                    __namedParameters: { _canIncreaseFee?: boolean },
                                ): string;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { accountId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        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: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    accountId: {
                        deserialize: (value: Buffer) => `ak_${string}`;
                        serialize: (value: `ak_${string}`) => Buffer;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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: undefined | Int,
                            txFields: { name: `${string}.chain` },
                            parameters: { denomination?: AE_AMOUNT_FORMATS },
                        ): Buffer;
                        serializeAettos(
                            _value: undefined | string,
                            txFields: { name: `${string}.chain` },
                        ): string;
                    };
                    nameSalt: {
                        deserialize: (value: Buffer, params: unknown) => string;
                        serialize: (value: undefined | Int, params: unknown) => Buffer;
                    };
                    nonce: {
                        deserialize: (value: Buffer) => number;
                        prepare: (
                            value: undefined | number,
                            params: {},
                            options: { accountId: string } & {
                                _isInternalBuild?: boolean;
                                onNode?: Node;
                                strategy?: Enum1;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            accountId: {
                                deserialize: (value: Buffer) => `ak_${string}`;
                                serialize: (value: `ak_${string}`) => Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: undefined | Int,
                                    txFields: { name: `${string}.chain` },
                                    parameters: { denomination?: AE_AMOUNT_FORMATS },
                                ): Buffer;
                                serializeAettos(
                                    _value: undefined | string,
                                    txFields: { name: `${string}.chain` },
                                ): string;
                            };
                            nameSalt: {
                                deserialize: (value: Buffer, params: unknown) => string;
                                serialize: (value: undefined | Int, params: unknown) => Buffer;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { accountId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 2;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 2;
                                serialize: (value?: 2) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "nameSalt"
                | "nameFee"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        accountId: {
                            deserialize: (value: Buffer) => `ak_${string}`;
                            serialize: (value: `ak_${string}`) => Buffer;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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: undefined | Int,
                                txFields: { name: `${string}.chain` },
                                parameters: { denomination?: AE_AMOUNT_FORMATS },
                            ): Buffer;
                            serializeAettos(
                                _value: undefined | string,
                                txFields: { name: `${string}.chain` },
                            ): string;
                        };
                        nameSalt: {
                            deserialize: (value: Buffer, params: unknown) => string;
                            serialize: (value: undefined | Int, params: unknown) => Buffer;
                        };
                        nonce: {
                            deserialize: (value: Buffer) => number;
                            prepare: (
                                value: undefined | number,
                                params: {},
                                options: { accountId: string } & {
                                    _isInternalBuild?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 2;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 2;
                            serialize: (value?: 2) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "nameSalt"
            | "nameFee"
            | "version",
        > & { denomination?: AE_AMOUNT_FORMATS } & { _canIncreaseFee?: boolean }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    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: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            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: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => Promise<number>;
                                senderKey: string;
                                serialize: (value: number, params: { tag: Tag }) => Buffer;
                            };
                            pointers: {
                                deserialize: (pointers: [key: ..., id: ...][]) => NamePointer[];
                                serialize: (pointers: NamePointer[]) => (...)[][];
                            };
                            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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "nameTtl"
                | "clientTtl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        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: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "nameTtl"
            | "clientTtl"
            | "version",
        >
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    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: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            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: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => Promise<number>;
                                senderKey: string;
                                serialize: (value: number, params: { tag: Tag }) => Buffer;
                            };
                            pointers: {
                                deserialize: (
                                    pointers: [key: ..., id: ...][],
                                ) => NamePointerRaw[];
                                serialize: (pointers: NamePointerRaw[]) => (...)[][];
                            };
                            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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 2;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 2;
                                serialize: (value: 2) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "nameTtl"
                | "clientTtl",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        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: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 2;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 2;
                            serialize: (value: 2) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "nameTtl"
            | "clientTtl",
        >
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    accountId: {
                        deserialize: (value: Buffer) => `ak_${string}`;
                        serialize: (value: `ak_${string}`) => Buffer;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            accountId: {
                                deserialize: (value: Buffer) => `ak_${string}`;
                                serialize: (value: `ak_${string}`) => Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => Promise<number>;
                                senderKey: string;
                                serialize: (value: number, params: { tag: Tag }) => Buffer;
                            };
                            recipientId: {
                                deserialize: (value: Buffer) => `ak_${(...)}` | `nm_${(...)}`;
                                serialize: (value: `ak_${(...)}` | `nm_${(...)}`) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        accountId: {
                            deserialize: (value: Buffer) => `ak_${string}`;
                            serialize: (value: `ak_${string}`) => Buffer;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    accountId: {
                        deserialize: (value: Buffer) => `ak_${string}`;
                        serialize: (value: `ak_${string}`) => Buffer;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            accountId: {
                                deserialize: (value: Buffer) => `ak_${string}`;
                                serialize: (value: `ak_${string}`) => Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        accountId: {
                            deserialize: (value: Buffer) => `ak_${string}`;
                            serialize: (value: `ak_${string}`) => Buffer;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    amount: {
                        deserialize(value: Buffer): string;
                        serialize(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                        ): 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: undefined | Int,
                            params: {},
                            options: { denomination?: AE_AMOUNT_FORMATS },
                        ) => Buffer;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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: undefined | Int,
                            params: {},
                            __namedParameters: {
                                denomination?: AE_AMOUNT_FORMATS;
                                onNode?: Node;
                            },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            amount: {
                                deserialize(value: Buffer): string;
                                serialize(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                                ): 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: undefined | Int,
                                    params: {},
                                    options: { denomination?: (...) | (...) },
                                ) => Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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_${(...)}`;
                                        rebuildTx: (params: any) => any;
                                        tag: Tag;
                                        unpackTx: <TxType extends Tag>(
                                            encodedTx: (...) | (...) | (...) | (...),
                                            txType?: (...) | (...),
                                        ) => (...) & (...);
                                    },
                                    __namedParameters: { gasMax?: number },
                                ): Buffer;
                            };
                            gasPrice: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: {
                                        denomination?: AE_AMOUNT_FORMATS;
                                        onNode?: Node;
                                    },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                                ): Buffer;
                                serializeAettos(value?: undefined | string): string;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { ownerId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                | "amount"
                | "fee"
                | "ttl"
                | "deposit"
                | "gasPrice"
                | "version"
                | "ctVersion"
                | "gasLimit",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        amount: {
                            deserialize(value: Buffer): string;
                            serialize(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                            ): 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: undefined | Int,
                                params: {},
                                options: { denomination?: AE_AMOUNT_FORMATS },
                            ) => Buffer;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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_${(...)}`
                                            | `pi_${(...)}`
                                            | `ss_${(...)}`
                                            | `cs_${(...)}`,
                                        txType?: TxType,
                                    ) => TxUnpacked & { tag: ... };
                                },
                                __namedParameters: { gasMax?: number },
                            ): Buffer;
                        };
                        gasPrice: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: {
                                    denomination?: AE_AMOUNT_FORMATS;
                                    onNode?: Node;
                                },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                            ): Buffer;
                            serializeAettos(value?: undefined | string): string;
                        };
                        nonce: {
                            deserialize: (value: Buffer) => number;
                            prepare: (
                                value: undefined | number,
                                params: {},
                                options: { ownerId: string } & {
                                    _isInternalBuild?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            | "amount"
            | "fee"
            | "ttl"
            | "deposit"
            | "gasPrice"
            | "version"
            | "ctVersion"
            | "gasLimit",
        > & { denomination?: AE_AMOUNT_FORMATS } & { _canIncreaseFee?: boolean } & {
            consensusProtocolVersion?: Ceres;
        } & { gasMax?: number }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    abiVersion: {
                        _getProtocolDetails(c: Ceres, tag: Tag): AbiVersion;
                        deserialize(buffer: Buffer): AbiVersion;
                        prepare(
                            value: undefined | AbiVersion,
                            __namedParameters: { tag: Tag },
                            options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                        ): Promise<undefined | AbiVersion>;
                        serialize(
                            value: undefined | AbiVersion,
                            __namedParameters: { tag: Tag },
                            __namedParameters: { consensusProtocolVersion?: Ceres },
                        ): Buffer;
                    };
                    amount: {
                        deserialize(value: Buffer): string;
                        serialize(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                        ): 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: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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: undefined | Int,
                            params: {},
                            __namedParameters: {
                                denomination?: AE_AMOUNT_FORMATS;
                                onNode?: Node;
                            },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            abiVersion: {
                                _getProtocolDetails(c: Ceres, tag: Tag): AbiVersion;
                                deserialize(buffer: Buffer): AbiVersion;
                                prepare(
                                    value: undefined | AbiVersion,
                                    __namedParameters: { tag: Tag },
                                    options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                                ): Promise<undefined | AbiVersion>;
                                serialize(
                                    value: undefined | AbiVersion,
                                    __namedParameters: { tag: Tag },
                                    __namedParameters: { consensusProtocolVersion?: Ceres },
                                ): Buffer;
                            };
                            amount: {
                                deserialize(value: Buffer): string;
                                serialize(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                                ): 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_${(...)}` | `nm_${(...)}`;
                                serialize: (value: `ct_${(...)}` | `nm_${(...)}`) => Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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_${(...)}`;
                                        rebuildTx: (params: any) => any;
                                        tag: Tag;
                                        unpackTx: <TxType extends Tag>(
                                            encodedTx: (...) | (...) | (...) | (...),
                                            txType?: (...) | (...),
                                        ) => (...) & (...);
                                    },
                                    __namedParameters: { gasMax?: number },
                                ): Buffer;
                            };
                            gasPrice: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: {
                                        denomination?: AE_AMOUNT_FORMATS;
                                        onNode?: Node;
                                    },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                                ): Buffer;
                                serializeAettos(value?: undefined | string): string;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { callerId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                | "amount"
                | "fee"
                | "ttl"
                | "abiVersion"
                | "gasPrice"
                | "version"
                | "gasLimit",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        abiVersion: {
                            _getProtocolDetails(c: Ceres, tag: Tag): AbiVersion;
                            deserialize(buffer: Buffer): AbiVersion;
                            prepare(
                                value: undefined | AbiVersion,
                                __namedParameters: { tag: Tag },
                                options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                            ): Promise<undefined | AbiVersion>;
                            serialize(
                                value: undefined | AbiVersion,
                                __namedParameters: { tag: Tag },
                                __namedParameters: { consensusProtocolVersion?: Ceres },
                            ): Buffer;
                        };
                        amount: {
                            deserialize(value: Buffer): string;
                            serialize(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                            ): 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: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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_${(...)}`
                                            | `pi_${(...)}`
                                            | `ss_${(...)}`
                                            | `cs_${(...)}`,
                                        txType?: TxType,
                                    ) => TxUnpacked & { tag: ... };
                                },
                                __namedParameters: { gasMax?: number },
                            ): Buffer;
                        };
                        gasPrice: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: {
                                    denomination?: AE_AMOUNT_FORMATS;
                                    onNode?: Node;
                                },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                            ): Buffer;
                            serializeAettos(value?: undefined | string): string;
                        };
                        nonce: {
                            deserialize: (value: Buffer) => number;
                            prepare: (
                                value: undefined | number,
                                params: {},
                                options: { callerId: string } & {
                                    _isInternalBuild?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            | "amount"
            | "fee"
            | "ttl"
            | "abiVersion"
            | "gasPrice"
            | "version"
            | "gasLimit",
        > & { denomination?: AE_AMOUNT_FORMATS } & { _canIncreaseFee?: boolean } & {
            gasMax?: number;
        } & { consensusProtocolVersion?: Ceres }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    abiVersion: {
                        _getProtocolDetails(c: Ceres, tag: Tag): AbiVersion;
                        deserialize(buffer: Buffer): AbiVersion;
                        prepare(
                            value: undefined | AbiVersion,
                            __namedParameters: { tag: Tag },
                            options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                        ): Promise<undefined | AbiVersion>;
                        serialize(
                            value: undefined | AbiVersion,
                            __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: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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: undefined | Int,
                            params: {},
                            __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                        ): 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            abiVersion: {
                                _getProtocolDetails(c: Ceres, tag: Tag): AbiVersion;
                                deserialize(buffer: Buffer): AbiVersion;
                                prepare(
                                    value: undefined | AbiVersion,
                                    __namedParameters: { tag: Tag },
                                    options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                                ): Promise<undefined | AbiVersion>;
                                serialize(
                                    value: undefined | AbiVersion,
                                    __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: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): Buffer;
                                serializeAettos(
                                    _value: undefined | string,
                                    __namedParameters: SerializeAettosParams,
                                    __namedParameters: { _canIncreaseFee?: boolean },
                                ): string;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { accountId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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: undefined | Int,
                                    params: {},
                                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                                ): 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                | "fee"
                | "ttl"
                | "queryFee"
                | "abiVersion"
                | "version"
                | "oracleTtlType"
                | "oracleTtlValue",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        abiVersion: {
                            _getProtocolDetails(c: Ceres, tag: Tag): AbiVersion;
                            deserialize(buffer: Buffer): AbiVersion;
                            prepare(
                                value: undefined | AbiVersion,
                                __namedParameters: { tag: Tag },
                                options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                            ): Promise<undefined | AbiVersion>;
                            serialize(
                                value: undefined | AbiVersion,
                                __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: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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: undefined | Int,
                                params: {},
                                __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                            ): 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            | "fee"
            | "ttl"
            | "queryFee"
            | "abiVersion"
            | "version"
            | "oracleTtlType"
            | "oracleTtlValue",
        > & { denomination?: AE_AMOUNT_FORMATS } & { _canIncreaseFee?: boolean } & {
            consensusProtocolVersion?: Ceres;
        }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): Buffer;
                                serializeAettos(
                                    _value: undefined | string,
                                    __namedParameters: SerializeAettosParams,
                                    __namedParameters: { _canIncreaseFee?: boolean },
                                ): string;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { oracleId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => Promise<number>;
                                senderKey: string;
                                serialize: (value: number, params: { tag: Tag }) => Buffer;
                            };
                            oracleId: {
                                deserialize: (value: Buffer) => `ok_${(...)}` | `nm_${(...)}`;
                                serialize: (value: `ok_${(...)}` | `nm_${(...)}`) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version"
                | "oracleTtlType"
                | "oracleTtlValue",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version"
            | "oracleTtlType"
            | "oracleTtlValue",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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: undefined | Int,
                            params: {},
                            options: { onNode?: Node; oracleId?: `ok_${string}` },
                        ): Promise<Int>;
                        serialize(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                        ): 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): Buffer;
                                serializeAettos(
                                    _value: undefined | string,
                                    __namedParameters: SerializeAettosParams,
                                    __namedParameters: { _canIncreaseFee?: boolean },
                                ): string;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { senderId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => Promise<number>;
                                senderKey: string;
                                serialize: (value: number, params: { tag: Tag }) => Buffer;
                            };
                            oracleId: {
                                deserialize: (value: Buffer) => `ok_${(...)}` | `nm_${(...)}`;
                                serialize: (value: `ok_${(...)}` | `nm_${(...)}`) => Buffer;
                            };
                            query: {
                                deserialize(buffer: Buffer): string;
                                serialize(string: string): Buffer;
                            };
                            queryFee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    options: { onNode?: Node; oracleId?: `ok_${(...)}` },
                                ): Promise<Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                                ): 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                | "fee"
                | "ttl"
                | "queryFee"
                | "version"
                | "queryTtlType"
                | "queryTtlValue"
                | "responseTtlType"
                | "responseTtlValue",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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: undefined | Int,
                                params: {},
                                options: { onNode?: Node; oracleId?: `ok_${string}` },
                            ): Promise<Int>;
                            serialize(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                            ): 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            | "fee"
            | "ttl"
            | "queryFee"
            | "version"
            | "queryTtlType"
            | "queryTtlValue"
            | "responseTtlType"
            | "responseTtlValue",
        > & { denomination?: AE_AMOUNT_FORMATS } & { _canIncreaseFee?: boolean }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): Buffer;
                                serializeAettos(
                                    _value: undefined | string,
                                    __namedParameters: SerializeAettosParams,
                                    __namedParameters: { _canIncreaseFee?: boolean },
                                ): string;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { oracleId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version"
                | "responseTtlType"
                | "responseTtlValue",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version"
            | "responseTtlType"
            | "responseTtlValue",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    channelReserve: {
                        deserialize(value: Buffer): string;
                        serialize(value: Int): Buffer;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            channelReserve: {
                                deserialize(value: Buffer): string;
                                serialize(value: Int): Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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,
                                ) => ((...) | (...) | (...) | (...) | (...) | (...))[];
                                serialize: (
                                    value: readonly ((...) | (...) | (...) | (...) | (...) | (...))[],
                                    params: unknown,
                                ) => Buffer[];
                            };
                            lockPeriod: {
                                deserialize(value: Buffer): string;
                                serialize(value: Int): Buffer;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { initiator: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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,
                                ) => ((...) | (...) | (...) | (...) | (...) | (...))[];
                                serialize: (
                                    value: readonly ((...) | (...) | (...) | (...) | (...) | (...))[],
                                    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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 2;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 2;
                                serialize: (value?: 2) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        channelReserve: {
                            deserialize(value: Buffer): string;
                            serialize(value: Int): Buffer;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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_${(...)}`
                                | `ct_${(...)}`
                                | `ok_${(...)}`
                                | `ak_${(...)}`
                                | `cm_${(...)}`
                                | `nm_${(...)}`
                            )[];
                            serialize: (
                                value: readonly (
                                    | `ch_${(...)}`
                                    | `ct_${(...)}`
                                    | `ok_${(...)}`
                                    | `ak_${(...)}`
                                    | `cm_${(...)}`
                                    | `nm_${(...)}`
                                )[],
                                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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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_${(...)}`
                                | `ct_${(...)}`
                                | `ok_${(...)}`
                                | `ak_${(...)}`
                                | `cm_${(...)}`
                                | `nm_${(...)}`
                            )[];
                            serialize: (
                                value: readonly (
                                    | `ch_${(...)}`
                                    | `ct_${(...)}`
                                    | `ok_${(...)}`
                                    | `ak_${(...)}`
                                    | `cm_${(...)}`
                                    | `nm_${(...)}`
                                )[],
                                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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 2;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 2;
                            serialize: (value?: 2) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    channelId: {
                        deserialize: (value: Buffer) => `ch_${string}`;
                        serialize: (value: `ch_${string}`) => Buffer;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            channelId: {
                                deserialize: (value: Buffer) => `ch_${string}`;
                                serialize: (value: `ch_${string}`) => Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        channelId: {
                            deserialize: (value: Buffer) => `ch_${string}`;
                            serialize: (value: `ch_${string}`) => Buffer;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    channelId: {
                        deserialize: (value: Buffer) => `ch_${string}`;
                        serialize: (value: `ch_${string}`) => Buffer;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            channelId: {
                                deserialize: (value: Buffer) => `ch_${string}`;
                                serialize: (value: `ch_${string}`) => Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        channelId: {
                            deserialize: (value: Buffer) => `ch_${string}`;
                            serialize: (value: `ch_${string}`) => Buffer;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    channelId: {
                        deserialize: (value: Buffer) => `ch_${string}`;
                        serialize: (value: `ch_${string}`) => Buffer;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            channelId: {
                                deserialize: (value: Buffer) => `ch_${string}`;
                                serialize: (value: `ch_${string}`) => Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        channelId: {
                            deserialize: (value: Buffer) => `ch_${string}`;
                            serialize: (value: `ch_${string}`) => Buffer;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    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: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            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: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        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: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    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: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            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: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): Buffer;
                                serializeAettos(
                                    _value: undefined | string,
                                    __namedParameters: SerializeAettosParams,
                                    __namedParameters: { _canIncreaseFee?: boolean },
                                ): string;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { fromId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        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: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    channelId: {
                        deserialize: (value: Buffer) => `ch_${string}`;
                        serialize: (value: `ch_${string}`) => Buffer;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            channelId: {
                                deserialize: (value: Buffer) => `ch_${string}`;
                                serialize: (value: `ch_${string}`) => Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        channelId: {
                            deserialize: (value: Buffer) => `ch_${string}`;
                            serialize: (value: `ch_${string}`) => Buffer;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    channelId: {
                        deserialize: (value: Buffer) => `ch_${string}`;
                        serialize: (value: `ch_${string}`) => Buffer;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            channelId: {
                                deserialize: (value: Buffer) => `ch_${string}`;
                                serialize: (value: `ch_${string}`) => Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "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;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        channelId: {
                            deserialize: (value: Buffer) => `ch_${string}`;
                            serialize: (value: `ch_${string}`) => Buffer;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        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;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            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;
                            };
                        },
                        false,
                    >,
                >,
                "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        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;
                        };
                    },
                    false,
                >,
            >,
            "version",
        >
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    channelId: {
                        deserialize: (value: Buffer) => `ch_${string}`;
                        serialize: (value: `ch_${string}`) => Buffer;
                    };
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            channelId: {
                                deserialize: (value: Buffer) => `ch_${string}`;
                                serialize: (value: `ch_${string}`) => Buffer;
                            };
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        channelId: {
                            deserialize: (value: Buffer) => `ch_${string}`;
                            serialize: (value: `ch_${string}`) => Buffer;
                        };
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    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: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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: undefined | Int,
                            params: {},
                            __namedParameters: {
                                denomination?: AE_AMOUNT_FORMATS;
                                onNode?: Node;
                            },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            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: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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_${(...)}`;
                                        rebuildTx: (params: any) => any;
                                        tag: Tag;
                                        unpackTx: <TxType extends Tag>(
                                            encodedTx: (...) | (...) | (...) | (...),
                                            txType?: (...) | (...),
                                        ) => (...) & (...);
                                    },
                                    __namedParameters: { gasMax?: number },
                                ): Buffer;
                            };
                            gasPrice: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: {
                                        denomination?: AE_AMOUNT_FORMATS;
                                        onNode?: Node;
                                    },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                                ): Buffer;
                                serializeAettos(value?: undefined | string): string;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { ownerId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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?: (...) | (...) | (...);
                                        absoluteTtl?: (...) | (...) | (...);
                                        onNode?: (...) | (...);
                                    } & Omit<
                                        {
                                            _expectedMineRate?: ...;
                                            _microBlockCycle?: ...;
                                            onNode: ...;
                                        },
                                        "onNode",
                                    >,
                                ): Promise<undefined | number>;
                                serialize(value: undefined | number): Buffer;
                            };
                            version: {
                                constValue: 1;
                                constValueOptional: boolean;
                                deserialize: (value: Buffer) => 1;
                                serialize: (value?: 1) => Buffer;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "ttl"
                | "gasPrice"
                | "version"
                | "ctVersion"
                | "gasLimit",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        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: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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_${(...)}`
                                            | `pi_${(...)}`
                                            | `ss_${(...)}`
                                            | `cs_${(...)}`,
                                        txType?: TxType,
                                    ) => TxUnpacked & { tag: ... };
                                },
                                __namedParameters: { gasMax?: number },
                            ): Buffer;
                        };
                        gasPrice: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: {
                                    denomination?: AE_AMOUNT_FORMATS;
                                    onNode?: Node;
                                },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                            ): Buffer;
                            serializeAettos(value?: undefined | string): string;
                        };
                        nonce: {
                            deserialize: (value: Buffer) => number;
                            prepare: (
                                value: undefined | number,
                                params: {},
                                options: { ownerId: string } & {
                                    _isInternalBuild?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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?: (...)
                                        | (...);
                                        _microBlockCycle?: (...) | (...);
                                        onNode: Node;
                                    },
                                    "onNode",
                                >,
                            ): Promise<undefined | number>;
                            serialize(value: undefined | number): Buffer;
                        };
                        version: {
                            constValue: 1;
                            constValueOptional: boolean;
                            deserialize: (value: Buffer) => 1;
                            serialize: (value?: 1) => Buffer;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "ttl"
            | "gasPrice"
            | "version"
            | "ctVersion"
            | "gasLimit",
        > & { denomination?: AE_AMOUNT_FORMATS } & { _canIncreaseFee?: boolean } & {
            consensusProtocolVersion?: Ceres;
        } & { gasMax?: number }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    abiVersion: {
                        _getProtocolDetails(c: Ceres, tag: Tag): AbiVersion;
                        deserialize(buffer: Buffer): AbiVersion;
                        prepare(
                            value: undefined | AbiVersion,
                            __namedParameters: { tag: Tag },
                            options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                        ): Promise<undefined | AbiVersion>;
                        serialize(
                            value: undefined | AbiVersion,
                            __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: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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: undefined | Int,
                            params: {},
                            __namedParameters: {
                                denomination?: AE_AMOUNT_FORMATS;
                                onNode?: Node;
                            },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                        ): 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            abiVersion: {
                                _getProtocolDetails(c: Ceres, tag: Tag): AbiVersion;
                                deserialize(buffer: Buffer): AbiVersion;
                                prepare(
                                    value: undefined | AbiVersion,
                                    __namedParameters: { tag: Tag },
                                    options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                                ): Promise<undefined | AbiVersion>;
                                serialize(
                                    value: undefined | AbiVersion,
                                    __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: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): 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_${(...)}`;
                                        rebuildTx: (params: any) => any;
                                        tag: Tag;
                                        unpackTx: <TxType extends Tag>(
                                            encodedTx: (...) | (...) | (...) | (...),
                                            txType?: (...) | (...),
                                        ) => (...) & (...);
                                    },
                                    __namedParameters: { gasMax?: number },
                                ): Buffer;
                            };
                            gasPrice: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: {
                                        denomination?: AE_AMOUNT_FORMATS;
                                        onNode?: Node;
                                    },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                                ): 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;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "abiVersion"
                | "gasPrice"
                | "version"
                | "gasLimit",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        abiVersion: {
                            _getProtocolDetails(c: Ceres, tag: Tag): AbiVersion;
                            deserialize(buffer: Buffer): AbiVersion;
                            prepare(
                                value: undefined | AbiVersion,
                                __namedParameters: { tag: Tag },
                                options: { consensusProtocolVersion?: Ceres; onNode?: Node },
                            ): Promise<undefined | AbiVersion>;
                            serialize(
                                value: undefined | AbiVersion,
                                __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: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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_${(...)}`
                                            | `pi_${(...)}`
                                            | `ss_${(...)}`
                                            | `cs_${(...)}`,
                                        txType?: TxType,
                                    ) => TxUnpacked & { tag: ... };
                                },
                                __namedParameters: { gasMax?: number },
                            ): Buffer;
                        };
                        gasPrice: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: {
                                    denomination?: AE_AMOUNT_FORMATS;
                                    onNode?: Node;
                                },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { denomination?: AE_AMOUNT_FORMATS },
                            ): 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;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "abiVersion"
            | "gasPrice"
            | "version"
            | "gasLimit",
        > & { denomination?: AE_AMOUNT_FORMATS } & { _canIncreaseFee?: boolean } & {
            gasMax?: number;
        } & { consensusProtocolVersion?: Ceres }
        | TxParamsBySchemaInternal<
            PickIsRec<
                {
                    fee: {
                        deserialize(value: Buffer): string;
                        prepare(
                            value: undefined | Int,
                            params: {},
                            __namedParameters: { onNode?: Node },
                        ): Promise<undefined | Int>;
                        serialize(
                            value: undefined | Int,
                            params: SerializeAettosParams,
                            options: { _canIncreaseFee?: boolean } & {
                                denomination?: AE_AMOUNT_FORMATS;
                            },
                        ): 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;
                            },
                        ) => 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;
                    };
                },
                true,
            >,
        > & Partial<
            Pick<
                TxParamsBySchemaInternal<
                    PickIsRec<
                        {
                            fee: {
                                deserialize(value: Buffer): string;
                                prepare(
                                    value: undefined | Int,
                                    params: {},
                                    __namedParameters: { onNode?: Node },
                                ): Promise<undefined | Int>;
                                serialize(
                                    value: undefined | Int,
                                    params: SerializeAettosParams,
                                    options: { _canIncreaseFee?: (...) | (...) | (...) } & {
                                        denomination?: (...) | (...);
                                    },
                                ): Buffer;
                                serializeAettos(
                                    _value: undefined | string,
                                    __namedParameters: SerializeAettosParams,
                                    __namedParameters: { _canIncreaseFee?: boolean },
                                ): string;
                            };
                            nonce: {
                                deserialize: (value: Buffer) => number;
                                prepare: (
                                    value: undefined | number,
                                    params: {},
                                    options: { payerId: ... } & {
                                        _isInternalBuild?: ...;
                                        onNode?: ...;
                                        strategy?: ...;
                                    },
                                ) => 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;
                            };
                        },
                        false,
                    >,
                >,
                "fee"
                | "version",
            >,
        > & Omit<
            TxParamsBySchemaInternal<
                PickIsRec<
                    {
                        fee: {
                            deserialize(value: Buffer): string;
                            prepare(
                                value: undefined | Int,
                                params: {},
                                __namedParameters: { onNode?: Node },
                            ): Promise<undefined | Int>;
                            serialize(
                                value: undefined | Int,
                                params: SerializeAettosParams,
                                options: { _canIncreaseFee?: boolean } & {
                                    denomination?: AE_AMOUNT_FORMATS;
                                },
                            ): 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?: (...) | (...) | (...);
                                    onNode?: (...) | (...);
                                    strategy?: (...) | (...);
                                },
                            ) => 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;
                        };
                    },
                    false,
                >,
            >,
            "fee"
            | "version",
        > & { _canIncreaseFee?: boolean } & { denomination?: AE_AMOUNT_FORMATS };
    signatures: readonly Uint8Array[];
    tag: SignedTx;
    version?: 1;
}