import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
import { Timestamp } from "../../../google/protobuf/timestamp";
import { Any, AnyAmino } from "../../../google/protobuf/any";
import { Duration, DurationAmino } from "../../../google/protobuf/duration";
import { BinaryReader, BinaryWriter } from "../../../binary";
export declare const protobufPackage = "atomone.gov.v1";
/** VoteOption enumerates the valid vote options for a given governance proposal. */
export declare enum VoteOption {
    /** VOTE_OPTION_UNSPECIFIED - VOTE_OPTION_UNSPECIFIED defines a no-op vote option. */
    VOTE_OPTION_UNSPECIFIED = 0,
    /** VOTE_OPTION_YES - VOTE_OPTION_YES defines a yes vote option. */
    VOTE_OPTION_YES = 1,
    /** VOTE_OPTION_ABSTAIN - VOTE_OPTION_ABSTAIN defines an abstain vote option. */
    VOTE_OPTION_ABSTAIN = 2,
    /** VOTE_OPTION_NO - VOTE_OPTION_NO defines a no vote option. */
    VOTE_OPTION_NO = 3,
    UNRECOGNIZED = -1
}
export declare const VoteOptionAmino: typeof VoteOption;
export declare function voteOptionFromJSON(object: any): VoteOption;
export declare function voteOptionToJSON(object: VoteOption): string;
/** ProposalStatus enumerates the valid statuses of a proposal. */
export declare enum ProposalStatus {
    /** PROPOSAL_STATUS_UNSPECIFIED - PROPOSAL_STATUS_UNSPECIFIED defines the default proposal status. */
    PROPOSAL_STATUS_UNSPECIFIED = 0,
    /**
     * PROPOSAL_STATUS_DEPOSIT_PERIOD - PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit
     * period.
     */
    PROPOSAL_STATUS_DEPOSIT_PERIOD = 1,
    /**
     * PROPOSAL_STATUS_VOTING_PERIOD - PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting
     * period.
     */
    PROPOSAL_STATUS_VOTING_PERIOD = 2,
    /**
     * PROPOSAL_STATUS_PASSED - PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has
     * passed.
     */
    PROPOSAL_STATUS_PASSED = 3,
    /**
     * PROPOSAL_STATUS_REJECTED - PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has
     * been rejected.
     */
    PROPOSAL_STATUS_REJECTED = 4,
    /**
     * PROPOSAL_STATUS_FAILED - PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has
     * failed.
     */
    PROPOSAL_STATUS_FAILED = 5,
    /**
     * PROPOSAL_STATUS_VETOED - PROPOSAL_STATUS_VETOED defines a proposal status of a proposal that has
     * been vetoed.
     */
    PROPOSAL_STATUS_VETOED = 6,
    UNRECOGNIZED = -1
}
export declare const ProposalStatusAmino: typeof ProposalStatus;
export declare function proposalStatusFromJSON(object: any): ProposalStatus;
export declare function proposalStatusToJSON(object: ProposalStatus): string;
/** GovernorStatus is the status of a governor. */
export declare enum GovernorStatus {
    /** GOVERNOR_STATUS_UNSPECIFIED - UNSPECIFIED defines an invalid governor status. */
    GOVERNOR_STATUS_UNSPECIFIED = 0,
    /** GOVERNOR_STATUS_ACTIVE - ACTIVE defines a governor that is active. */
    GOVERNOR_STATUS_ACTIVE = 1,
    /** GOVERNOR_STATUS_INACTIVE - INACTIVE defines a governor that is inactive. */
    GOVERNOR_STATUS_INACTIVE = 2,
    UNRECOGNIZED = -1
}
export declare const GovernorStatusAmino: typeof GovernorStatus;
export declare function governorStatusFromJSON(object: any): GovernorStatus;
export declare function governorStatusToJSON(object: GovernorStatus): string;
/** WeightedVoteOption defines a unit of vote for vote split. */
export interface WeightedVoteOption {
    /**
     * option defines the valid vote options, it must not contain duplicate vote
     * options.
     */
    option: VoteOption;
    /** weight is the vote weight associated with the vote option. */
    weight: string;
}
export interface WeightedVoteOptionProtoMsg {
    typeUrl: "/atomone.gov.v1.WeightedVoteOption";
    value: Uint8Array;
}
/** WeightedVoteOption defines a unit of vote for vote split. */
export interface WeightedVoteOptionAmino {
    /**
     * option defines the valid vote options, it must not contain duplicate vote
     * options.
     */
    option?: VoteOption;
    /** weight is the vote weight associated with the vote option. */
    weight?: string;
}
export interface WeightedVoteOptionAminoMsg {
    type: "/atomone.gov.v1.WeightedVoteOption";
    value: WeightedVoteOptionAmino;
}
/**
 * Deposit defines an amount deposited by an account address to an active
 * proposal.
 */
export interface Deposit {
    /** proposal_id defines the unique id of the proposal. */
    proposalId: bigint;
    /** depositor defines the deposit addresses from the proposals. */
    depositor: string;
    /** amount to be deposited by depositor. */
    amount: Coin[];
}
export interface DepositProtoMsg {
    typeUrl: "/atomone.gov.v1.Deposit";
    value: Uint8Array;
}
/**
 * Deposit defines an amount deposited by an account address to an active
 * proposal.
 */
export interface DepositAmino {
    /** proposal_id defines the unique id of the proposal. */
    proposal_id?: string;
    /** depositor defines the deposit addresses from the proposals. */
    depositor?: string;
    /** amount to be deposited by depositor. */
    amount: CoinAmino[];
}
export interface DepositAminoMsg {
    type: "/atomone.gov.v1.Deposit";
    value: DepositAmino;
}
/**
 * LastMinDeposit is a record of the last time the minimum deposit
 * was updated in the store, both its value and a timestamp
 */
export interface LastMinDeposit {
    /** value is the value of the minimum deposit */
    value: Coin[];
    /** time is the time the minimum deposit was last updated */
    time?: Timestamp | undefined;
}
export interface LastMinDepositProtoMsg {
    typeUrl: "/atomone.gov.v1.LastMinDeposit";
    value: Uint8Array;
}
/**
 * LastMinDeposit is a record of the last time the minimum deposit
 * was updated in the store, both its value and a timestamp
 */
export interface LastMinDepositAmino {
    /** value is the value of the minimum deposit */
    value: CoinAmino[];
    /** time is the time the minimum deposit was last updated */
    time?: string | undefined;
}
export interface LastMinDepositAminoMsg {
    type: "/atomone.gov.v1.LastMinDeposit";
    value: LastMinDepositAmino;
}
/** Proposal defines the core field members of a governance proposal. */
export interface Proposal {
    /** id defines the unique id of the proposal. */
    id: bigint;
    /** messages are the arbitrary messages to be executed if the proposal passes. */
    messages: Any[];
    /** status defines the proposal status. */
    status: ProposalStatus;
    /**
     * final_tally_result is the final tally result of the proposal. When
     * querying a proposal via gRPC, this field is not populated until the
     * proposal's voting period has ended.
     */
    finalTallyResult?: TallyResult | undefined;
    /** submit_time is the time of proposal submission. */
    submitTime?: Timestamp | undefined;
    /** deposit_end_time is the end time for deposition. */
    depositEndTime?: Timestamp | undefined;
    /** total_deposit is the total deposit on the proposal. */
    totalDeposit: Coin[];
    /** voting_start_time is the starting time to vote on a proposal. */
    votingStartTime?: Timestamp | undefined;
    /** voting_end_time is the end time of voting on a proposal. */
    votingEndTime?: Timestamp | undefined;
    /** metadata is any arbitrary metadata attached to the proposal. */
    metadata: string;
    /**
     * title is the title of the proposal
     *
     * Since: cosmos-sdk 0.47
     */
    title: string;
    /**
     * summary is a short summary of the proposal
     *
     * Since: cosmos-sdk 0.47
     */
    summary: string;
    /**
     * Proposer is the address of the proposal sumbitter
     *
     * Since: cosmos-sdk 0.47
     */
    proposer: string;
    /**
     * endorsed is a boolean indicating whether the proposal has been endorsed
     * by the Steering DAO.
     */
    endorsed: boolean;
    /**
     * annotation is an optional field that contains annotations
     * added by the Steering DAO.
     */
    annotation: string;
    /**
     * times_voting_period_extended is the number of times the voting period
     * has been extended from one of the core DAOs.
     */
    timesVotingPeriodExtended: number;
}
export interface ProposalProtoMsg {
    typeUrl: "/atomone.gov.v1.Proposal";
    value: Uint8Array;
}
/** Proposal defines the core field members of a governance proposal. */
export interface ProposalAmino {
    /** id defines the unique id of the proposal. */
    id?: string;
    /** messages are the arbitrary messages to be executed if the proposal passes. */
    messages?: AnyAmino[];
    /** status defines the proposal status. */
    status?: ProposalStatus;
    /**
     * final_tally_result is the final tally result of the proposal. When
     * querying a proposal via gRPC, this field is not populated until the
     * proposal's voting period has ended.
     */
    final_tally_result?: TallyResultAmino | undefined;
    /** submit_time is the time of proposal submission. */
    submit_time?: string | undefined;
    /** deposit_end_time is the end time for deposition. */
    deposit_end_time?: string | undefined;
    /** total_deposit is the total deposit on the proposal. */
    total_deposit: CoinAmino[];
    /** voting_start_time is the starting time to vote on a proposal. */
    voting_start_time?: string | undefined;
    /** voting_end_time is the end time of voting on a proposal. */
    voting_end_time?: string | undefined;
    /** metadata is any arbitrary metadata attached to the proposal. */
    metadata?: string;
    /**
     * title is the title of the proposal
     *
     * Since: cosmos-sdk 0.47
     */
    title?: string;
    /**
     * summary is a short summary of the proposal
     *
     * Since: cosmos-sdk 0.47
     */
    summary?: string;
    /**
     * Proposer is the address of the proposal sumbitter
     *
     * Since: cosmos-sdk 0.47
     */
    proposer?: string;
    /**
     * endorsed is a boolean indicating whether the proposal has been endorsed
     * by the Steering DAO.
     */
    endorsed?: boolean;
    /**
     * annotation is an optional field that contains annotations
     * added by the Steering DAO.
     */
    annotation?: string;
    /**
     * times_voting_period_extended is the number of times the voting period
     * has been extended from one of the core DAOs.
     */
    times_voting_period_extended?: number;
}
export interface ProposalAminoMsg {
    type: "/atomone.gov.v1.Proposal";
    value: ProposalAmino;
}
/** TallyResult defines a standard tally for a governance proposal. */
export interface TallyResult {
    /** yes_count is the number of yes votes on a proposal. */
    yesCount: string;
    /** abstain_count is the number of abstain votes on a proposal. */
    abstainCount: string;
    /** no_count is the number of no votes on a proposal. */
    noCount: string;
}
export interface TallyResultProtoMsg {
    typeUrl: "/atomone.gov.v1.TallyResult";
    value: Uint8Array;
}
/** TallyResult defines a standard tally for a governance proposal. */
export interface TallyResultAmino {
    /** yes_count is the number of yes votes on a proposal. */
    yes_count?: string;
    /** abstain_count is the number of abstain votes on a proposal. */
    abstain_count?: string;
    /** no_count is the number of no votes on a proposal. */
    no_count?: string;
}
export interface TallyResultAminoMsg {
    type: "/atomone.gov.v1.TallyResult";
    value: TallyResultAmino;
}
/**
 * Vote defines a vote on a governance proposal.
 * A Vote consists of a proposal ID, the voter, and the vote option.
 */
export interface Vote {
    /** proposal_id defines the unique id of the proposal. */
    proposalId: bigint;
    /** voter is the voter address of the proposal. */
    voter: string;
    /** options is the weighted vote options. */
    options: WeightedVoteOption[];
    /** metadata is any  arbitrary metadata to attached to the vote. */
    metadata: string;
}
export interface VoteProtoMsg {
    typeUrl: "/atomone.gov.v1.Vote";
    value: Uint8Array;
}
/**
 * Vote defines a vote on a governance proposal.
 * A Vote consists of a proposal ID, the voter, and the vote option.
 */
export interface VoteAmino {
    /** proposal_id defines the unique id of the proposal. */
    proposal_id?: string;
    /** voter is the voter address of the proposal. */
    voter?: string;
    /** options is the weighted vote options. */
    options?: WeightedVoteOptionAmino[];
    /** metadata is any  arbitrary metadata to attached to the vote. */
    metadata?: string;
}
export interface VoteAminoMsg {
    type: "/atomone.gov.v1.Vote";
    value: VoteAmino;
}
/** QuorumCheckQueueEntry defines a quorum check queue entry. */
export interface QuorumCheckQueueEntry {
    /**
     * quorum_timeout_time is the time after which quorum checks start happening
     * and voting period is extended if proposal reaches quorum.
     */
    quorumTimeoutTime?: Timestamp | undefined;
    /**
     * quorum_check_count is the number of times quorum will be checked.
     * This is a snapshot of the parameter value with the same name when the
     * proposal is initially added to the queue.
     */
    quorumCheckCount: bigint;
    /** quorum_checks_done is the number of quorum checks that have been done. */
    quorumChecksDone: bigint;
}
export interface QuorumCheckQueueEntryProtoMsg {
    typeUrl: "/atomone.gov.v1.QuorumCheckQueueEntry";
    value: Uint8Array;
}
/** QuorumCheckQueueEntry defines a quorum check queue entry. */
export interface QuorumCheckQueueEntryAmino {
    /**
     * quorum_timeout_time is the time after which quorum checks start happening
     * and voting period is extended if proposal reaches quorum.
     */
    quorum_timeout_time?: string | undefined;
    /**
     * quorum_check_count is the number of times quorum will be checked.
     * This is a snapshot of the parameter value with the same name when the
     * proposal is initially added to the queue.
     */
    quorum_check_count?: string;
    /** quorum_checks_done is the number of quorum checks that have been done. */
    quorum_checks_done?: string;
}
export interface QuorumCheckQueueEntryAminoMsg {
    type: "/atomone.gov.v1.QuorumCheckQueueEntry";
    value: QuorumCheckQueueEntryAmino;
}
/** DepositParams defines the params for deposits on governance proposals. */
export interface DepositParams {
    /** Minimum deposit for a proposal to enter voting period. */
    minDeposit: Coin[];
    /**
     * Maximum period for Atom holders to deposit on a proposal. Initial value: 2
     * months.
     */
    maxDepositPeriod?: Duration | undefined;
}
export interface DepositParamsProtoMsg {
    typeUrl: "/atomone.gov.v1.DepositParams";
    value: Uint8Array;
}
/** DepositParams defines the params for deposits on governance proposals. */
export interface DepositParamsAmino {
    /** Minimum deposit for a proposal to enter voting period. */
    min_deposit?: CoinAmino[];
    /**
     * Maximum period for Atom holders to deposit on a proposal. Initial value: 2
     * months.
     */
    max_deposit_period?: DurationAmino | undefined;
}
export interface DepositParamsAminoMsg {
    type: "/atomone.gov.v1.DepositParams";
    value: DepositParamsAmino;
}
/** VotingParams defines the params for voting on governance proposals. */
export interface VotingParams {
    /** Duration of the voting period. */
    votingPeriod?: Duration | undefined;
}
export interface VotingParamsProtoMsg {
    typeUrl: "/atomone.gov.v1.VotingParams";
    value: Uint8Array;
}
/** VotingParams defines the params for voting on governance proposals. */
export interface VotingParamsAmino {
    /** Duration of the voting period. */
    voting_period?: DurationAmino | undefined;
}
export interface VotingParamsAminoMsg {
    type: "/atomone.gov.v1.VotingParams";
    value: VotingParamsAmino;
}
/** TallyParams defines the params for tallying votes on governance proposals. */
export interface TallyParams {
    /**
     * Minimum percentage of total stake needed to vote for a result to be
     * considered valid.
     */
    /** @deprecated */
    quorum: string;
    /** Minimum proportion of Yes votes for proposal to pass. Default value: 2/3. */
    threshold: string;
    /** quorum for constitution amendment proposals */
    /** @deprecated */
    constitutionAmendmentQuorum: string;
    /** Minimum proportion of Yes votes for a Constitution Amendment proposal to pass. Default value: 0.9. */
    constitutionAmendmentThreshold: string;
    /** quorum for law proposals */
    /** @deprecated */
    lawQuorum: string;
    /** Minimum proportion of Yes votes for a Law proposal to pass. Default value: 0.9. */
    lawThreshold: string;
}
export interface TallyParamsProtoMsg {
    typeUrl: "/atomone.gov.v1.TallyParams";
    value: Uint8Array;
}
/** TallyParams defines the params for tallying votes on governance proposals. */
export interface TallyParamsAmino {
    /**
     * Minimum percentage of total stake needed to vote for a result to be
     * considered valid.
     */
    /** @deprecated */
    quorum?: string;
    /** Minimum proportion of Yes votes for proposal to pass. Default value: 2/3. */
    threshold?: string;
    /** quorum for constitution amendment proposals */
    /** @deprecated */
    constitution_amendment_quorum?: string;
    /** Minimum proportion of Yes votes for a Constitution Amendment proposal to pass. Default value: 0.9. */
    constitution_amendment_threshold?: string;
    /** quorum for law proposals */
    /** @deprecated */
    law_quorum?: string;
    /** Minimum proportion of Yes votes for a Law proposal to pass. Default value: 0.9. */
    law_threshold?: string;
}
export interface TallyParamsAminoMsg {
    type: "/atomone.gov.v1.TallyParams";
    value: TallyParamsAmino;
}
export interface MinDepositThrottler {
    /** Floor value for the minimum deposit required for a proposal to enter the voting period. */
    floorValue: Coin[];
    /**
     * Duration that dictates after how long the dynamic minimum deposit should be recalculated
     * for time-based decreases.
     */
    updatePeriod?: Duration | undefined;
    /** The number of active proposals the dynamic minimum deposit should target. */
    targetActiveProposals: bigint;
    /**
     * The ratio of increase for the minimum deposit when the number of active proposals
     * is at or above the target.
     */
    increaseRatio: string;
    /**
     * The ratio of decrease for the minimum deposit when the number of active proposals
     * is 1 less than the target.
     */
    decreaseRatio: string;
    /**
     * A positive integer representing the sensitivity of dynamic minimum deposit
     * decreases to the distance from the target number of active proposals.
     * The higher the number, the lower the sensitivity. A value of 1 represents the
     * highest sensitivity.
     */
    decreaseSensitivityTargetDistance: bigint;
}
export interface MinDepositThrottlerProtoMsg {
    typeUrl: "/atomone.gov.v1.MinDepositThrottler";
    value: Uint8Array;
}
export interface MinDepositThrottlerAmino {
    /** Floor value for the minimum deposit required for a proposal to enter the voting period. */
    floor_value: CoinAmino[];
    /**
     * Duration that dictates after how long the dynamic minimum deposit should be recalculated
     * for time-based decreases.
     */
    update_period?: DurationAmino | undefined;
    /** The number of active proposals the dynamic minimum deposit should target. */
    target_active_proposals?: string;
    /**
     * The ratio of increase for the minimum deposit when the number of active proposals
     * is at or above the target.
     */
    increase_ratio?: string;
    /**
     * The ratio of decrease for the minimum deposit when the number of active proposals
     * is 1 less than the target.
     */
    decrease_ratio?: string;
    /**
     * A positive integer representing the sensitivity of dynamic minimum deposit
     * decreases to the distance from the target number of active proposals.
     * The higher the number, the lower the sensitivity. A value of 1 represents the
     * highest sensitivity.
     */
    decrease_sensitivity_target_distance?: string;
}
export interface MinDepositThrottlerAminoMsg {
    type: "/atomone.gov.v1.MinDepositThrottler";
    value: MinDepositThrottlerAmino;
}
export interface MinInitialDepositThrottler {
    /** Floor value for the minimum initial deposit required for a proposal to enter the deposit period. */
    floorValue: Coin[];
    /**
     * Duration that dictates after how long the dynamic minimum deposit should be recalculated
     * for time-based decreases.
     */
    updatePeriod?: Duration | undefined;
    /** The number of proposals in deposit period the dynamic minimum initial deposit should target. */
    targetProposals: bigint;
    /**
     * The ratio of increase for the minimum initial deposit when the number of proposals
     * in deposit period is at or above the target.
     */
    increaseRatio: string;
    /**
     * The ratio of decrease for the minimum initial deposit when the number of proposals
     * in deposit period is 1 less than the target.
     */
    decreaseRatio: string;
    /**
     * A positive integer representing the sensitivity of dynamic minimum initial
     * deposit decreases to the distance from the target number of proposals
     * in deposit period. The higher the number, the lower the sensitivity. A value
     * of 1 represents the highest sensitivity.
     */
    decreaseSensitivityTargetDistance: bigint;
}
export interface MinInitialDepositThrottlerProtoMsg {
    typeUrl: "/atomone.gov.v1.MinInitialDepositThrottler";
    value: Uint8Array;
}
export interface MinInitialDepositThrottlerAmino {
    /** Floor value for the minimum initial deposit required for a proposal to enter the deposit period. */
    floor_value: CoinAmino[];
    /**
     * Duration that dictates after how long the dynamic minimum deposit should be recalculated
     * for time-based decreases.
     */
    update_period?: DurationAmino | undefined;
    /** The number of proposals in deposit period the dynamic minimum initial deposit should target. */
    target_proposals?: string;
    /**
     * The ratio of increase for the minimum initial deposit when the number of proposals
     * in deposit period is at or above the target.
     */
    increase_ratio?: string;
    /**
     * The ratio of decrease for the minimum initial deposit when the number of proposals
     * in deposit period is 1 less than the target.
     */
    decrease_ratio?: string;
    /**
     * A positive integer representing the sensitivity of dynamic minimum initial
     * deposit decreases to the distance from the target number of proposals
     * in deposit period. The higher the number, the lower the sensitivity. A value
     * of 1 represents the highest sensitivity.
     */
    decrease_sensitivity_target_distance?: string;
}
export interface MinInitialDepositThrottlerAminoMsg {
    type: "/atomone.gov.v1.MinInitialDepositThrottler";
    value: MinInitialDepositThrottlerAmino;
}
/**
 * Params defines the parameters for the x/gov module.
 *
 * Since: cosmos-sdk 0.47
 */
export interface Params {
    /**
     * Minimum deposit for a proposal to enter voting period.
     * Deprecated: a dynamic system now determines the minimum deposit,
     * see the other params inside the min_deposit_throttler field.
     * While setting this value returns an error, when queried it is set to the
     * value of the current minimum deposit value as determined by the dynamic
     * system for backward compatibility.
     */
    /** @deprecated */
    minDeposit: Coin[];
    /**
     * Maximum period for Atom holders to deposit on a proposal. Initial value: 2
     * months.
     */
    maxDepositPeriod?: Duration | undefined;
    /** Duration of the voting period. */
    votingPeriod?: Duration | undefined;
    /**
     * Minimum percentage of total stake needed to vote for a result to be
     *  considered valid. Default value: 0.25.
     */
    /** @deprecated */
    quorum: string;
    /** Minimum proportion of Yes votes for proposal to pass. Default value: 2/3. */
    threshold: string;
    /** The ratio representing the proportion of the deposit value that must be paid at proposal submission. */
    /** @deprecated */
    minInitialDepositRatio: string;
    /** burn deposits if a proposal does not meet quorum */
    burnVoteQuorum: boolean;
    /** burn deposits if the proposal does not enter voting period */
    burnProposalDepositPrevote: boolean;
    /**
     * The ratio representing the proportion of the deposit value minimum that
     * must be met when making a deposit. Default value: 0.01. Meaning that for a
     * chain with a min_deposit of 100stake, a deposit of 1stake would be
     * required.
     *
     * Since: cosmos-sdk 0.50
     * NOTE: backported from v50 (https://github.com/cosmos/cosmos-sdk/pull/18146)
     */
    minDepositRatio: string;
    /** quorum for constitution amendment proposals */
    /** @deprecated */
    constitutionAmendmentQuorum: string;
    /** Minimum proportion of Yes votes for a Constitution Amendment proposal to pass. Default value: 0.9. */
    constitutionAmendmentThreshold: string;
    /** quorum for law proposals */
    /** @deprecated */
    lawQuorum: string;
    /** Minimum proportion of Yes votes for a Law proposal to pass. Default value: 0.9. */
    lawThreshold: string;
    /**
     * Duration of time after a proposal enters the voting period, during which quorum
     * must be achieved to not incur in a voting period extension.
     */
    quorumTimeout?: Duration | undefined;
    /**
     * Duration that expresses the maximum amount of time by which a proposal voting period
     * can be extended.
     */
    maxVotingPeriodExtension?: Duration | undefined;
    /**
     * Number of times a proposal should be checked for quorum after the quorum timeout
     * has elapsed. Used to compute the amount of time in between quorum checks.
     */
    quorumCheckCount: bigint;
    minDepositThrottler?: MinDepositThrottler | undefined;
    minInitialDepositThrottler?: MinInitialDepositThrottler | undefined;
    /** Minimum proportion of No Votes for a proposal deposit to be burnt. */
    burnDepositNoThreshold: string;
    /** Achievable quorum */
    quorumRange?: QuorumRange | undefined;
    /** Achievable quorum for constitution amendment proposals */
    constitutionAmendmentQuorumRange?: QuorumRange | undefined;
    /** Achievable quorum for law proposals */
    lawQuorumRange?: QuorumRange | undefined;
    /** Defines the duration of time that need to elapse between governor status changes. */
    governorStatusChangePeriod?: Duration | undefined;
    /**
     * Defines the minimum amound of bonded tokens, aka the "self-delegation" (because active governors
     * must have the governance VP from the base account automatically delegated to them), that a governor
     * must have to be considered active.
     */
    minGovernorSelfDelegation: string;
}
export interface ParamsProtoMsg {
    typeUrl: "/atomone.gov.v1.Params";
    value: Uint8Array;
}
/**
 * Params defines the parameters for the x/gov module.
 *
 * Since: cosmos-sdk 0.47
 */
export interface ParamsAmino {
    /**
     * Minimum deposit for a proposal to enter voting period.
     * Deprecated: a dynamic system now determines the minimum deposit,
     * see the other params inside the min_deposit_throttler field.
     * While setting this value returns an error, when queried it is set to the
     * value of the current minimum deposit value as determined by the dynamic
     * system for backward compatibility.
     */
    /** @deprecated */
    min_deposit: CoinAmino[];
    /**
     * Maximum period for Atom holders to deposit on a proposal. Initial value: 2
     * months.
     */
    max_deposit_period?: DurationAmino | undefined;
    /** Duration of the voting period. */
    voting_period?: DurationAmino | undefined;
    /**
     * Minimum percentage of total stake needed to vote for a result to be
     *  considered valid. Default value: 0.25.
     */
    /** @deprecated */
    quorum?: string;
    /** Minimum proportion of Yes votes for proposal to pass. Default value: 2/3. */
    threshold?: string;
    /** The ratio representing the proportion of the deposit value that must be paid at proposal submission. */
    /** @deprecated */
    min_initial_deposit_ratio?: string;
    /** burn deposits if a proposal does not meet quorum */
    burn_vote_quorum?: boolean;
    /** burn deposits if the proposal does not enter voting period */
    burn_proposal_deposit_prevote?: boolean;
    /**
     * The ratio representing the proportion of the deposit value minimum that
     * must be met when making a deposit. Default value: 0.01. Meaning that for a
     * chain with a min_deposit of 100stake, a deposit of 1stake would be
     * required.
     *
     * Since: cosmos-sdk 0.50
     * NOTE: backported from v50 (https://github.com/cosmos/cosmos-sdk/pull/18146)
     */
    min_deposit_ratio?: string;
    /** quorum for constitution amendment proposals */
    /** @deprecated */
    constitution_amendment_quorum?: string;
    /** Minimum proportion of Yes votes for a Constitution Amendment proposal to pass. Default value: 0.9. */
    constitution_amendment_threshold?: string;
    /** quorum for law proposals */
    /** @deprecated */
    law_quorum?: string;
    /** Minimum proportion of Yes votes for a Law proposal to pass. Default value: 0.9. */
    law_threshold?: string;
    /**
     * Duration of time after a proposal enters the voting period, during which quorum
     * must be achieved to not incur in a voting period extension.
     */
    quorum_timeout?: DurationAmino | undefined;
    /**
     * Duration that expresses the maximum amount of time by which a proposal voting period
     * can be extended.
     */
    max_voting_period_extension?: DurationAmino | undefined;
    /**
     * Number of times a proposal should be checked for quorum after the quorum timeout
     * has elapsed. Used to compute the amount of time in between quorum checks.
     */
    quorum_check_count?: string;
    min_deposit_throttler?: MinDepositThrottlerAmino | undefined;
    min_initial_deposit_throttler?: MinInitialDepositThrottlerAmino | undefined;
    /** Minimum proportion of No Votes for a proposal deposit to be burnt. */
    burn_deposit_no_threshold?: string;
    /** Achievable quorum */
    quorum_range?: QuorumRangeAmino | undefined;
    /** Achievable quorum for constitution amendment proposals */
    constitution_amendment_quorum_range?: QuorumRangeAmino | undefined;
    /** Achievable quorum for law proposals */
    law_quorum_range?: QuorumRangeAmino | undefined;
    /** Defines the duration of time that need to elapse between governor status changes. */
    governor_status_change_period?: DurationAmino | undefined;
    /**
     * Defines the minimum amound of bonded tokens, aka the "self-delegation" (because active governors
     * must have the governance VP from the base account automatically delegated to them), that a governor
     * must have to be considered active.
     */
    min_governor_self_delegation?: string;
}
export interface ParamsAminoMsg {
    type: "/atomone.gov.v1.Params";
    value: ParamsAmino;
}
export interface QuorumRange {
    /** Maximum achievable quorum */
    max: string;
    /** Minimum achievable quorum */
    min: string;
}
export interface QuorumRangeProtoMsg {
    typeUrl: "/atomone.gov.v1.QuorumRange";
    value: Uint8Array;
}
export interface QuorumRangeAmino {
    /** Maximum achievable quorum */
    max?: string;
    /** Minimum achievable quorum */
    min?: string;
}
export interface QuorumRangeAminoMsg {
    type: "/atomone.gov.v1.QuorumRange";
    value: QuorumRangeAmino;
}
/**
 * Governor defines a governor, together with the total amount of delegated
 * validator's bond shares for a set amount of validators. When a delegator
 * delegates a percentage of its x/gov power to a governor, the resulting
 * shares from each delegators delegations in x/staking are added to the
 * governor's total shares.
 */
export interface Governor {
    /** governor_address defines the address of the governor; bech32-encoded. */
    governorAddress: string;
    /** status is the status of the governor (active/inactive). */
    status: GovernorStatus;
    /** description defines the description terms for the governor. */
    description: GovernorDescription | undefined;
    /** last_status_change_time is the time when the governor's status was last changed. */
    lastStatusChangeTime?: Timestamp | undefined;
}
export interface GovernorProtoMsg {
    typeUrl: "/atomone.gov.v1.Governor";
    value: Uint8Array;
}
/**
 * Governor defines a governor, together with the total amount of delegated
 * validator's bond shares for a set amount of validators. When a delegator
 * delegates a percentage of its x/gov power to a governor, the resulting
 * shares from each delegators delegations in x/staking are added to the
 * governor's total shares.
 */
export interface GovernorAmino {
    /** governor_address defines the address of the governor; bech32-encoded. */
    governor_address?: string;
    /** status is the status of the governor (active/inactive). */
    status?: GovernorStatus;
    /** description defines the description terms for the governor. */
    description: GovernorDescriptionAmino | undefined;
    /** last_status_change_time is the time when the governor's status was last changed. */
    last_status_change_time?: string | undefined;
}
export interface GovernorAminoMsg {
    type: "/atomone.gov.v1.Governor";
    value: GovernorAmino;
}
/** Description defines a governor description. */
export interface GovernorDescription {
    /** moniker defines a human-readable name for the governor. */
    moniker: string;
    /** identity defines an optional identity signature (ex. UPort or Keybase). */
    identity: string;
    /** website defines an optional website link. */
    website: string;
    /** security_contact defines an optional email for security contact. */
    securityContact: string;
    /** details define other optional details. */
    details: string;
}
export interface GovernorDescriptionProtoMsg {
    typeUrl: "/atomone.gov.v1.GovernorDescription";
    value: Uint8Array;
}
/** Description defines a governor description. */
export interface GovernorDescriptionAmino {
    /** moniker defines a human-readable name for the governor. */
    moniker?: string;
    /** identity defines an optional identity signature (ex. UPort or Keybase). */
    identity?: string;
    /** website defines an optional website link. */
    website?: string;
    /** security_contact defines an optional email for security contact. */
    security_contact?: string;
    /** details define other optional details. */
    details?: string;
}
export interface GovernorDescriptionAminoMsg {
    type: "/atomone.gov.v1.GovernorDescription";
    value: GovernorDescriptionAmino;
}
/**
 * GovernorValShares holds the number of virtual shares from the
 * specific validator that a governor can use to vote on proposals.
 */
export interface GovernorValShares {
    governorAddress: string;
    validatorAddress: string;
    /** shares define the delegation shares available from this validator. */
    shares: string;
}
export interface GovernorValSharesProtoMsg {
    typeUrl: "/atomone.gov.v1.GovernorValShares";
    value: Uint8Array;
}
/**
 * GovernorValShares holds the number of virtual shares from the
 * specific validator that a governor can use to vote on proposals.
 */
export interface GovernorValSharesAmino {
    governor_address?: string;
    validator_address?: string;
    /** shares define the delegation shares available from this validator. */
    shares?: string;
}
export interface GovernorValSharesAminoMsg {
    type: "/atomone.gov.v1.GovernorValShares";
    value: GovernorValSharesAmino;
}
/**
 * GovernanceDelegation defines a delegation of governance voting power from a
 * delegator to a governor.
 */
export interface GovernanceDelegation {
    delegatorAddress: string;
    governorAddress: string;
}
export interface GovernanceDelegationProtoMsg {
    typeUrl: "/atomone.gov.v1.GovernanceDelegation";
    value: Uint8Array;
}
/**
 * GovernanceDelegation defines a delegation of governance voting power from a
 * delegator to a governor.
 */
export interface GovernanceDelegationAmino {
    delegator_address?: string;
    governor_address?: string;
}
export interface GovernanceDelegationAminoMsg {
    type: "/atomone.gov.v1.GovernanceDelegation";
    value: GovernanceDelegationAmino;
}
export declare const WeightedVoteOption: {
    typeUrl: string;
    encode(message: WeightedVoteOption, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): WeightedVoteOption;
    fromJSON(object: any): WeightedVoteOption;
    toJSON(message: WeightedVoteOption): unknown;
    fromPartial(object: Partial<WeightedVoteOption>): WeightedVoteOption;
    fromAmino(object: WeightedVoteOptionAmino): WeightedVoteOption;
    toAmino(message: WeightedVoteOption): WeightedVoteOptionAmino;
    fromAminoMsg(object: WeightedVoteOptionAminoMsg): WeightedVoteOption;
    fromProtoMsg(message: WeightedVoteOptionProtoMsg): WeightedVoteOption;
    toProto(message: WeightedVoteOption): Uint8Array;
    toProtoMsg(message: WeightedVoteOption): WeightedVoteOptionProtoMsg;
};
export declare const Deposit: {
    typeUrl: string;
    encode(message: Deposit, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Deposit;
    fromJSON(object: any): Deposit;
    toJSON(message: Deposit): unknown;
    fromPartial(object: Partial<Deposit>): Deposit;
    fromAmino(object: DepositAmino): Deposit;
    toAmino(message: Deposit): DepositAmino;
    fromAminoMsg(object: DepositAminoMsg): Deposit;
    fromProtoMsg(message: DepositProtoMsg): Deposit;
    toProto(message: Deposit): Uint8Array;
    toProtoMsg(message: Deposit): DepositProtoMsg;
};
export declare const LastMinDeposit: {
    typeUrl: string;
    encode(message: LastMinDeposit, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): LastMinDeposit;
    fromJSON(object: any): LastMinDeposit;
    toJSON(message: LastMinDeposit): unknown;
    fromPartial(object: Partial<LastMinDeposit>): LastMinDeposit;
    fromAmino(object: LastMinDepositAmino): LastMinDeposit;
    toAmino(message: LastMinDeposit): LastMinDepositAmino;
    fromAminoMsg(object: LastMinDepositAminoMsg): LastMinDeposit;
    fromProtoMsg(message: LastMinDepositProtoMsg): LastMinDeposit;
    toProto(message: LastMinDeposit): Uint8Array;
    toProtoMsg(message: LastMinDeposit): LastMinDepositProtoMsg;
};
export declare const Proposal: {
    typeUrl: string;
    encode(message: Proposal, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Proposal;
    fromJSON(object: any): Proposal;
    toJSON(message: Proposal): unknown;
    fromPartial(object: Partial<Proposal>): Proposal;
    fromAmino(object: ProposalAmino): Proposal;
    toAmino(message: Proposal): ProposalAmino;
    fromAminoMsg(object: ProposalAminoMsg): Proposal;
    fromProtoMsg(message: ProposalProtoMsg): Proposal;
    toProto(message: Proposal): Uint8Array;
    toProtoMsg(message: Proposal): ProposalProtoMsg;
};
export declare const TallyResult: {
    typeUrl: string;
    encode(message: TallyResult, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): TallyResult;
    fromJSON(object: any): TallyResult;
    toJSON(message: TallyResult): unknown;
    fromPartial(object: Partial<TallyResult>): TallyResult;
    fromAmino(object: TallyResultAmino): TallyResult;
    toAmino(message: TallyResult): TallyResultAmino;
    fromAminoMsg(object: TallyResultAminoMsg): TallyResult;
    fromProtoMsg(message: TallyResultProtoMsg): TallyResult;
    toProto(message: TallyResult): Uint8Array;
    toProtoMsg(message: TallyResult): TallyResultProtoMsg;
};
export declare const Vote: {
    typeUrl: string;
    encode(message: Vote, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Vote;
    fromJSON(object: any): Vote;
    toJSON(message: Vote): unknown;
    fromPartial(object: Partial<Vote>): Vote;
    fromAmino(object: VoteAmino): Vote;
    toAmino(message: Vote): VoteAmino;
    fromAminoMsg(object: VoteAminoMsg): Vote;
    fromProtoMsg(message: VoteProtoMsg): Vote;
    toProto(message: Vote): Uint8Array;
    toProtoMsg(message: Vote): VoteProtoMsg;
};
export declare const QuorumCheckQueueEntry: {
    typeUrl: string;
    encode(message: QuorumCheckQueueEntry, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QuorumCheckQueueEntry;
    fromJSON(object: any): QuorumCheckQueueEntry;
    toJSON(message: QuorumCheckQueueEntry): unknown;
    fromPartial(object: Partial<QuorumCheckQueueEntry>): QuorumCheckQueueEntry;
    fromAmino(object: QuorumCheckQueueEntryAmino): QuorumCheckQueueEntry;
    toAmino(message: QuorumCheckQueueEntry): QuorumCheckQueueEntryAmino;
    fromAminoMsg(object: QuorumCheckQueueEntryAminoMsg): QuorumCheckQueueEntry;
    fromProtoMsg(message: QuorumCheckQueueEntryProtoMsg): QuorumCheckQueueEntry;
    toProto(message: QuorumCheckQueueEntry): Uint8Array;
    toProtoMsg(message: QuorumCheckQueueEntry): QuorumCheckQueueEntryProtoMsg;
};
export declare const DepositParams: {
    typeUrl: string;
    encode(message: DepositParams, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): DepositParams;
    fromJSON(object: any): DepositParams;
    toJSON(message: DepositParams): unknown;
    fromPartial(object: Partial<DepositParams>): DepositParams;
    fromAmino(object: DepositParamsAmino): DepositParams;
    toAmino(message: DepositParams): DepositParamsAmino;
    fromAminoMsg(object: DepositParamsAminoMsg): DepositParams;
    fromProtoMsg(message: DepositParamsProtoMsg): DepositParams;
    toProto(message: DepositParams): Uint8Array;
    toProtoMsg(message: DepositParams): DepositParamsProtoMsg;
};
export declare const VotingParams: {
    typeUrl: string;
    encode(message: VotingParams, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): VotingParams;
    fromJSON(object: any): VotingParams;
    toJSON(message: VotingParams): unknown;
    fromPartial(object: Partial<VotingParams>): VotingParams;
    fromAmino(object: VotingParamsAmino): VotingParams;
    toAmino(message: VotingParams): VotingParamsAmino;
    fromAminoMsg(object: VotingParamsAminoMsg): VotingParams;
    fromProtoMsg(message: VotingParamsProtoMsg): VotingParams;
    toProto(message: VotingParams): Uint8Array;
    toProtoMsg(message: VotingParams): VotingParamsProtoMsg;
};
export declare const TallyParams: {
    typeUrl: string;
    encode(message: TallyParams, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): TallyParams;
    fromJSON(object: any): TallyParams;
    toJSON(message: TallyParams): unknown;
    fromPartial(object: Partial<TallyParams>): TallyParams;
    fromAmino(object: TallyParamsAmino): TallyParams;
    toAmino(message: TallyParams): TallyParamsAmino;
    fromAminoMsg(object: TallyParamsAminoMsg): TallyParams;
    fromProtoMsg(message: TallyParamsProtoMsg): TallyParams;
    toProto(message: TallyParams): Uint8Array;
    toProtoMsg(message: TallyParams): TallyParamsProtoMsg;
};
export declare const MinDepositThrottler: {
    typeUrl: string;
    encode(message: MinDepositThrottler, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MinDepositThrottler;
    fromJSON(object: any): MinDepositThrottler;
    toJSON(message: MinDepositThrottler): unknown;
    fromPartial(object: Partial<MinDepositThrottler>): MinDepositThrottler;
    fromAmino(object: MinDepositThrottlerAmino): MinDepositThrottler;
    toAmino(message: MinDepositThrottler): MinDepositThrottlerAmino;
    fromAminoMsg(object: MinDepositThrottlerAminoMsg): MinDepositThrottler;
    fromProtoMsg(message: MinDepositThrottlerProtoMsg): MinDepositThrottler;
    toProto(message: MinDepositThrottler): Uint8Array;
    toProtoMsg(message: MinDepositThrottler): MinDepositThrottlerProtoMsg;
};
export declare const MinInitialDepositThrottler: {
    typeUrl: string;
    encode(message: MinInitialDepositThrottler, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): MinInitialDepositThrottler;
    fromJSON(object: any): MinInitialDepositThrottler;
    toJSON(message: MinInitialDepositThrottler): unknown;
    fromPartial(object: Partial<MinInitialDepositThrottler>): MinInitialDepositThrottler;
    fromAmino(object: MinInitialDepositThrottlerAmino): MinInitialDepositThrottler;
    toAmino(message: MinInitialDepositThrottler): MinInitialDepositThrottlerAmino;
    fromAminoMsg(object: MinInitialDepositThrottlerAminoMsg): MinInitialDepositThrottler;
    fromProtoMsg(message: MinInitialDepositThrottlerProtoMsg): MinInitialDepositThrottler;
    toProto(message: MinInitialDepositThrottler): Uint8Array;
    toProtoMsg(message: MinInitialDepositThrottler): MinInitialDepositThrottlerProtoMsg;
};
export declare const Params: {
    typeUrl: string;
    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Params;
    fromJSON(object: any): Params;
    toJSON(message: Params): unknown;
    fromPartial(object: Partial<Params>): Params;
    fromAmino(object: ParamsAmino): Params;
    toAmino(message: Params): ParamsAmino;
    fromAminoMsg(object: ParamsAminoMsg): Params;
    fromProtoMsg(message: ParamsProtoMsg): Params;
    toProto(message: Params): Uint8Array;
    toProtoMsg(message: Params): ParamsProtoMsg;
};
export declare const QuorumRange: {
    typeUrl: string;
    encode(message: QuorumRange, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QuorumRange;
    fromJSON(object: any): QuorumRange;
    toJSON(message: QuorumRange): unknown;
    fromPartial(object: Partial<QuorumRange>): QuorumRange;
    fromAmino(object: QuorumRangeAmino): QuorumRange;
    toAmino(message: QuorumRange): QuorumRangeAmino;
    fromAminoMsg(object: QuorumRangeAminoMsg): QuorumRange;
    fromProtoMsg(message: QuorumRangeProtoMsg): QuorumRange;
    toProto(message: QuorumRange): Uint8Array;
    toProtoMsg(message: QuorumRange): QuorumRangeProtoMsg;
};
export declare const Governor: {
    typeUrl: string;
    encode(message: Governor, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Governor;
    fromJSON(object: any): Governor;
    toJSON(message: Governor): unknown;
    fromPartial(object: Partial<Governor>): Governor;
    fromAmino(object: GovernorAmino): Governor;
    toAmino(message: Governor): GovernorAmino;
    fromAminoMsg(object: GovernorAminoMsg): Governor;
    fromProtoMsg(message: GovernorProtoMsg): Governor;
    toProto(message: Governor): Uint8Array;
    toProtoMsg(message: Governor): GovernorProtoMsg;
};
export declare const GovernorDescription: {
    typeUrl: string;
    encode(message: GovernorDescription, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): GovernorDescription;
    fromJSON(object: any): GovernorDescription;
    toJSON(message: GovernorDescription): unknown;
    fromPartial(object: Partial<GovernorDescription>): GovernorDescription;
    fromAmino(object: GovernorDescriptionAmino): GovernorDescription;
    toAmino(message: GovernorDescription): GovernorDescriptionAmino;
    fromAminoMsg(object: GovernorDescriptionAminoMsg): GovernorDescription;
    fromProtoMsg(message: GovernorDescriptionProtoMsg): GovernorDescription;
    toProto(message: GovernorDescription): Uint8Array;
    toProtoMsg(message: GovernorDescription): GovernorDescriptionProtoMsg;
};
export declare const GovernorValShares: {
    typeUrl: string;
    encode(message: GovernorValShares, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): GovernorValShares;
    fromJSON(object: any): GovernorValShares;
    toJSON(message: GovernorValShares): unknown;
    fromPartial(object: Partial<GovernorValShares>): GovernorValShares;
    fromAmino(object: GovernorValSharesAmino): GovernorValShares;
    toAmino(message: GovernorValShares): GovernorValSharesAmino;
    fromAminoMsg(object: GovernorValSharesAminoMsg): GovernorValShares;
    fromProtoMsg(message: GovernorValSharesProtoMsg): GovernorValShares;
    toProto(message: GovernorValShares): Uint8Array;
    toProtoMsg(message: GovernorValShares): GovernorValSharesProtoMsg;
};
export declare const GovernanceDelegation: {
    typeUrl: string;
    encode(message: GovernanceDelegation, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): GovernanceDelegation;
    fromJSON(object: any): GovernanceDelegation;
    toJSON(message: GovernanceDelegation): unknown;
    fromPartial(object: Partial<GovernanceDelegation>): GovernanceDelegation;
    fromAmino(object: GovernanceDelegationAmino): GovernanceDelegation;
    toAmino(message: GovernanceDelegation): GovernanceDelegationAmino;
    fromAminoMsg(object: GovernanceDelegationAminoMsg): GovernanceDelegation;
    fromProtoMsg(message: GovernanceDelegationProtoMsg): GovernanceDelegation;
    toProto(message: GovernanceDelegation): Uint8Array;
    toProtoMsg(message: GovernanceDelegation): GovernanceDelegationProtoMsg;
};