Interface TxUnpackedGaMetaTx2

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