Variable txSchemaConst

txSchema: readonly [{
    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);
    };
}] = ...