// @generated by protoc-gen-es v1.3.1 with parameter "target=ts"
// @generated from file ibc/lightclients/solomachine/v2/solomachine.proto (package ibc.lightclients.solomachine.v2, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { ConnectionEnd } from "../../../core/connection/v1/connection_pb.js";
import { Channel } from "../../../core/channel/v1/channel_pb.js";

/**
 * DataType defines the type of solo machine proof being created. This is done
 * to preserve uniqueness of different data sign byte encodings.
 *
 * @generated from enum ibc.lightclients.solomachine.v2.DataType
 */
export enum DataType {
  /**
   * Default State
   *
   * @generated from enum value: DATA_TYPE_UNINITIALIZED_UNSPECIFIED = 0;
   */
  UNINITIALIZED_UNSPECIFIED = 0,

  /**
   * Data type for client state verification
   *
   * @generated from enum value: DATA_TYPE_CLIENT_STATE = 1;
   */
  CLIENT_STATE = 1,

  /**
   * Data type for consensus state verification
   *
   * @generated from enum value: DATA_TYPE_CONSENSUS_STATE = 2;
   */
  CONSENSUS_STATE = 2,

  /**
   * Data type for connection state verification
   *
   * @generated from enum value: DATA_TYPE_CONNECTION_STATE = 3;
   */
  CONNECTION_STATE = 3,

  /**
   * Data type for channel state verification
   *
   * @generated from enum value: DATA_TYPE_CHANNEL_STATE = 4;
   */
  CHANNEL_STATE = 4,

  /**
   * Data type for packet commitment verification
   *
   * @generated from enum value: DATA_TYPE_PACKET_COMMITMENT = 5;
   */
  PACKET_COMMITMENT = 5,

  /**
   * Data type for packet acknowledgement verification
   *
   * @generated from enum value: DATA_TYPE_PACKET_ACKNOWLEDGEMENT = 6;
   */
  PACKET_ACKNOWLEDGEMENT = 6,

  /**
   * Data type for packet receipt absence verification
   *
   * @generated from enum value: DATA_TYPE_PACKET_RECEIPT_ABSENCE = 7;
   */
  PACKET_RECEIPT_ABSENCE = 7,

  /**
   * Data type for next sequence recv verification
   *
   * @generated from enum value: DATA_TYPE_NEXT_SEQUENCE_RECV = 8;
   */
  NEXT_SEQUENCE_RECV = 8,

  /**
   * Data type for header verification
   *
   * @generated from enum value: DATA_TYPE_HEADER = 9;
   */
  HEADER = 9,
}
// Retrieve enum metadata with: proto3.getEnumType(DataType)
proto3.util.setEnumType(DataType, "ibc.lightclients.solomachine.v2.DataType", [
  { no: 0, name: "DATA_TYPE_UNINITIALIZED_UNSPECIFIED" },
  { no: 1, name: "DATA_TYPE_CLIENT_STATE" },
  { no: 2, name: "DATA_TYPE_CONSENSUS_STATE" },
  { no: 3, name: "DATA_TYPE_CONNECTION_STATE" },
  { no: 4, name: "DATA_TYPE_CHANNEL_STATE" },
  { no: 5, name: "DATA_TYPE_PACKET_COMMITMENT" },
  { no: 6, name: "DATA_TYPE_PACKET_ACKNOWLEDGEMENT" },
  { no: 7, name: "DATA_TYPE_PACKET_RECEIPT_ABSENCE" },
  { no: 8, name: "DATA_TYPE_NEXT_SEQUENCE_RECV" },
  { no: 9, name: "DATA_TYPE_HEADER" },
]);

/**
 * ClientState defines a solo machine client that tracks the current consensus
 * state and if the client is frozen.
 *
 * @generated from message ibc.lightclients.solomachine.v2.ClientState
 */
export class ClientState extends Message<ClientState> {
  /**
   * latest sequence of the client state
   *
   * @generated from field: uint64 sequence = 1;
   */
  sequence = protoInt64.zero;

  /**
   * frozen sequence of the solo machine
   *
   * @generated from field: bool is_frozen = 2;
   */
  isFrozen = false;

  /**
   * @generated from field: ibc.lightclients.solomachine.v2.ConsensusState consensus_state = 3;
   */
  consensusState?: ConsensusState;

  /**
   * when set to true, will allow governance to update a solo machine client.
   * The client will be unfrozen if it is frozen.
   *
   * @generated from field: bool allow_update_after_proposal = 4;
   */
  allowUpdateAfterProposal = false;

  constructor(data?: PartialMessage<ClientState>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.ClientState";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 2, name: "is_frozen", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 3, name: "consensus_state", kind: "message", T: ConsensusState },
    { no: 4, name: "allow_update_after_proposal", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientState {
    return new ClientState().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientState {
    return new ClientState().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientState {
    return new ClientState().fromJsonString(jsonString, options);
  }

  static equals(a: ClientState | PlainMessage<ClientState> | undefined, b: ClientState | PlainMessage<ClientState> | undefined): boolean {
    return proto3.util.equals(ClientState, a, b);
  }
}

/**
 * ConsensusState defines a solo machine consensus state. The sequence of a
 * consensus state is contained in the "height" key used in storing the
 * consensus state.
 *
 * @generated from message ibc.lightclients.solomachine.v2.ConsensusState
 */
export class ConsensusState extends Message<ConsensusState> {
  /**
   * public key of the solo machine
   *
   * @generated from field: google.protobuf.Any public_key = 1;
   */
  publicKey?: Any;

  /**
   * diversifier allows the same public key to be re-used across different solo
   * machine clients (potentially on different chains) without being considered
   * misbehaviour.
   *
   * @generated from field: string diversifier = 2;
   */
  diversifier = "";

  /**
   * @generated from field: uint64 timestamp = 3;
   */
  timestamp = protoInt64.zero;

  constructor(data?: PartialMessage<ConsensusState>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.ConsensusState";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "public_key", kind: "message", T: Any },
    { no: 2, name: "diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConsensusState {
    return new ConsensusState().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConsensusState {
    return new ConsensusState().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConsensusState {
    return new ConsensusState().fromJsonString(jsonString, options);
  }

  static equals(a: ConsensusState | PlainMessage<ConsensusState> | undefined, b: ConsensusState | PlainMessage<ConsensusState> | undefined): boolean {
    return proto3.util.equals(ConsensusState, a, b);
  }
}

/**
 * Header defines a solo machine consensus header
 *
 * @generated from message ibc.lightclients.solomachine.v2.Header
 */
export class Header extends Message<Header> {
  /**
   * sequence to update solo machine public key at
   *
   * @generated from field: uint64 sequence = 1;
   */
  sequence = protoInt64.zero;

  /**
   * @generated from field: uint64 timestamp = 2;
   */
  timestamp = protoInt64.zero;

  /**
   * @generated from field: bytes signature = 3;
   */
  signature = new Uint8Array(0);

  /**
   * @generated from field: google.protobuf.Any new_public_key = 4;
   */
  newPublicKey?: Any;

  /**
   * @generated from field: string new_diversifier = 5;
   */
  newDiversifier = "";

  constructor(data?: PartialMessage<Header>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.Header";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 2, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 3, name: "signature", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 4, name: "new_public_key", kind: "message", T: Any },
    { no: 5, name: "new_diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Header {
    return new Header().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Header {
    return new Header().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Header {
    return new Header().fromJsonString(jsonString, options);
  }

  static equals(a: Header | PlainMessage<Header> | undefined, b: Header | PlainMessage<Header> | undefined): boolean {
    return proto3.util.equals(Header, a, b);
  }
}

/**
 * Misbehaviour defines misbehaviour for a solo machine which consists
 * of a sequence and two signatures over different messages at that sequence.
 *
 * @generated from message ibc.lightclients.solomachine.v2.Misbehaviour
 */
export class Misbehaviour extends Message<Misbehaviour> {
  /**
   * @generated from field: string client_id = 1;
   */
  clientId = "";

  /**
   * @generated from field: uint64 sequence = 2;
   */
  sequence = protoInt64.zero;

  /**
   * @generated from field: ibc.lightclients.solomachine.v2.SignatureAndData signature_one = 3;
   */
  signatureOne?: SignatureAndData;

  /**
   * @generated from field: ibc.lightclients.solomachine.v2.SignatureAndData signature_two = 4;
   */
  signatureTwo?: SignatureAndData;

  constructor(data?: PartialMessage<Misbehaviour>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.Misbehaviour";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 3, name: "signature_one", kind: "message", T: SignatureAndData },
    { no: 4, name: "signature_two", kind: "message", T: SignatureAndData },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Misbehaviour {
    return new Misbehaviour().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Misbehaviour {
    return new Misbehaviour().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Misbehaviour {
    return new Misbehaviour().fromJsonString(jsonString, options);
  }

  static equals(a: Misbehaviour | PlainMessage<Misbehaviour> | undefined, b: Misbehaviour | PlainMessage<Misbehaviour> | undefined): boolean {
    return proto3.util.equals(Misbehaviour, a, b);
  }
}

/**
 * SignatureAndData contains a signature and the data signed over to create that
 * signature.
 *
 * @generated from message ibc.lightclients.solomachine.v2.SignatureAndData
 */
export class SignatureAndData extends Message<SignatureAndData> {
  /**
   * @generated from field: bytes signature = 1;
   */
  signature = new Uint8Array(0);

  /**
   * @generated from field: ibc.lightclients.solomachine.v2.DataType data_type = 2;
   */
  dataType = DataType.UNINITIALIZED_UNSPECIFIED;

  /**
   * @generated from field: bytes data = 3;
   */
  data = new Uint8Array(0);

  /**
   * @generated from field: uint64 timestamp = 4;
   */
  timestamp = protoInt64.zero;

  constructor(data?: PartialMessage<SignatureAndData>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.SignatureAndData";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "signature", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 2, name: "data_type", kind: "enum", T: proto3.getEnumType(DataType) },
    { no: 3, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 4, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SignatureAndData {
    return new SignatureAndData().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SignatureAndData {
    return new SignatureAndData().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SignatureAndData {
    return new SignatureAndData().fromJsonString(jsonString, options);
  }

  static equals(a: SignatureAndData | PlainMessage<SignatureAndData> | undefined, b: SignatureAndData | PlainMessage<SignatureAndData> | undefined): boolean {
    return proto3.util.equals(SignatureAndData, a, b);
  }
}

/**
 * TimestampedSignatureData contains the signature data and the timestamp of the
 * signature.
 *
 * @generated from message ibc.lightclients.solomachine.v2.TimestampedSignatureData
 */
export class TimestampedSignatureData extends Message<TimestampedSignatureData> {
  /**
   * @generated from field: bytes signature_data = 1;
   */
  signatureData = new Uint8Array(0);

  /**
   * @generated from field: uint64 timestamp = 2;
   */
  timestamp = protoInt64.zero;

  constructor(data?: PartialMessage<TimestampedSignatureData>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.TimestampedSignatureData";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "signature_data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 2, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TimestampedSignatureData {
    return new TimestampedSignatureData().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TimestampedSignatureData {
    return new TimestampedSignatureData().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TimestampedSignatureData {
    return new TimestampedSignatureData().fromJsonString(jsonString, options);
  }

  static equals(a: TimestampedSignatureData | PlainMessage<TimestampedSignatureData> | undefined, b: TimestampedSignatureData | PlainMessage<TimestampedSignatureData> | undefined): boolean {
    return proto3.util.equals(TimestampedSignatureData, a, b);
  }
}

/**
 * SignBytes defines the signed bytes used for signature verification.
 *
 * @generated from message ibc.lightclients.solomachine.v2.SignBytes
 */
export class SignBytes extends Message<SignBytes> {
  /**
   * @generated from field: uint64 sequence = 1;
   */
  sequence = protoInt64.zero;

  /**
   * @generated from field: uint64 timestamp = 2;
   */
  timestamp = protoInt64.zero;

  /**
   * @generated from field: string diversifier = 3;
   */
  diversifier = "";

  /**
   * type of the data used
   *
   * @generated from field: ibc.lightclients.solomachine.v2.DataType data_type = 4;
   */
  dataType = DataType.UNINITIALIZED_UNSPECIFIED;

  /**
   * marshaled data
   *
   * @generated from field: bytes data = 5;
   */
  data = new Uint8Array(0);

  constructor(data?: PartialMessage<SignBytes>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.SignBytes";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 2, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 3, name: "diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "data_type", kind: "enum", T: proto3.getEnumType(DataType) },
    { no: 5, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SignBytes {
    return new SignBytes().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SignBytes {
    return new SignBytes().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SignBytes {
    return new SignBytes().fromJsonString(jsonString, options);
  }

  static equals(a: SignBytes | PlainMessage<SignBytes> | undefined, b: SignBytes | PlainMessage<SignBytes> | undefined): boolean {
    return proto3.util.equals(SignBytes, a, b);
  }
}

/**
 * HeaderData returns the SignBytes data for update verification.
 *
 * @generated from message ibc.lightclients.solomachine.v2.HeaderData
 */
export class HeaderData extends Message<HeaderData> {
  /**
   * header public key
   *
   * @generated from field: google.protobuf.Any new_pub_key = 1;
   */
  newPubKey?: Any;

  /**
   * header diversifier
   *
   * @generated from field: string new_diversifier = 2;
   */
  newDiversifier = "";

  constructor(data?: PartialMessage<HeaderData>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.HeaderData";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "new_pub_key", kind: "message", T: Any },
    { no: 2, name: "new_diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HeaderData {
    return new HeaderData().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HeaderData {
    return new HeaderData().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HeaderData {
    return new HeaderData().fromJsonString(jsonString, options);
  }

  static equals(a: HeaderData | PlainMessage<HeaderData> | undefined, b: HeaderData | PlainMessage<HeaderData> | undefined): boolean {
    return proto3.util.equals(HeaderData, a, b);
  }
}

/**
 * ClientStateData returns the SignBytes data for client state verification.
 *
 * @generated from message ibc.lightclients.solomachine.v2.ClientStateData
 */
export class ClientStateData extends Message<ClientStateData> {
  /**
   * @generated from field: bytes path = 1;
   */
  path = new Uint8Array(0);

  /**
   * @generated from field: google.protobuf.Any client_state = 2;
   */
  clientState?: Any;

  constructor(data?: PartialMessage<ClientStateData>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.ClientStateData";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 2, name: "client_state", kind: "message", T: Any },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientStateData {
    return new ClientStateData().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientStateData {
    return new ClientStateData().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientStateData {
    return new ClientStateData().fromJsonString(jsonString, options);
  }

  static equals(a: ClientStateData | PlainMessage<ClientStateData> | undefined, b: ClientStateData | PlainMessage<ClientStateData> | undefined): boolean {
    return proto3.util.equals(ClientStateData, a, b);
  }
}

/**
 * ConsensusStateData returns the SignBytes data for consensus state
 * verification.
 *
 * @generated from message ibc.lightclients.solomachine.v2.ConsensusStateData
 */
export class ConsensusStateData extends Message<ConsensusStateData> {
  /**
   * @generated from field: bytes path = 1;
   */
  path = new Uint8Array(0);

  /**
   * @generated from field: google.protobuf.Any consensus_state = 2;
   */
  consensusState?: Any;

  constructor(data?: PartialMessage<ConsensusStateData>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.ConsensusStateData";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 2, name: "consensus_state", kind: "message", T: Any },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConsensusStateData {
    return new ConsensusStateData().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConsensusStateData {
    return new ConsensusStateData().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConsensusStateData {
    return new ConsensusStateData().fromJsonString(jsonString, options);
  }

  static equals(a: ConsensusStateData | PlainMessage<ConsensusStateData> | undefined, b: ConsensusStateData | PlainMessage<ConsensusStateData> | undefined): boolean {
    return proto3.util.equals(ConsensusStateData, a, b);
  }
}

/**
 * ConnectionStateData returns the SignBytes data for connection state
 * verification.
 *
 * @generated from message ibc.lightclients.solomachine.v2.ConnectionStateData
 */
export class ConnectionStateData extends Message<ConnectionStateData> {
  /**
   * @generated from field: bytes path = 1;
   */
  path = new Uint8Array(0);

  /**
   * @generated from field: ibc.core.connection.v1.ConnectionEnd connection = 2;
   */
  connection?: ConnectionEnd;

  constructor(data?: PartialMessage<ConnectionStateData>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.ConnectionStateData";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 2, name: "connection", kind: "message", T: ConnectionEnd },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConnectionStateData {
    return new ConnectionStateData().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConnectionStateData {
    return new ConnectionStateData().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConnectionStateData {
    return new ConnectionStateData().fromJsonString(jsonString, options);
  }

  static equals(a: ConnectionStateData | PlainMessage<ConnectionStateData> | undefined, b: ConnectionStateData | PlainMessage<ConnectionStateData> | undefined): boolean {
    return proto3.util.equals(ConnectionStateData, a, b);
  }
}

/**
 * ChannelStateData returns the SignBytes data for channel state
 * verification.
 *
 * @generated from message ibc.lightclients.solomachine.v2.ChannelStateData
 */
export class ChannelStateData extends Message<ChannelStateData> {
  /**
   * @generated from field: bytes path = 1;
   */
  path = new Uint8Array(0);

  /**
   * @generated from field: ibc.core.channel.v1.Channel channel = 2;
   */
  channel?: Channel;

  constructor(data?: PartialMessage<ChannelStateData>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.ChannelStateData";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 2, name: "channel", kind: "message", T: Channel },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ChannelStateData {
    return new ChannelStateData().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ChannelStateData {
    return new ChannelStateData().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ChannelStateData {
    return new ChannelStateData().fromJsonString(jsonString, options);
  }

  static equals(a: ChannelStateData | PlainMessage<ChannelStateData> | undefined, b: ChannelStateData | PlainMessage<ChannelStateData> | undefined): boolean {
    return proto3.util.equals(ChannelStateData, a, b);
  }
}

/**
 * PacketCommitmentData returns the SignBytes data for packet commitment
 * verification.
 *
 * @generated from message ibc.lightclients.solomachine.v2.PacketCommitmentData
 */
export class PacketCommitmentData extends Message<PacketCommitmentData> {
  /**
   * @generated from field: bytes path = 1;
   */
  path = new Uint8Array(0);

  /**
   * @generated from field: bytes commitment = 2;
   */
  commitment = new Uint8Array(0);

  constructor(data?: PartialMessage<PacketCommitmentData>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.PacketCommitmentData";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 2, name: "commitment", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PacketCommitmentData {
    return new PacketCommitmentData().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PacketCommitmentData {
    return new PacketCommitmentData().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PacketCommitmentData {
    return new PacketCommitmentData().fromJsonString(jsonString, options);
  }

  static equals(a: PacketCommitmentData | PlainMessage<PacketCommitmentData> | undefined, b: PacketCommitmentData | PlainMessage<PacketCommitmentData> | undefined): boolean {
    return proto3.util.equals(PacketCommitmentData, a, b);
  }
}

/**
 * PacketAcknowledgementData returns the SignBytes data for acknowledgement
 * verification.
 *
 * @generated from message ibc.lightclients.solomachine.v2.PacketAcknowledgementData
 */
export class PacketAcknowledgementData extends Message<PacketAcknowledgementData> {
  /**
   * @generated from field: bytes path = 1;
   */
  path = new Uint8Array(0);

  /**
   * @generated from field: bytes acknowledgement = 2;
   */
  acknowledgement = new Uint8Array(0);

  constructor(data?: PartialMessage<PacketAcknowledgementData>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.PacketAcknowledgementData";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 2, name: "acknowledgement", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PacketAcknowledgementData {
    return new PacketAcknowledgementData().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PacketAcknowledgementData {
    return new PacketAcknowledgementData().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PacketAcknowledgementData {
    return new PacketAcknowledgementData().fromJsonString(jsonString, options);
  }

  static equals(a: PacketAcknowledgementData | PlainMessage<PacketAcknowledgementData> | undefined, b: PacketAcknowledgementData | PlainMessage<PacketAcknowledgementData> | undefined): boolean {
    return proto3.util.equals(PacketAcknowledgementData, a, b);
  }
}

/**
 * PacketReceiptAbsenceData returns the SignBytes data for
 * packet receipt absence verification.
 *
 * @generated from message ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData
 */
export class PacketReceiptAbsenceData extends Message<PacketReceiptAbsenceData> {
  /**
   * @generated from field: bytes path = 1;
   */
  path = new Uint8Array(0);

  constructor(data?: PartialMessage<PacketReceiptAbsenceData>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PacketReceiptAbsenceData {
    return new PacketReceiptAbsenceData().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PacketReceiptAbsenceData {
    return new PacketReceiptAbsenceData().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PacketReceiptAbsenceData {
    return new PacketReceiptAbsenceData().fromJsonString(jsonString, options);
  }

  static equals(a: PacketReceiptAbsenceData | PlainMessage<PacketReceiptAbsenceData> | undefined, b: PacketReceiptAbsenceData | PlainMessage<PacketReceiptAbsenceData> | undefined): boolean {
    return proto3.util.equals(PacketReceiptAbsenceData, a, b);
  }
}

/**
 * NextSequenceRecvData returns the SignBytes data for verification of the next
 * sequence to be received.
 *
 * @generated from message ibc.lightclients.solomachine.v2.NextSequenceRecvData
 */
export class NextSequenceRecvData extends Message<NextSequenceRecvData> {
  /**
   * @generated from field: bytes path = 1;
   */
  path = new Uint8Array(0);

  /**
   * @generated from field: uint64 next_seq_recv = 2;
   */
  nextSeqRecv = protoInt64.zero;

  constructor(data?: PartialMessage<NextSequenceRecvData>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "ibc.lightclients.solomachine.v2.NextSequenceRecvData";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 2, name: "next_seq_recv", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NextSequenceRecvData {
    return new NextSequenceRecvData().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NextSequenceRecvData {
    return new NextSequenceRecvData().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NextSequenceRecvData {
    return new NextSequenceRecvData().fromJsonString(jsonString, options);
  }

  static equals(a: NextSequenceRecvData | PlainMessage<NextSequenceRecvData> | undefined, b: NextSequenceRecvData | PlainMessage<NextSequenceRecvData> | undefined): boolean {
    return proto3.util.equals(NextSequenceRecvData, a, b);
  }
}