@keepkey/device-protocol 7.10.1 → 7.10.2

package/lib/messages-osmosis_pb.d.ts

@@ -0,0 +1,774 @@
+// package: 
+// file: messages-osmosis.proto
+
+import * as jspb from "google-protobuf";
+import * as types_pb from "./types_pb";
+
+export class OsmosisGetAddress extends jspb.Message {
+  clearAddressNList(): void;
+  getAddressNList(): Array<number>;
+  setAddressNList(value: Array<number>): void;
+  addAddressN(value: number, index?: number): number;
+
+  hasShowDisplay(): boolean;
+  clearShowDisplay(): void;
+  getShowDisplay(): boolean | undefined;
+  setShowDisplay(value: boolean): void;
+
+  hasTestnet(): boolean;
+  clearTestnet(): void;
+  getTestnet(): boolean | undefined;
+  setTestnet(value: boolean): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisGetAddress.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisGetAddress): OsmosisGetAddress.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisGetAddress, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisGetAddress;
+  static deserializeBinaryFromReader(message: OsmosisGetAddress, reader: jspb.BinaryReader): OsmosisGetAddress;
+}
+
+export namespace OsmosisGetAddress {
+  export type AsObject = {
+    addressNList: Array<number>,
+    showDisplay?: boolean,
+    testnet?: boolean,
+  }
+}
+
+export class OsmosisAddress extends jspb.Message {
+  hasAddress(): boolean;
+  clearAddress(): void;
+  getAddress(): string | undefined;
+  setAddress(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisAddress.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisAddress): OsmosisAddress.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisAddress, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisAddress;
+  static deserializeBinaryFromReader(message: OsmosisAddress, reader: jspb.BinaryReader): OsmosisAddress;
+}
+
+export namespace OsmosisAddress {
+  export type AsObject = {
+    address?: string,
+  }
+}
+
+export class OsmosisSignTx extends jspb.Message {
+  clearAddressNList(): void;
+  getAddressNList(): Array<number>;
+  setAddressNList(value: Array<number>): void;
+  addAddressN(value: number, index?: number): number;
+
+  hasAccountNumber(): boolean;
+  clearAccountNumber(): void;
+  getAccountNumber(): string | undefined;
+  setAccountNumber(value: string): void;
+
+  hasChainId(): boolean;
+  clearChainId(): void;
+  getChainId(): string | undefined;
+  setChainId(value: string): void;
+
+  hasFeeAmount(): boolean;
+  clearFeeAmount(): void;
+  getFeeAmount(): number | undefined;
+  setFeeAmount(value: number): void;
+
+  hasGas(): boolean;
+  clearGas(): void;
+  getGas(): number | undefined;
+  setGas(value: number): void;
+
+  hasMemo(): boolean;
+  clearMemo(): void;
+  getMemo(): string | undefined;
+  setMemo(value: string): void;
+
+  hasSequence(): boolean;
+  clearSequence(): void;
+  getSequence(): string | undefined;
+  setSequence(value: string): void;
+
+  hasMsgCount(): boolean;
+  clearMsgCount(): void;
+  getMsgCount(): number | undefined;
+  setMsgCount(value: number): void;
+
+  hasTestnet(): boolean;
+  clearTestnet(): void;
+  getTestnet(): boolean | undefined;
+  setTestnet(value: boolean): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisSignTx.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisSignTx): OsmosisSignTx.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisSignTx, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisSignTx;
+  static deserializeBinaryFromReader(message: OsmosisSignTx, reader: jspb.BinaryReader): OsmosisSignTx;
+}
+
+export namespace OsmosisSignTx {
+  export type AsObject = {
+    addressNList: Array<number>,
+    accountNumber?: string,
+    chainId?: string,
+    feeAmount?: number,
+    gas?: number,
+    memo?: string,
+    sequence?: string,
+    msgCount?: number,
+    testnet?: boolean,
+  }
+}
+
+export class OsmosisMsgRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgRequest): OsmosisMsgRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgRequest;
+  static deserializeBinaryFromReader(message: OsmosisMsgRequest, reader: jspb.BinaryReader): OsmosisMsgRequest;
+}
+
+export namespace OsmosisMsgRequest {
+  export type AsObject = {
+  }
+}
+
+export class OsmosisMsgAck extends jspb.Message {
+  hasSend(): boolean;
+  clearSend(): void;
+  getSend(): OsmosisMsgSend | undefined;
+  setSend(value?: OsmosisMsgSend): void;
+
+  hasDelegate(): boolean;
+  clearDelegate(): void;
+  getDelegate(): OsmosisMsgDelegate | undefined;
+  setDelegate(value?: OsmosisMsgDelegate): void;
+
+  hasUndelegate(): boolean;
+  clearUndelegate(): void;
+  getUndelegate(): OsmosisMsgUndelegate | undefined;
+  setUndelegate(value?: OsmosisMsgUndelegate): void;
+
+  hasRedelegate(): boolean;
+  clearRedelegate(): void;
+  getRedelegate(): OsmosisMsgRedelegate | undefined;
+  setRedelegate(value?: OsmosisMsgRedelegate): void;
+
+  hasRewards(): boolean;
+  clearRewards(): void;
+  getRewards(): OsmosisMsgRewards | undefined;
+  setRewards(value?: OsmosisMsgRewards): void;
+
+  hasLpAdd(): boolean;
+  clearLpAdd(): void;
+  getLpAdd(): OsmosisMsgLPAdd | undefined;
+  setLpAdd(value?: OsmosisMsgLPAdd): void;
+
+  hasLpRemove(): boolean;
+  clearLpRemove(): void;
+  getLpRemove(): OsmosisMsgLPRemove | undefined;
+  setLpRemove(value?: OsmosisMsgLPRemove): void;
+
+  hasLpStake(): boolean;
+  clearLpStake(): void;
+  getLpStake(): OsmosisMsgLPStake | undefined;
+  setLpStake(value?: OsmosisMsgLPStake): void;
+
+  hasLpUnstake(): boolean;
+  clearLpUnstake(): void;
+  getLpUnstake(): OsmosisMsgLPUnstake | undefined;
+  setLpUnstake(value?: OsmosisMsgLPUnstake): void;
+
+  hasIbcTransfer(): boolean;
+  clearIbcTransfer(): void;
+  getIbcTransfer(): OsmosisMsgIBCTransfer | undefined;
+  setIbcTransfer(value?: OsmosisMsgIBCTransfer): void;
+
+  hasSwap(): boolean;
+  clearSwap(): void;
+  getSwap(): OsmosisMsgSwap | undefined;
+  setSwap(value?: OsmosisMsgSwap): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgAck.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgAck): OsmosisMsgAck.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgAck, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgAck;
+  static deserializeBinaryFromReader(message: OsmosisMsgAck, reader: jspb.BinaryReader): OsmosisMsgAck;
+}
+
+export namespace OsmosisMsgAck {
+  export type AsObject = {
+    send?: OsmosisMsgSend.AsObject,
+    delegate?: OsmosisMsgDelegate.AsObject,
+    undelegate?: OsmosisMsgUndelegate.AsObject,
+    redelegate?: OsmosisMsgRedelegate.AsObject,
+    rewards?: OsmosisMsgRewards.AsObject,
+    lpAdd?: OsmosisMsgLPAdd.AsObject,
+    lpRemove?: OsmosisMsgLPRemove.AsObject,
+    lpStake?: OsmosisMsgLPStake.AsObject,
+    lpUnstake?: OsmosisMsgLPUnstake.AsObject,
+    ibcTransfer?: OsmosisMsgIBCTransfer.AsObject,
+    swap?: OsmosisMsgSwap.AsObject,
+  }
+}
+
+export class OsmosisMsgSend extends jspb.Message {
+  hasFromAddress(): boolean;
+  clearFromAddress(): void;
+  getFromAddress(): string | undefined;
+  setFromAddress(value: string): void;
+
+  hasToAddress(): boolean;
+  clearToAddress(): void;
+  getToAddress(): string | undefined;
+  setToAddress(value: string): void;
+
+  hasDenom(): boolean;
+  clearDenom(): void;
+  getDenom(): string | undefined;
+  setDenom(value: string): void;
+
+  hasAmount(): boolean;
+  clearAmount(): void;
+  getAmount(): string | undefined;
+  setAmount(value: string): void;
+
+  hasAddressType(): boolean;
+  clearAddressType(): void;
+  getAddressType(): types_pb.OutputAddressTypeMap[keyof types_pb.OutputAddressTypeMap] | undefined;
+  setAddressType(value: types_pb.OutputAddressTypeMap[keyof types_pb.OutputAddressTypeMap]): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgSend.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgSend): OsmosisMsgSend.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgSend, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgSend;
+  static deserializeBinaryFromReader(message: OsmosisMsgSend, reader: jspb.BinaryReader): OsmosisMsgSend;
+}
+
+export namespace OsmosisMsgSend {
+  export type AsObject = {
+    fromAddress?: string,
+    toAddress?: string,
+    denom?: string,
+    amount?: string,
+    addressType?: types_pb.OutputAddressTypeMap[keyof types_pb.OutputAddressTypeMap],
+  }
+}
+
+export class OsmosisMsgDelegate extends jspb.Message {
+  hasDelegatorAddress(): boolean;
+  clearDelegatorAddress(): void;
+  getDelegatorAddress(): string | undefined;
+  setDelegatorAddress(value: string): void;
+
+  hasValidatorAddress(): boolean;
+  clearValidatorAddress(): void;
+  getValidatorAddress(): string | undefined;
+  setValidatorAddress(value: string): void;
+
+  hasDenom(): boolean;
+  clearDenom(): void;
+  getDenom(): string | undefined;
+  setDenom(value: string): void;
+
+  hasAmount(): boolean;
+  clearAmount(): void;
+  getAmount(): string | undefined;
+  setAmount(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgDelegate.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgDelegate): OsmosisMsgDelegate.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgDelegate, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgDelegate;
+  static deserializeBinaryFromReader(message: OsmosisMsgDelegate, reader: jspb.BinaryReader): OsmosisMsgDelegate;
+}
+
+export namespace OsmosisMsgDelegate {
+  export type AsObject = {
+    delegatorAddress?: string,
+    validatorAddress?: string,
+    denom?: string,
+    amount?: string,
+  }
+}
+
+export class OsmosisMsgUndelegate extends jspb.Message {
+  hasDelegatorAddress(): boolean;
+  clearDelegatorAddress(): void;
+  getDelegatorAddress(): string | undefined;
+  setDelegatorAddress(value: string): void;
+
+  hasValidatorAddress(): boolean;
+  clearValidatorAddress(): void;
+  getValidatorAddress(): string | undefined;
+  setValidatorAddress(value: string): void;
+
+  hasDenom(): boolean;
+  clearDenom(): void;
+  getDenom(): string | undefined;
+  setDenom(value: string): void;
+
+  hasAmount(): boolean;
+  clearAmount(): void;
+  getAmount(): string | undefined;
+  setAmount(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgUndelegate.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgUndelegate): OsmosisMsgUndelegate.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgUndelegate, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgUndelegate;
+  static deserializeBinaryFromReader(message: OsmosisMsgUndelegate, reader: jspb.BinaryReader): OsmosisMsgUndelegate;
+}
+
+export namespace OsmosisMsgUndelegate {
+  export type AsObject = {
+    delegatorAddress?: string,
+    validatorAddress?: string,
+    denom?: string,
+    amount?: string,
+  }
+}
+
+export class OsmosisMsgRedelegate extends jspb.Message {
+  hasDelegatorAddress(): boolean;
+  clearDelegatorAddress(): void;
+  getDelegatorAddress(): string | undefined;
+  setDelegatorAddress(value: string): void;
+
+  hasValidatorSrcAddress(): boolean;
+  clearValidatorSrcAddress(): void;
+  getValidatorSrcAddress(): string | undefined;
+  setValidatorSrcAddress(value: string): void;
+
+  hasValidatorDstAddress(): boolean;
+  clearValidatorDstAddress(): void;
+  getValidatorDstAddress(): string | undefined;
+  setValidatorDstAddress(value: string): void;
+
+  hasDenom(): boolean;
+  clearDenom(): void;
+  getDenom(): string | undefined;
+  setDenom(value: string): void;
+
+  hasAmount(): boolean;
+  clearAmount(): void;
+  getAmount(): string | undefined;
+  setAmount(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgRedelegate.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgRedelegate): OsmosisMsgRedelegate.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgRedelegate, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgRedelegate;
+  static deserializeBinaryFromReader(message: OsmosisMsgRedelegate, reader: jspb.BinaryReader): OsmosisMsgRedelegate;
+}
+
+export namespace OsmosisMsgRedelegate {
+  export type AsObject = {
+    delegatorAddress?: string,
+    validatorSrcAddress?: string,
+    validatorDstAddress?: string,
+    denom?: string,
+    amount?: string,
+  }
+}
+
+export class OsmosisMsgRewards extends jspb.Message {
+  hasDelegatorAddress(): boolean;
+  clearDelegatorAddress(): void;
+  getDelegatorAddress(): string | undefined;
+  setDelegatorAddress(value: string): void;
+
+  hasValidatorAddress(): boolean;
+  clearValidatorAddress(): void;
+  getValidatorAddress(): string | undefined;
+  setValidatorAddress(value: string): void;
+
+  hasDenom(): boolean;
+  clearDenom(): void;
+  getDenom(): string | undefined;
+  setDenom(value: string): void;
+
+  hasAmount(): boolean;
+  clearAmount(): void;
+  getAmount(): string | undefined;
+  setAmount(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgRewards.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgRewards): OsmosisMsgRewards.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgRewards, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgRewards;
+  static deserializeBinaryFromReader(message: OsmosisMsgRewards, reader: jspb.BinaryReader): OsmosisMsgRewards;
+}
+
+export namespace OsmosisMsgRewards {
+  export type AsObject = {
+    delegatorAddress?: string,
+    validatorAddress?: string,
+    denom?: string,
+    amount?: string,
+  }
+}
+
+export class OsmosisMsgLPAdd extends jspb.Message {
+  hasSender(): boolean;
+  clearSender(): void;
+  getSender(): string | undefined;
+  setSender(value: string): void;
+
+  hasPoolId(): boolean;
+  clearPoolId(): void;
+  getPoolId(): string | undefined;
+  setPoolId(value: string): void;
+
+  hasShareOutAmount(): boolean;
+  clearShareOutAmount(): void;
+  getShareOutAmount(): number | undefined;
+  setShareOutAmount(value: number): void;
+
+  hasDenomInMaxA(): boolean;
+  clearDenomInMaxA(): void;
+  getDenomInMaxA(): string | undefined;
+  setDenomInMaxA(value: string): void;
+
+  hasAmountInMaxA(): boolean;
+  clearAmountInMaxA(): void;
+  getAmountInMaxA(): string | undefined;
+  setAmountInMaxA(value: string): void;
+
+  hasDenomInMaxB(): boolean;
+  clearDenomInMaxB(): void;
+  getDenomInMaxB(): string | undefined;
+  setDenomInMaxB(value: string): void;
+
+  hasAmountInMaxB(): boolean;
+  clearAmountInMaxB(): void;
+  getAmountInMaxB(): string | undefined;
+  setAmountInMaxB(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgLPAdd.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgLPAdd): OsmosisMsgLPAdd.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgLPAdd, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgLPAdd;
+  static deserializeBinaryFromReader(message: OsmosisMsgLPAdd, reader: jspb.BinaryReader): OsmosisMsgLPAdd;
+}
+
+export namespace OsmosisMsgLPAdd {
+  export type AsObject = {
+    sender?: string,
+    poolId?: string,
+    shareOutAmount?: number,
+    denomInMaxA?: string,
+    amountInMaxA?: string,
+    denomInMaxB?: string,
+    amountInMaxB?: string,
+  }
+}
+
+export class OsmosisMsgLPRemove extends jspb.Message {
+  hasSender(): boolean;
+  clearSender(): void;
+  getSender(): string | undefined;
+  setSender(value: string): void;
+
+  hasPoolId(): boolean;
+  clearPoolId(): void;
+  getPoolId(): string | undefined;
+  setPoolId(value: string): void;
+
+  hasShareOutAmount(): boolean;
+  clearShareOutAmount(): void;
+  getShareOutAmount(): number | undefined;
+  setShareOutAmount(value: number): void;
+
+  hasDenomOutMinA(): boolean;
+  clearDenomOutMinA(): void;
+  getDenomOutMinA(): string | undefined;
+  setDenomOutMinA(value: string): void;
+
+  hasAmountOutMinA(): boolean;
+  clearAmountOutMinA(): void;
+  getAmountOutMinA(): string | undefined;
+  setAmountOutMinA(value: string): void;
+
+  hasDenomOutMinB(): boolean;
+  clearDenomOutMinB(): void;
+  getDenomOutMinB(): string | undefined;
+  setDenomOutMinB(value: string): void;
+
+  hasAmountOutMinB(): boolean;
+  clearAmountOutMinB(): void;
+  getAmountOutMinB(): string | undefined;
+  setAmountOutMinB(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgLPRemove.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgLPRemove): OsmosisMsgLPRemove.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgLPRemove, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgLPRemove;
+  static deserializeBinaryFromReader(message: OsmosisMsgLPRemove, reader: jspb.BinaryReader): OsmosisMsgLPRemove;
+}
+
+export namespace OsmosisMsgLPRemove {
+  export type AsObject = {
+    sender?: string,
+    poolId?: string,
+    shareOutAmount?: number,
+    denomOutMinA?: string,
+    amountOutMinA?: string,
+    denomOutMinB?: string,
+    amountOutMinB?: string,
+  }
+}
+
+export class OsmosisMsgLPStake extends jspb.Message {
+  hasOwner(): boolean;
+  clearOwner(): void;
+  getOwner(): string | undefined;
+  setOwner(value: string): void;
+
+  hasDuration(): boolean;
+  clearDuration(): void;
+  getDuration(): number | undefined;
+  setDuration(value: number): void;
+
+  hasDenom(): boolean;
+  clearDenom(): void;
+  getDenom(): string | undefined;
+  setDenom(value: string): void;
+
+  hasAmount(): boolean;
+  clearAmount(): void;
+  getAmount(): string | undefined;
+  setAmount(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgLPStake.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgLPStake): OsmosisMsgLPStake.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgLPStake, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgLPStake;
+  static deserializeBinaryFromReader(message: OsmosisMsgLPStake, reader: jspb.BinaryReader): OsmosisMsgLPStake;
+}
+
+export namespace OsmosisMsgLPStake {
+  export type AsObject = {
+    owner?: string,
+    duration?: number,
+    denom?: string,
+    amount?: string,
+  }
+}
+
+export class OsmosisMsgLPUnstake extends jspb.Message {
+  hasOwner(): boolean;
+  clearOwner(): void;
+  getOwner(): string | undefined;
+  setOwner(value: string): void;
+
+  hasId(): boolean;
+  clearId(): void;
+  getId(): string | undefined;
+  setId(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgLPUnstake.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgLPUnstake): OsmosisMsgLPUnstake.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgLPUnstake, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgLPUnstake;
+  static deserializeBinaryFromReader(message: OsmosisMsgLPUnstake, reader: jspb.BinaryReader): OsmosisMsgLPUnstake;
+}
+
+export namespace OsmosisMsgLPUnstake {
+  export type AsObject = {
+    owner?: string,
+    id?: string,
+  }
+}
+
+export class OsmosisMsgIBCTransfer extends jspb.Message {
+  hasSourcePort(): boolean;
+  clearSourcePort(): void;
+  getSourcePort(): string | undefined;
+  setSourcePort(value: string): void;
+
+  hasSourceChannel(): boolean;
+  clearSourceChannel(): void;
+  getSourceChannel(): string | undefined;
+  setSourceChannel(value: string): void;
+
+  hasDenom(): boolean;
+  clearDenom(): void;
+  getDenom(): string | undefined;
+  setDenom(value: string): void;
+
+  hasAmount(): boolean;
+  clearAmount(): void;
+  getAmount(): string | undefined;
+  setAmount(value: string): void;
+
+  hasSender(): boolean;
+  clearSender(): void;
+  getSender(): string | undefined;
+  setSender(value: string): void;
+
+  hasReceiver(): boolean;
+  clearReceiver(): void;
+  getReceiver(): string | undefined;
+  setReceiver(value: string): void;
+
+  hasRevisionNumber(): boolean;
+  clearRevisionNumber(): void;
+  getRevisionNumber(): string | undefined;
+  setRevisionNumber(value: string): void;
+
+  hasRevisionHeight(): boolean;
+  clearRevisionHeight(): void;
+  getRevisionHeight(): string | undefined;
+  setRevisionHeight(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgIBCTransfer.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgIBCTransfer): OsmosisMsgIBCTransfer.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgIBCTransfer, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgIBCTransfer;
+  static deserializeBinaryFromReader(message: OsmosisMsgIBCTransfer, reader: jspb.BinaryReader): OsmosisMsgIBCTransfer;
+}
+
+export namespace OsmosisMsgIBCTransfer {
+  export type AsObject = {
+    sourcePort?: string,
+    sourceChannel?: string,
+    denom?: string,
+    amount?: string,
+    sender?: string,
+    receiver?: string,
+    revisionNumber?: string,
+    revisionHeight?: string,
+  }
+}
+
+export class OsmosisMsgSwap extends jspb.Message {
+  hasSender(): boolean;
+  clearSender(): void;
+  getSender(): string | undefined;
+  setSender(value: string): void;
+
+  hasPoolId(): boolean;
+  clearPoolId(): void;
+  getPoolId(): string | undefined;
+  setPoolId(value: string): void;
+
+  hasTokenOutDenom(): boolean;
+  clearTokenOutDenom(): void;
+  getTokenOutDenom(): string | undefined;
+  setTokenOutDenom(value: string): void;
+
+  hasTokenInDenom(): boolean;
+  clearTokenInDenom(): void;
+  getTokenInDenom(): string | undefined;
+  setTokenInDenom(value: string): void;
+
+  hasTokenInAmount(): boolean;
+  clearTokenInAmount(): void;
+  getTokenInAmount(): string | undefined;
+  setTokenInAmount(value: string): void;
+
+  hasTokenOutMinAmount(): boolean;
+  clearTokenOutMinAmount(): void;
+  getTokenOutMinAmount(): number | undefined;
+  setTokenOutMinAmount(value: number): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgSwap.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgSwap): OsmosisMsgSwap.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgSwap, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgSwap;
+  static deserializeBinaryFromReader(message: OsmosisMsgSwap, reader: jspb.BinaryReader): OsmosisMsgSwap;
+}
+
+export namespace OsmosisMsgSwap {
+  export type AsObject = {
+    sender?: string,
+    poolId?: string,
+    tokenOutDenom?: string,
+    tokenInDenom?: string,
+    tokenInAmount?: string,
+    tokenOutMinAmount?: number,
+  }
+}
+
+export class OsmosisSignedTx extends jspb.Message {
+  hasPublicKey(): boolean;
+  clearPublicKey(): void;
+  getPublicKey(): Uint8Array | string;
+  getPublicKey_asU8(): Uint8Array;
+  getPublicKey_asB64(): string;
+  setPublicKey(value: Uint8Array | string): void;
+
+  hasSignature(): boolean;
+  clearSignature(): void;
+  getSignature(): Uint8Array | string;
+  getSignature_asU8(): Uint8Array;
+  getSignature_asB64(): string;
+  setSignature(value: Uint8Array | string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisSignedTx.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisSignedTx): OsmosisSignedTx.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisSignedTx, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisSignedTx;
+  static deserializeBinaryFromReader(message: OsmosisSignedTx, reader: jspb.BinaryReader): OsmosisSignedTx;
+}
+
+export namespace OsmosisSignedTx {
+  export type AsObject = {
+    publicKey: Uint8Array | string,
+    signature: Uint8Array | string,
+  }
+}
+