@keepkey/device-protocol 7.2.3 → 7.5.0

package/lib/messages-osmosis_pb.d.ts

@@ -0,0 +1,730 @@
+// 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 OsmosisToken extends jspb.Message {
+  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): OsmosisToken.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisToken): OsmosisToken.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisToken, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisToken;
+  static deserializeBinaryFromReader(message: OsmosisToken, reader: jspb.BinaryReader): OsmosisToken;
+}
+
+export namespace OsmosisToken {
+  export type AsObject = {
+    denom?: string,
+    amount?: string,
+  }
+}
+
+export class OsmosisTimeoutHeight extends jspb.Message {
+  hasRevisionNumber(): boolean;
+  clearRevisionNumber(): void;
+  getRevisionNumber(): number | undefined;
+  setRevisionNumber(value: number): void;
+
+  hasRevisionHeight(): boolean;
+  clearRevisionHeight(): void;
+  getRevisionHeight(): number | undefined;
+  setRevisionHeight(value: number): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisTimeoutHeight.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisTimeoutHeight): OsmosisTimeoutHeight.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisTimeoutHeight, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisTimeoutHeight;
+  static deserializeBinaryFromReader(message: OsmosisTimeoutHeight, reader: jspb.BinaryReader): OsmosisTimeoutHeight;
+}
+
+export namespace OsmosisTimeoutHeight {
+  export type AsObject = {
+    revisionNumber?: number,
+    revisionHeight?: number,
+  }
+}
+
+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;
+
+  hasClaim(): boolean;
+  clearClaim(): void;
+  getClaim(): OsmosisMsgClaim | undefined;
+  setClaim(value?: OsmosisMsgClaim): void;
+
+  hasLpAdd(): boolean;
+  clearLpAdd(): void;
+  getLpAdd(): OsmosisMsgLPAdd | undefined;
+  setLpAdd(value?: OsmosisMsgLPAdd): void;
+
+  hasLpRemove(): boolean;
+  clearLpRemove(): void;
+  getLpRemove(): OsmosisMsgLPRemove | undefined;
+  setLpRemove(value?: OsmosisMsgLPRemove): void;
+
+  hasFarmTokens(): boolean;
+  clearFarmTokens(): void;
+  getFarmTokens(): OsmosisMsgFarmTokens | undefined;
+  setFarmTokens(value?: OsmosisMsgFarmTokens): void;
+
+  hasIbcDeposit(): boolean;
+  clearIbcDeposit(): void;
+  getIbcDeposit(): OsmosisMsgIBCDeposit | undefined;
+  setIbcDeposit(value?: OsmosisMsgIBCDeposit): void;
+
+  hasIbcWithdrawal(): boolean;
+  clearIbcWithdrawal(): void;
+  getIbcWithdrawal(): OsmosisMsgIBCWithdrawal | undefined;
+  setIbcWithdrawal(value?: OsmosisMsgIBCWithdrawal): 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,
+    claim?: OsmosisMsgClaim.AsObject,
+    lpAdd?: OsmosisMsgLPAdd.AsObject,
+    lpRemove?: OsmosisMsgLPRemove.AsObject,
+    farmTokens?: OsmosisMsgFarmTokens.AsObject,
+    ibcDeposit?: OsmosisMsgIBCDeposit.AsObject,
+    ibcWithdrawal?: OsmosisMsgIBCWithdrawal.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;
+
+  hasToken(): boolean;
+  clearToken(): void;
+  getToken(): OsmosisToken | undefined;
+  setToken(value?: OsmosisToken): 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,
+    token?: OsmosisToken.AsObject,
+    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;
+
+  hasToken(): boolean;
+  clearToken(): void;
+  getToken(): OsmosisToken | undefined;
+  setToken(value?: OsmosisToken): 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,
+    token?: OsmosisToken.AsObject,
+  }
+}
+
+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;
+
+  hasToken(): boolean;
+  clearToken(): void;
+  getToken(): OsmosisToken | undefined;
+  setToken(value?: OsmosisToken): 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,
+    token?: OsmosisToken.AsObject,
+  }
+}
+
+export class OsmosisMsgClaim 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;
+
+  hasToken(): boolean;
+  clearToken(): void;
+  getToken(): OsmosisToken | undefined;
+  setToken(value?: OsmosisToken): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgClaim.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgClaim): OsmosisMsgClaim.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgClaim, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgClaim;
+  static deserializeBinaryFromReader(message: OsmosisMsgClaim, reader: jspb.BinaryReader): OsmosisMsgClaim;
+}
+
+export namespace OsmosisMsgClaim {
+  export type AsObject = {
+    delegatorAddress?: string,
+    validatorAddress?: string,
+    token?: OsmosisToken.AsObject,
+  }
+}
+
+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;
+
+  hasTokenInMaxA(): boolean;
+  clearTokenInMaxA(): void;
+  getTokenInMaxA(): OsmosisToken | undefined;
+  setTokenInMaxA(value?: OsmosisToken): void;
+
+  hasTokenInMaxB(): boolean;
+  clearTokenInMaxB(): void;
+  getTokenInMaxB(): OsmosisToken | undefined;
+  setTokenInMaxB(value?: OsmosisToken): 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,
+    tokenInMaxA?: OsmosisToken.AsObject,
+    tokenInMaxB?: OsmosisToken.AsObject,
+  }
+}
+
+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;
+
+  hasTokenOutMinA(): boolean;
+  clearTokenOutMinA(): void;
+  getTokenOutMinA(): OsmosisToken | undefined;
+  setTokenOutMinA(value?: OsmosisToken): void;
+
+  hasTokenOutMinB(): boolean;
+  clearTokenOutMinB(): void;
+  getTokenOutMinB(): OsmosisToken | undefined;
+  setTokenOutMinB(value?: OsmosisToken): 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,
+    tokenOutMinA?: OsmosisToken.AsObject,
+    tokenOutMinB?: OsmosisToken.AsObject,
+  }
+}
+
+export class OsmosisMsgFarmTokens 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;
+
+  hasToken(): boolean;
+  clearToken(): void;
+  getToken(): OsmosisToken | undefined;
+  setToken(value?: OsmosisToken): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgFarmTokens.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgFarmTokens): OsmosisMsgFarmTokens.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgFarmTokens, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgFarmTokens;
+  static deserializeBinaryFromReader(message: OsmosisMsgFarmTokens, reader: jspb.BinaryReader): OsmosisMsgFarmTokens;
+}
+
+export namespace OsmosisMsgFarmTokens {
+  export type AsObject = {
+    owner?: string,
+    duration?: number,
+    token?: OsmosisToken.AsObject,
+  }
+}
+
+export class OsmosisMsgIBCDeposit 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;
+
+  hasToken(): boolean;
+  clearToken(): void;
+  getToken(): OsmosisToken | undefined;
+  setToken(value?: OsmosisToken): void;
+
+  hasSender(): boolean;
+  clearSender(): void;
+  getSender(): string | undefined;
+  setSender(value: string): void;
+
+  hasReceiver(): boolean;
+  clearReceiver(): void;
+  getReceiver(): string | undefined;
+  setReceiver(value: string): void;
+
+  hasTimeoutHeight(): boolean;
+  clearTimeoutHeight(): void;
+  getTimeoutHeight(): OsmosisTimeoutHeight | undefined;
+  setTimeoutHeight(value?: OsmosisTimeoutHeight): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgIBCDeposit.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgIBCDeposit): OsmosisMsgIBCDeposit.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgIBCDeposit, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgIBCDeposit;
+  static deserializeBinaryFromReader(message: OsmosisMsgIBCDeposit, reader: jspb.BinaryReader): OsmosisMsgIBCDeposit;
+}
+
+export namespace OsmosisMsgIBCDeposit {
+  export type AsObject = {
+    sourcePort?: string,
+    sourceChannel?: string,
+    token?: OsmosisToken.AsObject,
+    sender?: string,
+    receiver?: string,
+    timeoutHeight?: OsmosisTimeoutHeight.AsObject,
+  }
+}
+
+export class OsmosisMsgIBCWithdrawal 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;
+
+  hasToken(): boolean;
+  clearToken(): void;
+  getToken(): OsmosisToken | undefined;
+  setToken(value?: OsmosisToken): void;
+
+  hasSender(): boolean;
+  clearSender(): void;
+  getSender(): string | undefined;
+  setSender(value: string): void;
+
+  hasReceiver(): boolean;
+  clearReceiver(): void;
+  getReceiver(): string | undefined;
+  setReceiver(value: string): void;
+
+  hasTimeoutHeight(): boolean;
+  clearTimeoutHeight(): void;
+  getTimeoutHeight(): OsmosisTimeoutHeight | undefined;
+  setTimeoutHeight(value?: OsmosisTimeoutHeight): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OsmosisMsgIBCWithdrawal.AsObject;
+  static toObject(includeInstance: boolean, msg: OsmosisMsgIBCWithdrawal): OsmosisMsgIBCWithdrawal.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OsmosisMsgIBCWithdrawal, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OsmosisMsgIBCWithdrawal;
+  static deserializeBinaryFromReader(message: OsmosisMsgIBCWithdrawal, reader: jspb.BinaryReader): OsmosisMsgIBCWithdrawal;
+}
+
+export namespace OsmosisMsgIBCWithdrawal {
+  export type AsObject = {
+    sourcePort?: string,
+    sourceChannel?: string,
+    token?: OsmosisToken.AsObject,
+    sender?: string,
+    receiver?: string,
+    timeoutHeight?: OsmosisTimeoutHeight.AsObject,
+  }
+}
+
+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;
+
+  hasTokenIn(): boolean;
+  clearTokenIn(): void;
+  getTokenIn(): OsmosisToken | undefined;
+  setTokenIn(value?: OsmosisToken): 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,
+    tokenIn?: OsmosisToken.AsObject,
+    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,
+  }
+}
+