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

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Duration, Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf";
import { Header } from "../../../tendermint/types/types_pb.js";
import { Coin } from "../../base/v1beta1/coin_pb.js";
import { ValidatorUpdate } from "../../../tendermint/abci/types_pb.js";

/**
 * BondStatus is the status of a validator.
 *
 * @generated from enum cosmos.staking.v1beta1.BondStatus
 */
export enum BondStatus {
  /**
   * UNSPECIFIED defines an invalid validator status.
   *
   * @generated from enum value: BOND_STATUS_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

  /**
   * UNBONDED defines a validator that is not bonded.
   *
   * @generated from enum value: BOND_STATUS_UNBONDED = 1;
   */
  UNBONDED = 1,

  /**
   * UNBONDING defines a validator that is unbonding.
   *
   * @generated from enum value: BOND_STATUS_UNBONDING = 2;
   */
  UNBONDING = 2,

  /**
   * BONDED defines a validator that is bonded.
   *
   * @generated from enum value: BOND_STATUS_BONDED = 3;
   */
  BONDED = 3,
}
// Retrieve enum metadata with: proto3.getEnumType(BondStatus)
proto3.util.setEnumType(BondStatus, "cosmos.staking.v1beta1.BondStatus", [
  { no: 0, name: "BOND_STATUS_UNSPECIFIED" },
  { no: 1, name: "BOND_STATUS_UNBONDED" },
  { no: 2, name: "BOND_STATUS_UNBONDING" },
  { no: 3, name: "BOND_STATUS_BONDED" },
]);

/**
 * Infraction indicates the infraction a validator commited.
 *
 * @generated from enum cosmos.staking.v1beta1.Infraction
 */
export enum Infraction {
  /**
   * UNSPECIFIED defines an empty infraction.
   *
   * @generated from enum value: INFRACTION_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

  /**
   * DOUBLE_SIGN defines a validator that double-signs a block.
   *
   * @generated from enum value: INFRACTION_DOUBLE_SIGN = 1;
   */
  DOUBLE_SIGN = 1,

  /**
   * DOWNTIME defines a validator that missed signing too many blocks.
   *
   * @generated from enum value: INFRACTION_DOWNTIME = 2;
   */
  DOWNTIME = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(Infraction)
proto3.util.setEnumType(Infraction, "cosmos.staking.v1beta1.Infraction", [
  { no: 0, name: "INFRACTION_UNSPECIFIED" },
  { no: 1, name: "INFRACTION_DOUBLE_SIGN" },
  { no: 2, name: "INFRACTION_DOWNTIME" },
]);

/**
 * HistoricalInfo contains header and validator information for a given block.
 * It is stored as part of staking module's state, which persists the `n` most
 * recent HistoricalInfo
 * (`n` is set by the staking module's `historical_entries` parameter).
 *
 * @generated from message cosmos.staking.v1beta1.HistoricalInfo
 */
export class HistoricalInfo extends Message<HistoricalInfo> {
  /**
   * @generated from field: tendermint.types.Header header = 1;
   */
  header?: Header;

  /**
   * @generated from field: repeated cosmos.staking.v1beta1.Validator valset = 2;
   */
  valset: Validator[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.HistoricalInfo";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "header", kind: "message", T: Header },
    { no: 2, name: "valset", kind: "message", T: Validator, repeated: true },
  ]);

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

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

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

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

/**
 * CommissionRates defines the initial commission rates to be used for creating
 * a validator.
 *
 * @generated from message cosmos.staking.v1beta1.CommissionRates
 */
export class CommissionRates extends Message<CommissionRates> {
  /**
   * rate is the commission rate charged to delegators, as a fraction.
   *
   * @generated from field: string rate = 1;
   */
  rate = "";

  /**
   * max_rate defines the maximum commission rate which validator can ever charge, as a fraction.
   *
   * @generated from field: string max_rate = 2;
   */
  maxRate = "";

  /**
   * max_change_rate defines the maximum daily increase of the validator commission, as a fraction.
   *
   * @generated from field: string max_change_rate = 3;
   */
  maxChangeRate = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.CommissionRates";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "rate", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "max_rate", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "max_change_rate", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * Commission defines commission parameters for a given validator.
 *
 * @generated from message cosmos.staking.v1beta1.Commission
 */
export class Commission extends Message<Commission> {
  /**
   * commission_rates defines the initial commission rates to be used for creating a validator.
   *
   * @generated from field: cosmos.staking.v1beta1.CommissionRates commission_rates = 1;
   */
  commissionRates?: CommissionRates;

  /**
   * update_time is the last time the commission rate was changed.
   *
   * @generated from field: google.protobuf.Timestamp update_time = 2;
   */
  updateTime?: Timestamp;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.Commission";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "commission_rates", kind: "message", T: CommissionRates },
    { no: 2, name: "update_time", kind: "message", T: Timestamp },
  ]);

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

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

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

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

/**
 * Description defines a validator description.
 *
 * @generated from message cosmos.staking.v1beta1.Description
 */
export class Description extends Message<Description> {
  /**
   * moniker defines a human-readable name for the validator.
   *
   * @generated from field: string moniker = 1;
   */
  moniker = "";

  /**
   * identity defines an optional identity signature (ex. UPort or Keybase).
   *
   * @generated from field: string identity = 2;
   */
  identity = "";

  /**
   * website defines an optional website link.
   *
   * @generated from field: string website = 3;
   */
  website = "";

  /**
   * security_contact defines an optional email for security contact.
   *
   * @generated from field: string security_contact = 4;
   */
  securityContact = "";

  /**
   * details define other optional details.
   *
   * @generated from field: string details = 5;
   */
  details = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.Description";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "moniker", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "identity", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "website", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "security_contact", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "details", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * Validator defines a validator, together with the total amount of the
 * Validator's bond shares and their exchange rate to coins. Slashing results in
 * a decrease in the exchange rate, allowing correct calculation of future
 * undelegations without iterating over delegators. When coins are delegated to
 * this validator, the validator is credited with a delegation whose number of
 * bond shares is based on the amount of coins delegated divided by the current
 * exchange rate. Voting power can be calculated as total bonded shares
 * multiplied by exchange rate.
 *
 * @generated from message cosmos.staking.v1beta1.Validator
 */
export class Validator extends Message<Validator> {
  /**
   * operator_address defines the address of the validator's operator; bech encoded in JSON.
   *
   * @generated from field: string operator_address = 1;
   */
  operatorAddress = "";

  /**
   * consensus_pubkey is the consensus public key of the validator, as a Protobuf Any.
   *
   * @generated from field: google.protobuf.Any consensus_pubkey = 2;
   */
  consensusPubkey?: Any;

  /**
   * jailed defined whether the validator has been jailed from bonded status or not.
   *
   * @generated from field: bool jailed = 3;
   */
  jailed = false;

  /**
   * status is the validator status (bonded/unbonding/unbonded).
   *
   * @generated from field: cosmos.staking.v1beta1.BondStatus status = 4;
   */
  status = BondStatus.UNSPECIFIED;

  /**
   * tokens define the delegated tokens (incl. self-delegation).
   *
   * @generated from field: string tokens = 5;
   */
  tokens = "";

  /**
   * delegator_shares defines total shares issued to a validator's delegators.
   *
   * @generated from field: string delegator_shares = 6;
   */
  delegatorShares = "";

  /**
   * description defines the description terms for the validator.
   *
   * @generated from field: cosmos.staking.v1beta1.Description description = 7;
   */
  description?: Description;

  /**
   * unbonding_height defines, if unbonding, the height at which this validator has begun unbonding.
   *
   * @generated from field: int64 unbonding_height = 8;
   */
  unbondingHeight = protoInt64.zero;

  /**
   * unbonding_time defines, if unbonding, the min time for the validator to complete unbonding.
   *
   * @generated from field: google.protobuf.Timestamp unbonding_time = 9;
   */
  unbondingTime?: Timestamp;

  /**
   * commission defines the commission parameters.
   *
   * @generated from field: cosmos.staking.v1beta1.Commission commission = 10;
   */
  commission?: Commission;

  /**
   * min_self_delegation is the validator's self declared minimum self delegation.
   *
   * Since: cosmos-sdk 0.46
   *
   * @generated from field: string min_self_delegation = 11;
   */
  minSelfDelegation = "";

  /**
   * strictly positive if this validator's unbonding has been stopped by external modules
   *
   * @generated from field: int64 unbonding_on_hold_ref_count = 12;
   */
  unbondingOnHoldRefCount = protoInt64.zero;

  /**
   * list of unbonding ids, each uniquely identifing an unbonding of this validator
   *
   * @generated from field: repeated uint64 unbonding_ids = 13;
   */
  unbondingIds: bigint[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.Validator";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "operator_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "consensus_pubkey", kind: "message", T: Any },
    { no: 3, name: "jailed", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 4, name: "status", kind: "enum", T: proto3.getEnumType(BondStatus) },
    { no: 5, name: "tokens", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "delegator_shares", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "description", kind: "message", T: Description },
    { no: 8, name: "unbonding_height", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 9, name: "unbonding_time", kind: "message", T: Timestamp },
    { no: 10, name: "commission", kind: "message", T: Commission },
    { no: 11, name: "min_self_delegation", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 12, name: "unbonding_on_hold_ref_count", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 13, name: "unbonding_ids", kind: "scalar", T: 4 /* ScalarType.UINT64 */, repeated: true },
  ]);

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

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

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

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

/**
 * ValAddresses defines a repeated set of validator addresses.
 *
 * @generated from message cosmos.staking.v1beta1.ValAddresses
 */
export class ValAddresses extends Message<ValAddresses> {
  /**
   * @generated from field: repeated string addresses = 1;
   */
  addresses: string[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.ValAddresses";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "addresses", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

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

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

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

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

/**
 * DVPair is struct that just has a delegator-validator pair with no other data.
 * It is intended to be used as a marshalable pointer. For example, a DVPair can
 * be used to construct the key to getting an UnbondingDelegation from state.
 *
 * @generated from message cosmos.staking.v1beta1.DVPair
 */
export class DVPair extends Message<DVPair> {
  /**
   * @generated from field: string delegator_address = 1;
   */
  delegatorAddress = "";

  /**
   * @generated from field: string validator_address = 2;
   */
  validatorAddress = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.DVPair";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "delegator_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "validator_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * DVPairs defines an array of DVPair objects.
 *
 * @generated from message cosmos.staking.v1beta1.DVPairs
 */
export class DVPairs extends Message<DVPairs> {
  /**
   * @generated from field: repeated cosmos.staking.v1beta1.DVPair pairs = 1;
   */
  pairs: DVPair[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.DVPairs";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "pairs", kind: "message", T: DVPair, repeated: true },
  ]);

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

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

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

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

/**
 * DVVTriplet is struct that just has a delegator-validator-validator triplet
 * with no other data. It is intended to be used as a marshalable pointer. For
 * example, a DVVTriplet can be used to construct the key to getting a
 * Redelegation from state.
 *
 * @generated from message cosmos.staking.v1beta1.DVVTriplet
 */
export class DVVTriplet extends Message<DVVTriplet> {
  /**
   * @generated from field: string delegator_address = 1;
   */
  delegatorAddress = "";

  /**
   * @generated from field: string validator_src_address = 2;
   */
  validatorSrcAddress = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.DVVTriplet";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "delegator_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "validator_src_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "validator_dst_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * DVVTriplets defines an array of DVVTriplet objects.
 *
 * @generated from message cosmos.staking.v1beta1.DVVTriplets
 */
export class DVVTriplets extends Message<DVVTriplets> {
  /**
   * @generated from field: repeated cosmos.staking.v1beta1.DVVTriplet triplets = 1;
   */
  triplets: DVVTriplet[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.DVVTriplets";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "triplets", kind: "message", T: DVVTriplet, repeated: true },
  ]);

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

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

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

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

/**
 * Delegation represents the bond with tokens held by an account. It is
 * owned by one delegator, and is associated with the voting power of one
 * validator.
 *
 * @generated from message cosmos.staking.v1beta1.Delegation
 */
export class Delegation extends Message<Delegation> {
  /**
   * delegator_address is the bech32-encoded address of the delegator.
   *
   * @generated from field: string delegator_address = 1;
   */
  delegatorAddress = "";

  /**
   * validator_address is the bech32-encoded address of the validator.
   *
   * @generated from field: string validator_address = 2;
   */
  validatorAddress = "";

  /**
   * shares define the delegation shares received.
   *
   * @generated from field: string shares = 3;
   */
  shares = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.Delegation";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "delegator_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "validator_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "shares", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * UnbondingDelegation stores all of a single delegator's unbonding bonds
 * for a single validator in an time-ordered list.
 *
 * @generated from message cosmos.staking.v1beta1.UnbondingDelegation
 */
export class UnbondingDelegation extends Message<UnbondingDelegation> {
  /**
   * delegator_address is the bech32-encoded address of the delegator.
   *
   * @generated from field: string delegator_address = 1;
   */
  delegatorAddress = "";

  /**
   * validator_address is the bech32-encoded address of the validator.
   *
   * @generated from field: string validator_address = 2;
   */
  validatorAddress = "";

  /**
   * entries are the unbonding delegation entries.
   *
   * unbonding delegation entries
   *
   * @generated from field: repeated cosmos.staking.v1beta1.UnbondingDelegationEntry entries = 3;
   */
  entries: UnbondingDelegationEntry[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.UnbondingDelegation";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "delegator_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "validator_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "entries", kind: "message", T: UnbondingDelegationEntry, repeated: true },
  ]);

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

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

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

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

/**
 * UnbondingDelegationEntry defines an unbonding object with relevant metadata.
 *
 * @generated from message cosmos.staking.v1beta1.UnbondingDelegationEntry
 */
export class UnbondingDelegationEntry extends Message<UnbondingDelegationEntry> {
  /**
   * creation_height is the height which the unbonding took place.
   *
   * @generated from field: int64 creation_height = 1;
   */
  creationHeight = protoInt64.zero;

  /**
   * completion_time is the unix time for unbonding completion.
   *
   * @generated from field: google.protobuf.Timestamp completion_time = 2;
   */
  completionTime?: Timestamp;

  /**
   * initial_balance defines the tokens initially scheduled to receive at completion.
   *
   * @generated from field: string initial_balance = 3;
   */
  initialBalance = "";

  /**
   * balance defines the tokens to receive at completion.
   *
   * @generated from field: string balance = 4;
   */
  balance = "";

  /**
   * Incrementing id that uniquely identifies this entry
   *
   * @generated from field: uint64 unbonding_id = 5;
   */
  unbondingId = protoInt64.zero;

  /**
   * Strictly positive if this entry's unbonding has been stopped by external modules
   *
   * @generated from field: int64 unbonding_on_hold_ref_count = 6;
   */
  unbondingOnHoldRefCount = protoInt64.zero;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.UnbondingDelegationEntry";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "creation_height", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 2, name: "completion_time", kind: "message", T: Timestamp },
    { no: 3, name: "initial_balance", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "balance", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "unbonding_id", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 6, name: "unbonding_on_hold_ref_count", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
  ]);

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

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

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

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

/**
 * RedelegationEntry defines a redelegation object with relevant metadata.
 *
 * @generated from message cosmos.staking.v1beta1.RedelegationEntry
 */
export class RedelegationEntry extends Message<RedelegationEntry> {
  /**
   * creation_height  defines the height which the redelegation took place.
   *
   * @generated from field: int64 creation_height = 1;
   */
  creationHeight = protoInt64.zero;

  /**
   * completion_time defines the unix time for redelegation completion.
   *
   * @generated from field: google.protobuf.Timestamp completion_time = 2;
   */
  completionTime?: Timestamp;

  /**
   * initial_balance defines the initial balance when redelegation started.
   *
   * @generated from field: string initial_balance = 3;
   */
  initialBalance = "";

  /**
   * shares_dst is the amount of destination-validator shares created by redelegation.
   *
   * @generated from field: string shares_dst = 4;
   */
  sharesDst = "";

  /**
   * Incrementing id that uniquely identifies this entry
   *
   * @generated from field: uint64 unbonding_id = 5;
   */
  unbondingId = protoInt64.zero;

  /**
   * Strictly positive if this entry's unbonding has been stopped by external modules
   *
   * @generated from field: int64 unbonding_on_hold_ref_count = 6;
   */
  unbondingOnHoldRefCount = protoInt64.zero;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.RedelegationEntry";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "creation_height", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 2, name: "completion_time", kind: "message", T: Timestamp },
    { no: 3, name: "initial_balance", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "shares_dst", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "unbonding_id", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 6, name: "unbonding_on_hold_ref_count", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
  ]);

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

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

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

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

/**
 * Redelegation contains the list of a particular delegator's redelegating bonds
 * from a particular source validator to a particular destination validator.
 *
 * @generated from message cosmos.staking.v1beta1.Redelegation
 */
export class Redelegation extends Message<Redelegation> {
  /**
   * delegator_address is the bech32-encoded address of the delegator.
   *
   * @generated from field: string delegator_address = 1;
   */
  delegatorAddress = "";

  /**
   * validator_src_address is the validator redelegation source operator address.
   *
   * @generated from field: string validator_src_address = 2;
   */
  validatorSrcAddress = "";

  /**
   * validator_dst_address is the validator redelegation destination operator address.
   *
   * @generated from field: string validator_dst_address = 3;
   */
  validatorDstAddress = "";

  /**
   * entries are the redelegation entries.
   *
   * redelegation entries
   *
   * @generated from field: repeated cosmos.staking.v1beta1.RedelegationEntry entries = 4;
   */
  entries: RedelegationEntry[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.Redelegation";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "delegator_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "validator_src_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "validator_dst_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "entries", kind: "message", T: RedelegationEntry, repeated: true },
  ]);

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

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

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

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

/**
 * Params defines the parameters for the x/staking module.
 *
 * @generated from message cosmos.staking.v1beta1.Params
 */
export class Params extends Message<Params> {
  /**
   * unbonding_time is the time duration of unbonding.
   *
   * @generated from field: google.protobuf.Duration unbonding_time = 1;
   */
  unbondingTime?: Duration;

  /**
   * max_validators is the maximum number of validators.
   *
   * @generated from field: uint32 max_validators = 2;
   */
  maxValidators = 0;

  /**
   * max_entries is the max entries for either unbonding delegation or redelegation (per pair/trio).
   *
   * @generated from field: uint32 max_entries = 3;
   */
  maxEntries = 0;

  /**
   * historical_entries is the number of historical entries to persist.
   *
   * @generated from field: uint32 historical_entries = 4;
   */
  historicalEntries = 0;

  /**
   * bond_denom defines the bondable coin denomination.
   *
   * @generated from field: string bond_denom = 5;
   */
  bondDenom = "";

  /**
   * min_commission_rate is the chain-wide minimum commission rate that a validator can charge their delegators
   *
   * @generated from field: string min_commission_rate = 6;
   */
  minCommissionRate = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.Params";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "unbonding_time", kind: "message", T: Duration },
    { no: 2, name: "max_validators", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 3, name: "max_entries", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 4, name: "historical_entries", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 5, name: "bond_denom", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "min_commission_rate", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * DelegationResponse is equivalent to Delegation except that it contains a
 * balance in addition to shares which is more suitable for client responses.
 *
 * @generated from message cosmos.staking.v1beta1.DelegationResponse
 */
export class DelegationResponse extends Message<DelegationResponse> {
  /**
   * @generated from field: cosmos.staking.v1beta1.Delegation delegation = 1;
   */
  delegation?: Delegation;

  /**
   * @generated from field: cosmos.base.v1beta1.Coin balance = 2;
   */
  balance?: Coin;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.DelegationResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "delegation", kind: "message", T: Delegation },
    { no: 2, name: "balance", kind: "message", T: Coin },
  ]);

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

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

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

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

/**
 * RedelegationEntryResponse is equivalent to a RedelegationEntry except that it
 * contains a balance in addition to shares which is more suitable for client
 * responses.
 *
 * @generated from message cosmos.staking.v1beta1.RedelegationEntryResponse
 */
export class RedelegationEntryResponse extends Message<RedelegationEntryResponse> {
  /**
   * @generated from field: cosmos.staking.v1beta1.RedelegationEntry redelegation_entry = 1;
   */
  redelegationEntry?: RedelegationEntry;

  /**
   * @generated from field: string balance = 4;
   */
  balance = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.RedelegationEntryResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "redelegation_entry", kind: "message", T: RedelegationEntry },
    { no: 4, name: "balance", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * RedelegationResponse is equivalent to a Redelegation except that its entries
 * contain a balance in addition to shares which is more suitable for client
 * responses.
 *
 * @generated from message cosmos.staking.v1beta1.RedelegationResponse
 */
export class RedelegationResponse extends Message<RedelegationResponse> {
  /**
   * @generated from field: cosmos.staking.v1beta1.Redelegation redelegation = 1;
   */
  redelegation?: Redelegation;

  /**
   * @generated from field: repeated cosmos.staking.v1beta1.RedelegationEntryResponse entries = 2;
   */
  entries: RedelegationEntryResponse[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.RedelegationResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "redelegation", kind: "message", T: Redelegation },
    { no: 2, name: "entries", kind: "message", T: RedelegationEntryResponse, repeated: true },
  ]);

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

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

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

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

/**
 * Pool is used for tracking bonded and not-bonded token supply of the bond
 * denomination.
 *
 * @generated from message cosmos.staking.v1beta1.Pool
 */
export class Pool extends Message<Pool> {
  /**
   * @generated from field: string not_bonded_tokens = 1;
   */
  notBondedTokens = "";

  /**
   * @generated from field: string bonded_tokens = 2;
   */
  bondedTokens = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.Pool";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "not_bonded_tokens", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "bonded_tokens", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * ValidatorUpdates defines an array of abci.ValidatorUpdate objects.
 * TODO: explore moving this to proto/cosmos/base to separate modules from tendermint dependence
 *
 * @generated from message cosmos.staking.v1beta1.ValidatorUpdates
 */
export class ValidatorUpdates extends Message<ValidatorUpdates> {
  /**
   * @generated from field: repeated tendermint.abci.ValidatorUpdate updates = 1;
   */
  updates: ValidatorUpdate[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.staking.v1beta1.ValidatorUpdates";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "updates", kind: "message", T: ValidatorUpdate, repeated: true },
  ]);

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

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

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

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