Interface TransactionAny

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