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

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { Coin, DecCoin } from "../../base/v1beta1/coin_pb.js";

/**
 * Params defines the set of params for the distribution module.
 *
 * @generated from message cosmos.distribution.v1beta1.Params
 */
export class Params extends Message<Params> {
  /**
   * @generated from field: string community_tax = 1;
   */
  communityTax = "";

  /**
   * Deprecated: The base_proposer_reward field is deprecated and is no longer used
   * in the x/distribution module's reward mechanism.
   *
   * @generated from field: string base_proposer_reward = 2 [deprecated = true];
   * @deprecated
   */
  baseProposerReward = "";

  /**
   * Deprecated: The bonus_proposer_reward field is deprecated and is no longer used
   * in the x/distribution module's reward mechanism.
   *
   * @generated from field: string bonus_proposer_reward = 3 [deprecated = true];
   * @deprecated
   */
  bonusProposerReward = "";

  /**
   * @generated from field: bool withdraw_addr_enabled = 4;
   */
  withdrawAddrEnabled = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.distribution.v1beta1.Params";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "community_tax", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "base_proposer_reward", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "bonus_proposer_reward", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "withdraw_addr_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  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);
  }
}

/**
 * ValidatorHistoricalRewards represents historical rewards for a validator.
 * Height is implicit within the store key.
 * Cumulative reward ratio is the sum from the zeroeth period
 * until this period of rewards / tokens, per the spec.
 * The reference count indicates the number of objects
 * which might need to reference this historical entry at any point.
 * ReferenceCount =
 *    number of outstanding delegations which ended the associated period (and
 *    might need to read that record)
 *  + number of slashes which ended the associated period (and might need to
 *  read that record)
 *  + one per validator for the zeroeth period, set on initialization
 *
 * @generated from message cosmos.distribution.v1beta1.ValidatorHistoricalRewards
 */
export class ValidatorHistoricalRewards extends Message<ValidatorHistoricalRewards> {
  /**
   * @generated from field: repeated cosmos.base.v1beta1.DecCoin cumulative_reward_ratio = 1;
   */
  cumulativeRewardRatio: DecCoin[] = [];

  /**
   * @generated from field: uint32 reference_count = 2;
   */
  referenceCount = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.distribution.v1beta1.ValidatorHistoricalRewards";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "cumulative_reward_ratio", kind: "message", T: DecCoin, repeated: true },
    { no: 2, name: "reference_count", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
  ]);

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

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

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

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

/**
 * ValidatorCurrentRewards represents current rewards and current
 * period for a validator kept as a running counter and incremented
 * each block as long as the validator's tokens remain constant.
 *
 * @generated from message cosmos.distribution.v1beta1.ValidatorCurrentRewards
 */
export class ValidatorCurrentRewards extends Message<ValidatorCurrentRewards> {
  /**
   * @generated from field: repeated cosmos.base.v1beta1.DecCoin rewards = 1;
   */
  rewards: DecCoin[] = [];

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.distribution.v1beta1.ValidatorCurrentRewards";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "rewards", kind: "message", T: DecCoin, repeated: true },
    { no: 2, name: "period", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
  ]);

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

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

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

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

/**
 * ValidatorAccumulatedCommission represents accumulated commission
 * for a validator kept as a running counter, can be withdrawn at any time.
 *
 * @generated from message cosmos.distribution.v1beta1.ValidatorAccumulatedCommission
 */
export class ValidatorAccumulatedCommission extends Message<ValidatorAccumulatedCommission> {
  /**
   * @generated from field: repeated cosmos.base.v1beta1.DecCoin commission = 1;
   */
  commission: DecCoin[] = [];

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

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

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

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

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

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

/**
 * ValidatorOutstandingRewards represents outstanding (un-withdrawn) rewards
 * for a validator inexpensive to track, allows simple sanity checks.
 *
 * @generated from message cosmos.distribution.v1beta1.ValidatorOutstandingRewards
 */
export class ValidatorOutstandingRewards extends Message<ValidatorOutstandingRewards> {
  /**
   * @generated from field: repeated cosmos.base.v1beta1.DecCoin rewards = 1;
   */
  rewards: DecCoin[] = [];

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

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

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

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

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

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

/**
 * ValidatorSlashEvent represents a validator slash event.
 * Height is implicit within the store key.
 * This is needed to calculate appropriate amount of staking tokens
 * for delegations which are withdrawn after a slash has occurred.
 *
 * @generated from message cosmos.distribution.v1beta1.ValidatorSlashEvent
 */
export class ValidatorSlashEvent extends Message<ValidatorSlashEvent> {
  /**
   * @generated from field: uint64 validator_period = 1;
   */
  validatorPeriod = protoInt64.zero;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.distribution.v1beta1.ValidatorSlashEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "validator_period", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 2, name: "fraction", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * ValidatorSlashEvents is a collection of ValidatorSlashEvent messages.
 *
 * @generated from message cosmos.distribution.v1beta1.ValidatorSlashEvents
 */
export class ValidatorSlashEvents extends Message<ValidatorSlashEvents> {
  /**
   * @generated from field: repeated cosmos.distribution.v1beta1.ValidatorSlashEvent validator_slash_events = 1;
   */
  validatorSlashEvents: ValidatorSlashEvent[] = [];

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

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

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

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

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

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

/**
 * FeePool is the global fee pool for distribution.
 *
 * @generated from message cosmos.distribution.v1beta1.FeePool
 */
export class FeePool extends Message<FeePool> {
  /**
   * @generated from field: repeated cosmos.base.v1beta1.DecCoin community_pool = 1;
   */
  communityPool: DecCoin[] = [];

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

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

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

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

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

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

/**
 * CommunityPoolSpendProposal details a proposal for use of community funds,
 * together with how many coins are proposed to be spent, and to which
 * recipient account.
 *
 * Deprecated: Do not use. As of the Cosmos SDK release v0.47.x, there is no
 * longer a need for an explicit CommunityPoolSpendProposal. To spend community
 * pool funds, a simple MsgCommunityPoolSpend can be invoked from the x/gov
 * module via a v1 governance proposal.
 *
 * @generated from message cosmos.distribution.v1beta1.CommunityPoolSpendProposal
 * @deprecated
 */
export class CommunityPoolSpendProposal extends Message<CommunityPoolSpendProposal> {
  /**
   * @generated from field: string title = 1;
   */
  title = "";

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

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

  /**
   * @generated from field: repeated cosmos.base.v1beta1.Coin amount = 4;
   */
  amount: Coin[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.distribution.v1beta1.CommunityPoolSpendProposal";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "title", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "recipient", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "amount", kind: "message", T: Coin, repeated: true },
  ]);

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

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

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

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

/**
 * DelegatorStartingInfo represents the starting info for a delegator reward
 * period. It tracks the previous validator period, the delegation's amount of
 * staking token, and the creation height (to check later on if any slashes have
 * occurred). NOTE: Even though validators are slashed to whole staking tokens,
 * the delegators within the validator may be left with less than a full token,
 * thus sdk.Dec is used.
 *
 * @generated from message cosmos.distribution.v1beta1.DelegatorStartingInfo
 */
export class DelegatorStartingInfo extends Message<DelegatorStartingInfo> {
  /**
   * @generated from field: uint64 previous_period = 1;
   */
  previousPeriod = protoInt64.zero;

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.distribution.v1beta1.DelegatorStartingInfo";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "previous_period", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 2, name: "stake", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "height", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
  ]);

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

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

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

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

/**
 * DelegationDelegatorReward represents the properties
 * of a delegator's delegation reward.
 *
 * @generated from message cosmos.distribution.v1beta1.DelegationDelegatorReward
 */
export class DelegationDelegatorReward extends Message<DelegationDelegatorReward> {
  /**
   * @generated from field: string validator_address = 1;
   */
  validatorAddress = "";

  /**
   * @generated from field: repeated cosmos.base.v1beta1.DecCoin reward = 2;
   */
  reward: DecCoin[] = [];

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

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

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

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

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

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

/**
 * CommunityPoolSpendProposalWithDeposit defines a CommunityPoolSpendProposal
 * with a deposit
 *
 * @generated from message cosmos.distribution.v1beta1.CommunityPoolSpendProposalWithDeposit
 */
export class CommunityPoolSpendProposalWithDeposit extends Message<CommunityPoolSpendProposalWithDeposit> {
  /**
   * @generated from field: string title = 1;
   */
  title = "";

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "cosmos.distribution.v1beta1.CommunityPoolSpendProposalWithDeposit";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "title", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "recipient", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "amount", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "deposit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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