/* eslint-disable */

// @ts-nocheck

// This file was automatically generated by @icp-sdk/bindgen@0.3.0.
// You should NOT make any changes in this file as it will be overwritten.
// Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.

import type { ActorMethod } from '@icp-sdk/core/agent';
import type { IDL } from '@icp-sdk/core/candid';
import type { Principal } from '@icp-sdk/core/principal';

export interface Account {
  'owner' : [] | [Principal],
  'subaccount' : [] | [Uint8Array],
}
export interface AccountIdentifier { 'hash' : Uint8Array }
export type Action = { 'RegisterKnownNeuron' : KnownNeuron } |
  { 'FulfillSubnetRentalRequest' : FulfillSubnetRentalRequest } |
  { 'ManageNeuron' : ManageNeuronProposal } |
  { 'LoadCanisterSnapshot' : LoadCanisterSnapshot } |
  { 'BlessAlternativeGuestOsVersion' : BlessAlternativeGuestOsVersion } |
  { 'UpdateCanisterSettings' : UpdateCanisterSettings } |
  { 'InstallCode' : InstallCode } |
  { 'DeregisterKnownNeuron' : DeregisterKnownNeuron } |
  { 'TakeCanisterSnapshot' : TakeCanisterSnapshot } |
  { 'StopOrStartCanister' : StopOrStartCanister } |
  { 'CreateServiceNervousSystem' : CreateServiceNervousSystem } |
  { 'ExecuteNnsFunction' : ExecuteNnsFunction } |
  { 'RewardNodeProvider' : RewardNodeProvider } |
  { 'OpenSnsTokenSwap' : OpenSnsTokenSwap } |
  { 'SetSnsTokenSwapOpenTimeWindow' : SetSnsTokenSwapOpenTimeWindow } |
  { 'SetDefaultFollowees' : SetDefaultFollowees } |
  { 'RewardNodeProviders' : RewardNodeProviders } |
  { 'ManageNetworkEconomics' : NetworkEconomics } |
  { 'ApproveGenesisKyc' : Principals } |
  { 'AddOrRemoveNodeProvider' : AddOrRemoveNodeProvider } |
  { 'Motion' : Motion };
export interface AddHotKey { 'new_hot_key' : [] | [Principal] }
export interface AddOrRemoveNodeProvider { 'change' : [] | [Change] }
export interface Amount { 'e8s' : bigint }
export interface ApproveGenesisKyc { 'principals' : Array<Principal> }
export interface Ballot { 'vote' : number, 'voting_power' : bigint }
export interface BallotInfo {
  'vote' : number,
  'proposal_id' : [] | [ProposalId],
}
/**
 * Declares an approved set of alternative replica virtual machine software for
 * disaster recovery purposes.
 */
export interface BlessAlternativeGuestOsVersion {
  /**
   * Hexadecimal fingerprint of the recovery rootfs.
   * Must contain only hexadecimal characters (0-9, A-F, a-f).
   */
  'rootfs_hash' : [] | [string],
  /**
   * AMD Secure Processor chip IDs that are allowed to run this software.
   * Each chip ID must be exactly 64 bytes.
   */
  'chip_ids' : [] | [Array<Uint8Array>],
  /**
   * The version being replaced by this (alternative version) must match this
   * field (or one of the possibilities therein).
   * 
   * (Here, we refer to the version being replaced as the "base" version.)
   */
  'base_guest_launch_measurements' : [] | [GuestLaunchMeasurements],
}
export type By = { 'NeuronIdOrSubaccount' : {} } |
  { 'MemoAndController' : ClaimOrRefreshNeuronFromAccount } |
  { 'Memo' : bigint };
export interface Canister { 'id' : [] | [Principal] }
export interface CanisterSettings {
  'freezing_threshold' : [] | [bigint],
  'wasm_memory_threshold' : [] | [bigint],
  'controllers' : [] | [Controllers],
  'log_visibility' : [] | [number],
  'wasm_memory_limit' : [] | [bigint],
  'memory_allocation' : [] | [bigint],
  'compute_allocation' : [] | [bigint],
}
export interface CanisterStatusResultV2 {
  'status' : [] | [number],
  'freezing_threshold' : [] | [bigint],
  'controllers' : Array<Principal>,
  'memory_size' : [] | [bigint],
  'cycles' : [] | [bigint],
  'idle_cycles_burned_per_day' : [] | [bigint],
  'module_hash' : Uint8Array,
}
export interface CanisterSummary {
  'status' : [] | [CanisterStatusResultV2],
  'canister_id' : [] | [Principal],
}
export type Change = { 'ToRemove' : NodeProvider } |
  { 'ToAdd' : NodeProvider };
export interface ChangeAutoStakeMaturity {
  'requested_setting_for_auto_stake_maturity' : boolean,
}
export interface ClaimOrRefresh { 'by' : [] | [By] }
export interface ClaimOrRefreshNeuronFromAccount {
  'controller' : [] | [Principal],
  'memo' : bigint,
}
export interface ClaimOrRefreshNeuronFromAccountResponse {
  'result' : [] | [Result_1],
}
export interface ClaimOrRefreshResponse {
  'refreshed_neuron_id' : [] | [NeuronId],
}
export type Command_1 = { 'Error' : GovernanceError } |
  { 'Spawn' : SpawnResponse } |
  { 'Split' : SpawnResponse } |
  { 'Follow' : {} } |
  { 'DisburseMaturity' : DisburseMaturityResponse } |
  { 'RefreshVotingPower' : RefreshVotingPowerResponse } |
  { 'ClaimOrRefresh' : ClaimOrRefreshResponse } |
  { 'Configure' : {} } |
  { 'RegisterVote' : {} } |
  { 'Merge' : MergeResponse } |
  { 'DisburseToNeuron' : SpawnResponse } |
  { 'SetFollowing' : SetFollowingResponse } |
  { 'MakeProposal' : MakeProposalResponse } |
  { 'StakeMaturity' : StakeMaturityResponse } |
  { 'MergeMaturity' : MergeMaturityResponse } |
  { 'Disburse' : DisburseResponse };
export type Command_2 = { 'Spawn' : NeuronId } |
  { 'Split' : Split } |
  { 'Configure' : Configure } |
  { 'Merge' : Merge } |
  { 'DisburseToNeuron' : DisburseToNeuron } |
  { 'SyncCommand' : {} } |
  { 'ClaimOrRefreshNeuron' : ClaimOrRefresh } |
  { 'MergeMaturity' : MergeMaturity } |
  { 'Disburse' : Disburse };
export interface Committed {
  'total_direct_contribution_icp_e8s' : [] | [bigint],
  'total_neurons_fund_contribution_icp_e8s' : [] | [bigint],
  'sns_governance_canister_id' : [] | [Principal],
}
export interface Committed_1 {
  'total_direct_participation_icp_e8s' : [] | [bigint],
  'total_neurons_fund_participation_icp_e8s' : [] | [bigint],
  'sns_governance_canister_id' : [] | [Principal],
}
export interface Configure { 'operation' : [] | [Operation] }
export interface Controllers { 'controllers' : Array<Principal> }
export interface Countries { 'iso_codes' : Array<string> }
/**
 * Request to create a new neuron using ICRC-2 transfer_from.
 * The caller must have previously approved the governance canister to spend the specified amount.
 */
export interface CreateNeuronRequest {
  /**
   * The controller of the new neuron. Defaults to the caller.
   */
  'controller' : [] | [Principal],
  /**
   * The subaccount of the caller to transfer ICP from. Defaults to the default subaccount.
   */
  'source_subaccount' : [] | [Uint8Array],
  /**
   * The dissolve delay in seconds. Defaults to 7 days. Clamped to [0, 8 years].
   */
  'dissolve_delay_seconds' : [] | [bigint],
  /**
   * Whether to automatically stake maturity. Defaults to false.
   */
  'auto_stake_maturity' : [] | [boolean],
  /**
   * Required. The amount of ICP to stake in e8s.
   */
  'amount_e8s' : [] | [bigint],
  /**
   * The followees to set for the new neuron. Defaults to the network's default followees.
   */
  'followees' : [] | [SetFollowing],
  /**
   * Whether the neuron should start dissolving immediately. Defaults to false.
   */
  'dissolving' : [] | [boolean],
}
export type CreateNeuronResponse = { 'Ok' : CreatedNeuron } |
  { 'Err' : GovernanceError };
export interface CreateServiceNervousSystem {
  'url' : [] | [string],
  'governance_parameters' : [] | [GovernanceParameters],
  'fallback_controller_principal_ids' : Array<Principal>,
  'logo' : [] | [Image],
  'name' : [] | [string],
  'ledger_parameters' : [] | [LedgerParameters],
  'description' : [] | [string],
  'dapp_canisters' : Array<Canister>,
  'swap_parameters' : [] | [SwapParameters],
  'initial_token_distribution' : [] | [InitialTokenDistribution],
}
export interface CreatedNeuron { 'neuron_id' : [] | [NeuronId] }
export interface CustomProposalCriticality {
  'additional_critical_native_action_ids' : [] | [BigUint64Array],
}
export interface DateRangeFilter {
  'start_timestamp_seconds' : [] | [bigint],
  'end_timestamp_seconds' : [] | [bigint],
}
export interface DateUtc { 'day' : number, 'month' : number, 'year' : number }
export interface Decimal { 'human_readable' : [] | [string] }
export interface DeregisterKnownNeuron { 'id' : [] | [NeuronId] }
export interface DerivedProposalInformation {
  'swap_background_information' : [] | [SwapBackgroundInformation],
}
export interface DeveloperDistribution {
  'developer_neurons' : Array<NeuronDistribution>,
}
export interface Disburse {
  'to_account' : [] | [AccountIdentifier],
  'amount' : [] | [Amount],
}
export interface DisburseMaturity {
  'to_account_identifier' : [] | [AccountIdentifier],
  'to_account' : [] | [Account],
  'percentage_to_disburse' : number,
}
export interface DisburseMaturityResponse {
  'amount_disbursed_e8s' : [] | [bigint],
}
export interface DisburseResponse { 'transfer_block_height' : bigint }
export interface DisburseToNeuron {
  'dissolve_delay_seconds' : bigint,
  'kyc_verified' : boolean,
  'amount_e8s' : bigint,
  'new_controller' : [] | [Principal],
  'nonce' : bigint,
}
export type DissolveState = { 'DissolveDelaySeconds' : bigint } |
  { 'WhenDissolvedTimestampSeconds' : bigint };
export interface Duration { 'seconds' : [] | [bigint] }
export interface ExecuteNnsFunction {
  'nns_function' : number,
  'payload' : Uint8Array,
}
export interface Follow { 'topic' : number, 'followees' : Array<NeuronId> }
export interface Followees { 'followees' : Array<NeuronId> }
export interface FolloweesForTopic {
  'topic' : [] | [number],
  'followees' : [] | [Array<NeuronId>],
}
/**
 * Creates a rented subnet from a rental request (in the Subnet Rental
 * canister).
 */
export interface FulfillSubnetRentalRequest {
  /**
   * Identifies which rental request to fulfill.
   * 
   * (Identifying the rental request by user works, because a user can have at
   * most one rental request in the Subnet Rental canister).
   */
  'user' : [] | [Principal],
  /**
   * What software the nodes will run.
   * 
   * This must be approved by a prior proposal to bless an IC OS version.
   * 
   * This is a FULL git commit ID in the ic repo. (Therefore, it must be a 40
   * character hexidecimal string, not an abbreviated git commit ID.)
   * 
   * One way to find a suitable value is with the following command:
   * 
   * ic-admin \
   * get-subnet 0 \
   * --nns-urls https://nns.ic0.app \
   * | grep replica_version_id
   * 
   * Where to obtain a recent version of ic-admin:
   * 
   * https://github.com/dfinity/ic/releases/latest
   */
  'replica_version_id' : [] | [string],
  /**
   * Which nodes will be members of the subnet.
   */
  'node_ids' : [] | [Array<Principal>],
}
export interface GetNeuronIndexRequest {
  'page_size' : [] | [number],
  'exclusive_start_neuron_id' : [] | [NeuronId],
}
export type GetNeuronIndexResult = { 'Ok' : NeuronIndexData } |
  { 'Err' : GovernanceError };
export interface GetNeuronsFundAuditInfoRequest {
  'nns_proposal_id' : [] | [ProposalId],
}
export interface GetNeuronsFundAuditInfoResponse { 'result' : [] | [Result_6] }
export interface GetPendingProposalsRequest {
  'return_self_describing_action' : [] | [boolean],
}
export interface GlobalTimeOfDay {
  'seconds_after_utc_midnight' : [] | [bigint],
}
export interface Governance {
  'default_followees' : Array<[number, Followees]>,
  'most_recent_monthly_node_provider_rewards' : [] | [
    MonthlyNodeProviderRewards
  ],
  'maturity_modulation_last_updated_at_timestamp_seconds' : [] | [bigint],
  'wait_for_quiet_threshold_seconds' : bigint,
  'metrics' : [] | [GovernanceCachedMetrics],
  'neuron_management_voting_period_seconds' : [] | [bigint],
  'node_providers' : Array<NodeProvider>,
  'cached_daily_maturity_modulation_basis_points' : [] | [number],
  'economics' : [] | [NetworkEconomics],
  'restore_aging_summary' : [] | [RestoreAgingSummary],
  'spawning_neurons' : [] | [boolean],
  'latest_reward_event' : [] | [RewardEvent],
  'to_claim_transfers' : Array<NeuronStakeTransfer>,
  'short_voting_period_seconds' : bigint,
  'proposals' : Array<[bigint, ProposalData]>,
  'xdr_conversion_rate' : [] | [XdrConversionRate],
  'in_flight_commands' : Array<[bigint, NeuronInFlightCommand]>,
  'neurons' : Array<[bigint, Neuron]>,
  'genesis_timestamp_seconds' : bigint,
}
export interface GovernanceCachedMetrics {
  'total_maturity_e8s_equivalent' : bigint,
  'not_dissolving_neurons_e8s_buckets' : Array<[bigint, number]>,
  'dissolving_neurons_staked_maturity_e8s_equivalent_sum' : bigint,
  'garbage_collectable_neurons_count' : bigint,
  'dissolving_neurons_staked_maturity_e8s_equivalent_buckets' : Array<
    [bigint, number]
  >,
  'neurons_with_invalid_stake_count' : bigint,
  'not_dissolving_neurons_count_buckets' : Array<[bigint, bigint]>,
  'ect_neuron_count' : bigint,
  'total_supply_icp' : bigint,
  'neurons_with_less_than_6_months_dissolve_delay_count' : bigint,
  'dissolved_neurons_count' : bigint,
  'community_fund_total_maturity_e8s_equivalent' : bigint,
  'total_staked_e8s_seed' : bigint,
  'total_staked_maturity_e8s_equivalent_ect' : bigint,
  'total_staked_e8s' : bigint,
  'fully_lost_voting_power_neuron_subset_metrics' : [] | [NeuronSubsetMetrics],
  'not_dissolving_neurons_count' : bigint,
  'total_locked_e8s' : bigint,
  'neurons_fund_total_active_neurons' : bigint,
  'total_voting_power_non_self_authenticating_controller' : [] | [bigint],
  'total_staked_maturity_e8s_equivalent' : bigint,
  'not_dissolving_neurons_e8s_buckets_ect' : Array<[bigint, number]>,
  'spawning_neurons_count' : bigint,
  'declining_voting_power_neuron_subset_metrics' : [] | [NeuronSubsetMetrics],
  'total_staked_e8s_ect' : bigint,
  'not_dissolving_neurons_staked_maturity_e8s_equivalent_sum' : bigint,
  'dissolved_neurons_e8s' : bigint,
  'total_staked_e8s_non_self_authenticating_controller' : [] | [bigint],
  'dissolving_neurons_e8s_buckets_seed' : Array<[bigint, number]>,
  'neurons_with_less_than_6_months_dissolve_delay_e8s' : bigint,
  'not_dissolving_neurons_staked_maturity_e8s_equivalent_buckets' : Array<
    [bigint, number]
  >,
  'dissolving_neurons_count_buckets' : Array<[bigint, bigint]>,
  'dissolving_neurons_e8s_buckets_ect' : Array<[bigint, number]>,
  'non_self_authenticating_controller_neuron_subset_metrics' : [] | [
    NeuronSubsetMetrics
  ],
  'dissolving_neurons_count' : bigint,
  'dissolving_neurons_e8s_buckets' : Array<[bigint, number]>,
  'total_staked_maturity_e8s_equivalent_seed' : bigint,
  'community_fund_total_staked_e8s' : bigint,
  'not_dissolving_neurons_e8s_buckets_seed' : Array<[bigint, number]>,
  'public_neuron_subset_metrics' : [] | [NeuronSubsetMetrics],
  'timestamp_seconds' : bigint,
  'seed_neuron_count' : bigint,
}
export interface GovernanceError {
  'error_message' : string,
  'error_type' : number,
}
export interface GovernanceParameters {
  'neuron_maximum_dissolve_delay_bonus' : [] | [Percentage],
  'neuron_maximum_age_for_age_bonus' : [] | [Duration],
  'neuron_maximum_dissolve_delay' : [] | [Duration],
  'neuron_minimum_dissolve_delay_to_vote' : [] | [Duration],
  'neuron_maximum_age_bonus' : [] | [Percentage],
  'neuron_minimum_stake' : [] | [Tokens],
  'proposal_wait_for_quiet_deadline_increase' : [] | [Duration],
  'proposal_initial_voting_period' : [] | [Duration],
  'custom_proposal_criticality' : [] | [CustomProposalCriticality],
  'proposal_rejection_fee' : [] | [Tokens],
  'voting_reward_parameters' : [] | [VotingRewardParameters],
}
export interface GuestLaunchMeasurement {
  /**
   * Metadata associated with the measurement.
   */
  'metadata' : [] | [GuestLaunchMeasurementMetadata],
  /**
   * SEV-SNP measurement (48 bytes).
   */
  'measurement' : [] | [Uint8Array],
}
export interface GuestLaunchMeasurementMetadata {
  /**
   * Kernel command line used for this measurement.
   */
  'kernel_cmdline' : [] | [string],
}
export interface GuestLaunchMeasurements {
  'guest_launch_measurements' : [] | [Array<GuestLaunchMeasurement>],
}
export interface IdealMatchedParticipationFunction {
  'serialized_representation' : [] | [string],
}
export interface Image { 'base64_encoding' : [] | [string] }
export interface IncreaseDissolveDelay {
  'additional_dissolve_delay_seconds' : number,
}
export interface InitialTokenDistribution {
  'treasury_distribution' : [] | [SwapDistribution],
  'developer_distribution' : [] | [DeveloperDistribution],
  'swap_distribution' : [] | [SwapDistribution],
}
export interface InstallCode {
  'skip_stopping_before_installing' : [] | [boolean],
  'wasm_module_hash' : [] | [Uint8Array],
  'canister_id' : [] | [Principal],
  'arg_hash' : [] | [Uint8Array],
  'install_mode' : [] | [number],
}
export interface InstallCodeRequest {
  'arg' : [] | [Uint8Array],
  'wasm_module' : [] | [Uint8Array],
  'skip_stopping_before_installing' : [] | [boolean],
  'canister_id' : [] | [Principal],
  'install_mode' : [] | [number],
}
export interface KnownNeuron {
  'id' : [] | [NeuronId],
  'known_neuron_data' : [] | [KnownNeuronData],
}
export interface KnownNeuronData {
  'name' : string,
  /**
   * Topics that the known neuron is committed to always vote on.
   * Note regarding the type: the first `opt` makes it so that the field can be renamed/deprecated
   * in the future, and the second `opt` makes it so that an older client not recognizing a new
   * variant can still get the rest of the `vec`.
   */
  'committed_topics' : [] | [Array<[] | [TopicToFollow]>],
  'description' : [] | [string],
  /**
   * Links related to the known neuron. Can be links to social URLs (OpenChat, X, etc.), or a homepage.
   */
  'links' : [] | [Array<string>],
}
export interface LedgerParameters {
  'transaction_fee' : [] | [Tokens],
  'token_symbol' : [] | [string],
  'token_logo' : [] | [Image],
  'token_name' : [] | [string],
}
export interface ListKnownNeuronsResponse {
  'known_neurons' : Array<KnownNeuron>,
}
export interface ListNeuronVotesRequest {
  /**
   * Only fetch the voting history for proposal whose id `< before_proposal`. This can be used as a
   * pagination token - pass the minimum proposal id as `before_proposal` for the next page.
   */
  'before_proposal' : [] | [ProposalId],
  /**
   * The maximum number of votes to fetch. The maximum number allowed is 500, and 500 will be used
   * if is set as either null or > 500.
   */
  'limit' : [] | [bigint],
  /**
   * The neuron id for which the voting history will be returned. Currently, the voting history is
   * only recorded for known neurons.
   */
  'neuron_id' : [] | [NeuronId],
}
export type ListNeuronVotesResponse = {
    'Ok' : {
      'votes' : [] | [Array<NeuronVote>],
      /**
       * All the proposals before this id is "finalized", which means if a proposal before this id
       * does not exist in the votes, it will never appear in the voting history, either because the
       * neuron is not eligible to vote on the proposal, or the neuron is not a known neuron at the
       * time of the proposal creation. Therefore, if a client syncs the entire voting history of a
       * certain neuron and store `all_finalized_before_proposal`, it doesn't need to start from
       * scratch the next time - it can stop as soon as they have seen any votes
       * `< all_finalized_before_proposal`.
       */
      'all_finalized_before_proposal' : [] | [ProposalId],
    }
  } |
  { 'Err' : GovernanceError };
/**
 * Parameters of the list_neurons method.
 */
export interface ListNeurons {
  'page_size' : [] | [bigint],
  /**
   * When a public neuron is a member of the result set, include it in the
   * full_neurons field (of ListNeuronsResponse). This does not affect which
   * neurons are part of the result set.
   */
  'include_public_neurons_in_full_neurons' : [] | [boolean],
  /**
   * These fields select neurons to be in the result set.
   */
  'neuron_ids' : BigUint64Array,
  'page_number' : [] | [bigint],
  /**
   * Only has an effect when include_neurons_readable_by_caller.
   */
  'include_empty_neurons_readable_by_caller' : [] | [boolean],
  'neuron_subaccounts' : [] | [Array<NeuronSubaccount>],
  'include_neurons_readable_by_caller' : boolean,
}
/**
 * Output of the list_neurons method.
 */
export interface ListNeuronsResponse {
  /**
   * Per the NeuronInfo type, this is a redacted view of the neurons in the
   * result set consisting of information that require no special privileges to
   * view.
   */
  'neuron_infos' : Array<[bigint, NeuronInfo]>,
  /**
   * If the caller has the necessary special privileges (or the neuron is
   * public, and the request sets include_public_neurons_in_full_neurons to
   * true), then all the information about the neurons in the result set is made
   * available here.
   */
  'full_neurons' : Array<Neuron>,
  'total_pages_available' : [] | [bigint],
}
export interface ListNodeProviderRewardsRequest {
  'date_filter' : [] | [DateRangeFilter],
}
export interface ListNodeProviderRewardsResponse {
  'rewards' : Array<MonthlyNodeProviderRewards>,
}
export interface ListNodeProvidersResponse {
  'node_providers' : Array<NodeProvider>,
}
export interface ListProposalInfoRequest {
  'return_self_describing_action' : [] | [boolean],
  'include_reward_status' : Int32Array,
  'omit_large_fields' : [] | [boolean],
  'before_proposal' : [] | [ProposalId],
  'limit' : number,
  'exclude_topic' : Int32Array,
  'include_all_manage_neuron_proposals' : [] | [boolean],
  'include_status' : Int32Array,
}
export interface ListProposalInfoResponse {
  'proposal_info' : Array<ProposalInfo>,
}
export interface LoadCanisterSnapshot {
  'canister_id' : [] | [Principal],
  'snapshot_id' : [] | [Uint8Array],
}
export interface MakeProposalRequest {
  'url' : string,
  'title' : [] | [string],
  'action' : [] | [ProposalActionRequest],
  'summary' : string,
}
export interface MakeProposalResponse {
  'message' : [] | [string],
  'proposal_id' : [] | [ProposalId],
}
/**
 * KEEP THIS IN SYNC WITH COMMAND!
 */
export type ManageNeuronCommandRequest = { 'Spawn' : Spawn } |
  { 'Split' : Split } |
  { 'Follow' : Follow } |
  { 'DisburseMaturity' : DisburseMaturity } |
  { 'RefreshVotingPower' : RefreshVotingPower } |
  { 'ClaimOrRefresh' : ClaimOrRefresh } |
  { 'Configure' : Configure } |
  { 'RegisterVote' : RegisterVote } |
  { 'Merge' : Merge } |
  { 'DisburseToNeuron' : DisburseToNeuron } |
  { 'SetFollowing' : SetFollowing } |
  { 'MakeProposal' : MakeProposalRequest } |
  { 'StakeMaturity' : StakeMaturity } |
  { 'MergeMaturity' : MergeMaturity } |
  { 'Disburse' : Disburse };
/**
 * Not to be confused with ManageNeuronRequest. This is only used to represent a manage neuron proposal.
 * (Yes, this is very structurally similar to that, but not actually exactly equivalent)
 */
export interface ManageNeuronProposal {
  'id' : [] | [NeuronId],
  'command' : [] | [ManageNeuronProposalCommand],
  'neuron_id_or_subaccount' : [] | [NeuronIdOrSubaccount],
}
/**
 * KEEP THIS IN SYNC WITH ManageNeuronCommandRequest!
 */
export type ManageNeuronProposalCommand = { 'Spawn' : Spawn } |
  { 'Split' : Split } |
  { 'Follow' : Follow } |
  { 'DisburseMaturity' : DisburseMaturity } |
  { 'RefreshVotingPower' : RefreshVotingPower } |
  { 'ClaimOrRefresh' : ClaimOrRefresh } |
  { 'Configure' : Configure } |
  { 'RegisterVote' : RegisterVote } |
  { 'Merge' : Merge } |
  { 'DisburseToNeuron' : DisburseToNeuron } |
  { 'SetFollowing' : SetFollowing } |
  { 'MakeProposal' : Proposal } |
  { 'StakeMaturity' : StakeMaturity } |
  { 'MergeMaturity' : MergeMaturity } |
  { 'Disburse' : Disburse };
/**
 * Parameters of the manage_neuron method.
 */
export interface ManageNeuronRequest {
  /**
   * Deprecated. Use neuron_id_or_subaccount instead.
   */
  'id' : [] | [NeuronId],
  /**
   * What operation to perform on the neuron.
   */
  'command' : [] | [ManageNeuronCommandRequest],
  /**
   * Which neuron to operate on.
   */
  'neuron_id_or_subaccount' : [] | [NeuronIdOrSubaccount],
}
/**
 * Output of the manage_neuron method.
 */
export interface ManageNeuronResponse {
  /**
   * Corresponds to the command field in ManageNeuronRequest, which determines
   * what operation was performed.
   */
  'command' : [] | [Command_1],
}
export interface MaturityDisbursement {
  'account_identifier_to_disburse_to' : [] | [AccountIdentifier],
  'timestamp_of_disbursement_seconds' : [] | [bigint],
  'amount_e8s' : [] | [bigint],
  'account_to_disburse_to' : [] | [Account],
  'finalize_disbursement_timestamp_seconds' : [] | [bigint],
}
export interface Merge { 'source_neuron_id' : [] | [NeuronId] }
export interface MergeMaturity { 'percentage_to_merge' : number }
export interface MergeMaturityResponse {
  'merged_maturity_e8s' : bigint,
  'new_stake_e8s' : bigint,
}
export interface MergeResponse {
  'target_neuron' : [] | [Neuron],
  'source_neuron' : [] | [Neuron],
  'target_neuron_info' : [] | [NeuronInfo],
  'source_neuron_info' : [] | [NeuronInfo],
}
export interface MonthlyNodeProviderRewards {
  'algorithm_version' : [] | [number],
  'minimum_xdr_permyriad_per_icp' : [] | [bigint],
  'end_date' : [] | [DateUtc],
  'registry_version' : [] | [bigint],
  'node_providers' : Array<NodeProvider>,
  'start_date' : [] | [DateUtc],
  'timestamp' : bigint,
  'rewards' : Array<RewardNodeProvider>,
  'xdr_conversion_rate' : [] | [XdrConversionRate],
  'maximum_node_provider_rewards_e8s' : [] | [bigint],
}
export interface Motion { 'motion_text' : string }
export interface NetworkEconomics {
  'neuron_minimum_stake_e8s' : bigint,
  /**
   * Parameters that affect the voting power of neurons.
   */
  'voting_power_economics' : [] | [VotingPowerEconomics],
  'max_proposals_to_keep_per_topic' : number,
  'neuron_management_fee_per_proposal_e8s' : bigint,
  'reject_cost_e8s' : bigint,
  'transaction_fee_e8s' : bigint,
  'neuron_spawn_dissolve_delay_seconds' : bigint,
  'minimum_icp_xdr_rate' : bigint,
  'maximum_node_provider_rewards_e8s' : bigint,
  'neurons_fund_economics' : [] | [NeuronsFundEconomics],
}
export interface Neuron {
  'id' : [] | [NeuronId],
  'staked_maturity_e8s_equivalent' : [] | [bigint],
  'controller' : [] | [Principal],
  'recent_ballots' : Array<BallotInfo>,
  'voting_power_refreshed_timestamp_seconds' : [] | [bigint],
  'kyc_verified' : boolean,
  /**
   * The amount of "sway" this neuron can have if it refreshes its voting power
   * frequently enough.
   * 
   * Unlike deciding_voting_power, this does NOT take refreshing into account.
   * Rather, this only takes three factors into account:
   * 
   * 1. (Net) staked amount - This is the "base" of a neuron's voting power.
   * This primarily consists of the neuron's ICP balance.
   * 
   * 2. Age - Neurons with more age have more voting power (all else being
   * equal).
   * 
   * 3. Dissolve delay - Neurons with longer dissolve delay have more voting
   * power (all else being equal). Neurons with a dissolve delay of less
   * than six months are not eligible to vote. Therefore, such neurons
   * are considered to have 0 voting power.
   * 
   * Per NNS policy, this is opt. Nevertheless, it will never be null.
   */
  'potential_voting_power' : [] | [bigint],
  'neuron_type' : [] | [number],
  'not_for_profit' : boolean,
  'maturity_e8s_equivalent' : bigint,
  /**
   * The amount of "sway" this neuron has when voting on proposals.
   * 
   * When a proposal is created, each eligible neuron gets a "blank" ballot. The
   * amount of voting power in that ballot is set to the neuron's deciding
   * voting power at the time of proposal creation. There are two ways that a
   * proposal can become decided:
   * 
   * 1. Early: Either more than half of the total voting power in the ballots
   * votes in favor (then the proposal is approved), or at least half of the
   * votal voting power in the ballots votes against (then, the proposal is
   * rejected).
   * 
   * 2. The proposal's voting deadline is reached. At that point, if there is
   * more voting power in favor than against, and at least 3% of the total
   * voting power voted in favor, then the proposal is approved. Otherwise, it
   * is rejected.
   * 
   * If a neuron regularly refreshes its voting power, this has the same value
   * as potential_voting_power. Actions that cause a refresh are as follows:
   * 
   * 1. voting directly (not via following)
   * 2. set following
   * 3. refresh voting power
   * 
   * (All of these actions are performed via the manage_neuron method.)
   * 
   * However, if a neuron has not refreshed in a "long" time, this will be less
   * than potential voting power. See VotingPowerEconomics. As a further result
   * of less deciding voting power, not only does it have less influence on the
   * outcome of proposals, the neuron receives less voting rewards (when it
   * votes indirectly via following).
   * 
   * For details, see https://dashboard.internetcomputer.org/proposal/132411.
   * 
   * Per NNS policy, this is opt. Nevertheless, it will never be null.
   */
  'deciding_voting_power' : [] | [bigint],
  'cached_neuron_stake_e8s' : bigint,
  'created_timestamp_seconds' : bigint,
  'auto_stake_maturity' : [] | [boolean],
  'aging_since_timestamp_seconds' : bigint,
  'hot_keys' : Array<Principal>,
  'account' : Uint8Array,
  'joined_community_fund_timestamp_seconds' : [] | [bigint],
  /**
   * The maturity disbursements in progress, i.e. the disbursements that are initiated but not
   * finalized. The finalization happens 7 days after the disbursement is initiated.
   */
  'maturity_disbursements_in_progress' : [] | [Array<MaturityDisbursement>],
  'dissolve_state' : [] | [DissolveState],
  'followees' : Array<[number, Followees]>,
  'neuron_fees_e8s' : bigint,
  'visibility' : [] | [number],
  'transfer' : [] | [NeuronStakeTransfer],
  'known_neuron_data' : [] | [KnownNeuronData],
  'spawn_at_timestamp_seconds' : [] | [bigint],
}
export interface NeuronBasketConstructionParameters {
  'dissolve_delay_interval' : [] | [Duration],
  'count' : [] | [bigint],
}
export interface NeuronBasketConstructionParameters_1 {
  'dissolve_delay_interval_seconds' : bigint,
  'count' : bigint,
}
export interface NeuronDistribution {
  'controller' : [] | [Principal],
  'dissolve_delay' : [] | [Duration],
  'memo' : [] | [bigint],
  'vesting_period' : [] | [Duration],
  'stake' : [] | [Tokens],
}
export interface NeuronId { 'id' : bigint }
export type NeuronIdOrSubaccount = { 'Subaccount' : Uint8Array } |
  { 'NeuronId' : NeuronId };
export interface NeuronInFlightCommand {
  'command' : [] | [Command_2],
  'timestamp' : bigint,
}
export interface NeuronIndexData { 'neurons' : Array<NeuronInfo> }
/**
 * A limit view of Neuron that allows some aspects of all neurons to be read by
 * anyone (i.e. without having to be the neuron's controller nor one of its
 * hotkeys).
 * 
 * As such, the meaning of each field in this type is generally the same as the
 * one of the same (or at least similar) name in Neuron.
 */
export interface NeuronInfo {
  'id' : [] | [NeuronId],
  'dissolve_delay_seconds' : bigint,
  'recent_ballots' : Array<BallotInfo>,
  'voting_power_refreshed_timestamp_seconds' : [] | [bigint],
  'potential_voting_power' : [] | [bigint],
  'neuron_type' : [] | [number],
  'deciding_voting_power' : [] | [bigint],
  'created_timestamp_seconds' : bigint,
  'state' : number,
  /**
   * The amount of ICP (and staked maturity) locked in this neuron.
   * 
   * This is the foundation of the neuron's voting power.
   * 
   * cached_neuron_stake_e8s - neuron_fees_e8s + staked_maturity_e8s_equivalent
   */
  'stake_e8s' : bigint,
  'joined_community_fund_timestamp_seconds' : [] | [bigint],
  'retrieved_at_timestamp_seconds' : bigint,
  'visibility' : [] | [number],
  'known_neuron_data' : [] | [KnownNeuronData],
  /**
   * Deprecated. Use either deciding_voting_power or potential_voting_power
   * instead. Has the same value as deciding_voting_power.
   * 
   * Previously, if a neuron had < 6 months dissolve delay (making it ineligible
   * to vote), this would not get set to 0 (zero). That was pretty confusing.
   * Now that this is set to deciding_voting_power, this actually does get
   * zeroed out.
   */
  'voting_power' : bigint,
  'age_seconds' : bigint,
}
export interface NeuronStakeTransfer {
  'to_subaccount' : Uint8Array,
  'neuron_stake_e8s' : bigint,
  'from' : [] | [Principal],
  'memo' : bigint,
  'from_subaccount' : Uint8Array,
  'transfer_timestamp' : bigint,
  'block_height' : bigint,
}
export interface NeuronSubaccount { 'subaccount' : Uint8Array }
export interface NeuronSubsetMetrics {
  'total_maturity_e8s_equivalent' : [] | [bigint],
  'maturity_e8s_equivalent_buckets' : Array<[bigint, bigint]>,
  'voting_power_buckets' : Array<[bigint, bigint]>,
  'total_staked_e8s' : [] | [bigint],
  'count' : [] | [bigint],
  'deciding_voting_power_buckets' : Array<[bigint, bigint]>,
  'total_staked_maturity_e8s_equivalent' : [] | [bigint],
  'total_potential_voting_power' : [] | [bigint],
  'total_deciding_voting_power' : [] | [bigint],
  'staked_maturity_e8s_equivalent_buckets' : Array<[bigint, bigint]>,
  'staked_e8s_buckets' : Array<[bigint, bigint]>,
  'total_voting_power' : [] | [bigint],
  'potential_voting_power_buckets' : Array<[bigint, bigint]>,
  'count_buckets' : Array<[bigint, bigint]>,
}
export interface NeuronVote {
  /**
   * The vote of the neuron on the specific proposal id.
   */
  'vote' : [] | [Vote],
  'proposal_id' : [] | [ProposalId],
}
export interface NeuronsFundAuditInfo {
  'final_neurons_fund_participation' : [] | [NeuronsFundParticipation],
  'initial_neurons_fund_participation' : [] | [NeuronsFundParticipation],
  'neurons_fund_refunds' : [] | [NeuronsFundSnapshot],
}
export interface NeuronsFundData {
  'final_neurons_fund_participation' : [] | [NeuronsFundParticipation],
  'initial_neurons_fund_participation' : [] | [NeuronsFundParticipation],
  'neurons_fund_refunds' : [] | [NeuronsFundSnapshot],
}
export interface NeuronsFundEconomics {
  'maximum_icp_xdr_rate' : [] | [Percentage],
  'neurons_fund_matched_funding_curve_coefficients' : [] | [
    NeuronsFundMatchedFundingCurveCoefficients
  ],
  'max_theoretical_neurons_fund_participation_amount_xdr' : [] | [Decimal],
  'minimum_icp_xdr_rate' : [] | [Percentage],
}
export interface NeuronsFundMatchedFundingCurveCoefficients {
  'contribution_threshold_xdr' : [] | [Decimal],
  'one_third_participation_milestone_xdr' : [] | [Decimal],
  'full_participation_milestone_xdr' : [] | [Decimal],
}
export interface NeuronsFundNeuron {
  'controller' : [] | [Principal],
  'hotkeys' : [] | [Principals],
  'is_capped' : [] | [boolean],
  'nns_neuron_id' : [] | [bigint],
  'amount_icp_e8s' : [] | [bigint],
}
export interface NeuronsFundNeuronPortion {
  'controller' : [] | [Principal],
  'hotkeys' : Array<Principal>,
  'is_capped' : [] | [boolean],
  'maturity_equivalent_icp_e8s' : [] | [bigint],
  'nns_neuron_id' : [] | [NeuronId],
  'amount_icp_e8s' : [] | [bigint],
}
export interface NeuronsFundParticipation {
  'total_maturity_equivalent_icp_e8s' : [] | [bigint],
  'intended_neurons_fund_participation_icp_e8s' : [] | [bigint],
  'direct_participation_icp_e8s' : [] | [bigint],
  'swap_participation_limits' : [] | [SwapParticipationLimits],
  'max_neurons_fund_swap_participation_icp_e8s' : [] | [bigint],
  'neurons_fund_reserves' : [] | [NeuronsFundSnapshot],
  'ideal_matched_participation_function' : [] | [
    IdealMatchedParticipationFunction
  ],
  'allocated_neurons_fund_participation_icp_e8s' : [] | [bigint],
}
export interface NeuronsFundSnapshot {
  'neurons_fund_neuron_portions' : Array<NeuronsFundNeuronPortion>,
}
export interface NodeProvider {
  'id' : [] | [Principal],
  'reward_account' : [] | [AccountIdentifier],
}
export interface Ok { 'neurons_fund_audit_info' : [] | [NeuronsFundAuditInfo] }
export interface Ok_1 {
  'neurons_fund_neuron_portions' : Array<NeuronsFundNeuron>,
}
export interface OpenSnsTokenSwap {
  'community_fund_investment_e8s' : [] | [bigint],
  'target_swap_canister_id' : [] | [Principal],
  'params' : [] | [Params],
}
export type Operation = { 'RemoveHotKey' : RemoveHotKey } |
  { 'AddHotKey' : AddHotKey } |
  { 'ChangeAutoStakeMaturity' : ChangeAutoStakeMaturity } |
  { 'StopDissolving' : {} } |
  { 'StartDissolving' : {} } |
  { 'IncreaseDissolveDelay' : IncreaseDissolveDelay } |
  { 'SetVisibility' : SetVisibility } |
  { 'JoinCommunityFund' : {} } |
  { 'LeaveCommunityFund' : {} } |
  { 'SetDissolveTimestamp' : SetDissolveTimestamp };
export interface Params {
  'min_participant_icp_e8s' : bigint,
  'neuron_basket_construction_parameters' : [] | [
    NeuronBasketConstructionParameters_1
  ],
  'max_icp_e8s' : bigint,
  'swap_due_timestamp_seconds' : bigint,
  'min_participants' : number,
  'sns_token_e8s' : bigint,
  'sale_delay_seconds' : [] | [bigint],
  'max_participant_icp_e8s' : bigint,
  'min_direct_participation_icp_e8s' : [] | [bigint],
  'min_icp_e8s' : bigint,
  'max_direct_participation_icp_e8s' : [] | [bigint],
}
export interface Percentage { 'basis_points' : [] | [bigint] }
export interface Principals { 'principals' : Array<Principal> }
export interface Proposal {
  'url' : string,
  'title' : [] | [string],
  'action' : [] | [Action],
  'summary' : string,
  'self_describing_action' : [] | [SelfDescribingProposalAction],
}
export type ProposalActionRequest = { 'RegisterKnownNeuron' : KnownNeuron } |
  { 'FulfillSubnetRentalRequest' : FulfillSubnetRentalRequest } |
  { 'ManageNeuron' : ManageNeuronRequest } |
  { 'LoadCanisterSnapshot' : LoadCanisterSnapshot } |
  { 'BlessAlternativeGuestOsVersion' : BlessAlternativeGuestOsVersion } |
  { 'UpdateCanisterSettings' : UpdateCanisterSettings } |
  { 'InstallCode' : InstallCodeRequest } |
  { 'DeregisterKnownNeuron' : DeregisterKnownNeuron } |
  { 'TakeCanisterSnapshot' : TakeCanisterSnapshot } |
  { 'StopOrStartCanister' : StopOrStartCanister } |
  { 'CreateServiceNervousSystem' : CreateServiceNervousSystem } |
  { 'ExecuteNnsFunction' : ExecuteNnsFunction } |
  { 'RewardNodeProvider' : RewardNodeProvider } |
  { 'RewardNodeProviders' : RewardNodeProviders } |
  { 'ManageNetworkEconomics' : NetworkEconomics } |
  { 'ApproveGenesisKyc' : Principals } |
  { 'AddOrRemoveNodeProvider' : AddOrRemoveNodeProvider } |
  { 'Motion' : Motion };
export interface ProposalData {
  'id' : [] | [ProposalId],
  'topic' : [] | [number],
  'failure_reason' : [] | [GovernanceError],
  'ballots' : Array<[bigint, Ballot]>,
  'proposal_timestamp_seconds' : bigint,
  'reward_event_round' : bigint,
  'failed_timestamp_seconds' : bigint,
  'neurons_fund_data' : [] | [NeuronsFundData],
  'reject_cost_e8s' : bigint,
  'derived_proposal_information' : [] | [DerivedProposalInformation],
  'latest_tally' : [] | [Tally],
  'total_potential_voting_power' : [] | [bigint],
  'sns_token_swap_lifecycle' : [] | [number],
  'decided_timestamp_seconds' : bigint,
  'proposal' : [] | [Proposal],
  'proposer' : [] | [NeuronId],
  'wait_for_quiet_state' : [] | [WaitForQuietState],
  'executed_timestamp_seconds' : bigint,
  'original_total_community_fund_maturity_e8s_equivalent' : [] | [bigint],
}
export interface ProposalId { 'id' : bigint }
export interface ProposalInfo {
  'id' : [] | [ProposalId],
  'status' : number,
  'topic' : number,
  'failure_reason' : [] | [GovernanceError],
  'ballots' : Array<[bigint, Ballot]>,
  'proposal_timestamp_seconds' : bigint,
  'reward_event_round' : bigint,
  'deadline_timestamp_seconds' : [] | [bigint],
  'failed_timestamp_seconds' : bigint,
  'reject_cost_e8s' : bigint,
  'derived_proposal_information' : [] | [DerivedProposalInformation],
  'latest_tally' : [] | [Tally],
  'total_potential_voting_power' : [] | [bigint],
  'reward_status' : number,
  'decided_timestamp_seconds' : bigint,
  'proposal' : [] | [Proposal],
  'proposer' : [] | [NeuronId],
  'executed_timestamp_seconds' : bigint,
}
/**
 * This is one way for a neuron to make sure that its deciding_voting_power is
 * not less than its potential_voting_power. See the description of those fields
 * in Neuron.
 */
export type RefreshVotingPower = {};
export type RefreshVotingPowerResponse = {};
export interface RegisterVote {
  'vote' : number,
  'proposal' : [] | [ProposalId],
}
export interface RemoveHotKey { 'hot_key_to_remove' : [] | [Principal] }
export interface RestoreAgingNeuronGroup {
  'count' : [] | [bigint],
  'previous_total_stake_e8s' : [] | [bigint],
  'current_total_stake_e8s' : [] | [bigint],
  'group_type' : number,
}
export interface RestoreAgingSummary {
  'groups' : Array<RestoreAgingNeuronGroup>,
  'timestamp_seconds' : [] | [bigint],
}
export type Result = { 'Ok' : null } |
  { 'Err' : GovernanceError };
export type Result_1 = { 'Error' : GovernanceError } |
  { 'NeuronId' : NeuronId };
export type Result_10 = { 'Ok' : Ok_1 } |
  { 'Err' : GovernanceError };
export type Result_2 = { 'Ok' : Neuron } |
  { 'Err' : GovernanceError };
export type Result_3 = { 'Ok' : GovernanceCachedMetrics } |
  { 'Err' : GovernanceError };
export type Result_4 = { 'Ok' : MonthlyNodeProviderRewards } |
  { 'Err' : GovernanceError };
export type Result_5 = { 'Ok' : NeuronInfo } |
  { 'Err' : GovernanceError };
export type Result_6 = { 'Ok' : Ok } |
  { 'Err' : GovernanceError };
export type Result_7 = { 'Ok' : NodeProvider } |
  { 'Err' : GovernanceError };
export type Result_8 = { 'Committed' : Committed } |
  { 'Aborted' : {} };
export type Result_9 = { 'Committed' : Committed_1 } |
  { 'Aborted' : {} };
export interface RewardEvent {
  'rounds_since_last_distribution' : [] | [bigint],
  'day_after_genesis' : bigint,
  'actual_timestamp_seconds' : bigint,
  'total_available_e8s_equivalent' : bigint,
  'latest_round_available_e8s_equivalent' : [] | [bigint],
  'distributed_e8s_equivalent' : bigint,
  'settled_proposals' : Array<ProposalId>,
}
export type RewardMode = { 'RewardToNeuron' : RewardToNeuron } |
  { 'RewardToAccount' : RewardToAccount };
export interface RewardNodeProvider {
  'node_provider' : [] | [NodeProvider],
  'reward_mode' : [] | [RewardMode],
  'amount_e8s' : bigint,
}
export interface RewardNodeProviders {
  'use_registry_derived_rewards' : [] | [boolean],
  'rewards' : Array<RewardNodeProvider>,
}
export interface RewardToAccount { 'to_account' : [] | [AccountIdentifier] }
export interface RewardToNeuron { 'dissolve_delay_seconds' : bigint }
export interface SelfDescribingProposalAction {
  'type_description' : [] | [string],
  'type_name' : [] | [string],
  'value' : [] | [SelfDescribingValue],
}
export type SelfDescribingValue = { 'Int' : bigint } |
  { 'Map' : Array<[string, SelfDescribingValue]> } |
  { 'Nat' : bigint } |
  { 'Blob' : Uint8Array } |
  { 'Bool' : boolean } |
  { 'Null' : null } |
  { 'Text' : string } |
  { 'Array' : Array<SelfDescribingValue> };
export interface SetDefaultFollowees {
  'default_followees' : Array<[number, Followees]>,
}
export interface SetDissolveTimestamp { 'dissolve_timestamp_seconds' : bigint }
export interface SetFollowing {
  'topic_following' : [] | [Array<FolloweesForTopic>],
}
export type SetFollowingResponse = {};
export interface SetOpenTimeWindowRequest {
  'open_time_window' : [] | [TimeWindow],
}
export interface SetSnsTokenSwapOpenTimeWindow {
  'request' : [] | [SetOpenTimeWindowRequest],
  'swap_canister_id' : [] | [Principal],
}
export interface SetVisibility { 'visibility' : [] | [number] }
export interface SettleCommunityFundParticipation {
  'result' : [] | [Result_8],
  'open_sns_token_swap_proposal_id' : [] | [bigint],
}
export interface SettleNeuronsFundParticipationRequest {
  'result' : [] | [Result_9],
  'nns_proposal_id' : [] | [bigint],
}
export interface SettleNeuronsFundParticipationResponse {
  'result' : [] | [Result_10],
}
export interface Spawn {
  'percentage_to_spawn' : [] | [number],
  'new_controller' : [] | [Principal],
  'nonce' : [] | [bigint],
}
export interface SpawnResponse { 'created_neuron_id' : [] | [NeuronId] }
export interface Split { 'memo' : [] | [bigint], 'amount_e8s' : bigint }
export interface StakeMaturity { 'percentage_to_stake' : [] | [number] }
export interface StakeMaturityResponse {
  'maturity_e8s' : bigint,
  'staked_maturity_e8s' : bigint,
}
export interface StopOrStartCanister {
  'action' : [] | [number],
  'canister_id' : [] | [Principal],
}
export interface SwapBackgroundInformation {
  'ledger_index_canister_summary' : [] | [CanisterSummary],
  'fallback_controller_principal_ids' : Array<Principal>,
  'ledger_archive_canister_summaries' : Array<CanisterSummary>,
  'ledger_canister_summary' : [] | [CanisterSummary],
  'swap_canister_summary' : [] | [CanisterSummary],
  'governance_canister_summary' : [] | [CanisterSummary],
  'root_canister_summary' : [] | [CanisterSummary],
  'dapp_canister_summaries' : Array<CanisterSummary>,
}
export interface SwapDistribution { 'total' : [] | [Tokens] }
export interface SwapParameters {
  'minimum_participants' : [] | [bigint],
  'neurons_fund_participation' : [] | [boolean],
  'duration' : [] | [Duration],
  'neuron_basket_construction_parameters' : [] | [
    NeuronBasketConstructionParameters
  ],
  'confirmation_text' : [] | [string],
  'maximum_participant_icp' : [] | [Tokens],
  'minimum_icp' : [] | [Tokens],
  'minimum_direct_participation_icp' : [] | [Tokens],
  'minimum_participant_icp' : [] | [Tokens],
  'start_time' : [] | [GlobalTimeOfDay],
  'maximum_direct_participation_icp' : [] | [Tokens],
  'maximum_icp' : [] | [Tokens],
  'neurons_fund_investment_icp' : [] | [Tokens],
  'restricted_countries' : [] | [Countries],
}
export interface SwapParticipationLimits {
  'min_participant_icp_e8s' : [] | [bigint],
  'max_participant_icp_e8s' : [] | [bigint],
  'min_direct_participation_icp_e8s' : [] | [bigint],
  'max_direct_participation_icp_e8s' : [] | [bigint],
}
export interface TakeCanisterSnapshot {
  'replace_snapshot' : [] | [Uint8Array],
  'canister_id' : [] | [Principal],
}
export interface Tally {
  'no' : bigint,
  'yes' : bigint,
  'total' : bigint,
  'timestamp_seconds' : bigint,
}
export interface TimeWindow {
  'start_timestamp_seconds' : bigint,
  'end_timestamp_seconds' : bigint,
}
export interface Tokens { 'e8s' : [] | [bigint] }
/**
 * A topic that can be followed. It is almost the same as the topic on the
 * proposal, except that the `CatchAll` is a special value and following on this
 * `topic` will let the neuron follow the votes on all topics except for
 * Governance and SnsAndCommunityFund.
 */
export type TopicToFollow = { 'Kyc' : null } |
  { 'ServiceNervousSystemManagement' : null } |
  { 'ApiBoundaryNodeManagement' : null } |
  { 'ApplicationCanisterManagement' : null } |
  { 'SubnetRental' : null } |
  { 'NeuronManagement' : null } |
  { 'NodeProviderRewards' : null } |
  { 'SubnetManagement' : null } |
  { 'ExchangeRate' : null } |
  { 'CatchAll' : null } |
  { 'NodeAdmin' : null } |
  { 'IcOsVersionElection' : null } |
  { 'ProtocolCanisterManagement' : null } |
  { 'NetworkEconomics' : null } |
  { 'IcOsVersionDeployment' : null } |
  { 'ParticipantManagement' : null } |
  { 'Governance' : null } |
  { 'SnsAndCommunityFund' : null };
export interface UpdateCanisterSettings {
  'canister_id' : [] | [Principal],
  'settings' : [] | [CanisterSettings],
}
export interface UpdateNodeProvider {
  'reward_account' : [] | [AccountIdentifier],
}
export type Vote = { 'No' : null } |
  { 'Yes' : null } |
  {
    /**
     * Abstentions are recorded as Unspecified.
     */
    'Unspecified' : null
  };
/**
 * Parameters that affect the voting power of neurons.
 */
export interface VotingPowerEconomics {
  /**
   * If a neuron has not "refreshed" its voting power after this amount of time,
   * its deciding voting power starts decreasing linearly. See also
   * clear_following_after_seconds.
   * 
   * For explanation of what "refresh" means in this context, see
   * https://dashboard.internetcomputer.org/proposal/132411
   * 
   * Initially, set to 0.5 years. (The nominal length of a year is 365.25 days).
   */
  'start_reducing_voting_power_after_seconds' : [] | [bigint],
  /**
   * The minimum dissolve delay a neuron must have in order to be eligible to vote.
   * 
   * Neurons with a dissolve delay lower than this threshold will not have
   * voting power, even if they are otherwise active.
   * 
   * This value is an essential part of the staking mechanism, promoting
   * long-term alignment with the network's governance.
   */
  'neuron_minimum_dissolve_delay_to_vote_seconds' : [] | [bigint],
  /**
   * After a neuron has experienced voting power reduction for this amount of
   * time, a couple of things happen:
   * 
   * 1. Deciding voting power reaches 0.
   * 
   * 2. Its following on topics other than NeuronManagement are cleared.
   * 
   * Initially, set to 1/12 years.
   */
  'clear_following_after_seconds' : [] | [bigint],
}
export interface VotingRewardParameters {
  'reward_rate_transition_duration' : [] | [Duration],
  'initial_reward_rate' : [] | [Percentage],
  'final_reward_rate' : [] | [Percentage],
}
export interface WaitForQuietState {
  'current_deadline_timestamp_seconds' : bigint,
}
export interface XdrConversionRate {
  'xdr_permyriad_per_icp' : [] | [bigint],
  'timestamp_seconds' : [] | [bigint],
}
export interface _SERVICE {
  'claim_gtc_neurons' : ActorMethod<[Principal, Array<NeuronId>], Result>,
  'claim_or_refresh_neuron_from_account' : ActorMethod<
    [ClaimOrRefreshNeuronFromAccount],
    ClaimOrRefreshNeuronFromAccountResponse
  >,
  'create_neuron' : ActorMethod<[CreateNeuronRequest], CreateNeuronResponse>,
  'get_build_metadata' : ActorMethod<[], string>,
  'get_full_neuron' : ActorMethod<[bigint], Result_2>,
  'get_full_neuron_by_id_or_subaccount' : ActorMethod<
    [NeuronIdOrSubaccount],
    Result_2
  >,
  'get_latest_reward_event' : ActorMethod<[], RewardEvent>,
  'get_metrics' : ActorMethod<[], Result_3>,
  'get_monthly_node_provider_rewards' : ActorMethod<[], Result_4>,
  'get_most_recent_monthly_node_provider_rewards' : ActorMethod<
    [],
    [] | [MonthlyNodeProviderRewards]
  >,
  'get_network_economics_parameters' : ActorMethod<[], NetworkEconomics>,
  'get_neuron_ids' : ActorMethod<[], BigUint64Array>,
  'get_neuron_index' : ActorMethod<
    [GetNeuronIndexRequest],
    GetNeuronIndexResult
  >,
  'get_neuron_info' : ActorMethod<[bigint], Result_5>,
  'get_neuron_info_by_id_or_subaccount' : ActorMethod<
    [NeuronIdOrSubaccount],
    Result_5
  >,
  'get_neurons_fund_audit_info' : ActorMethod<
    [GetNeuronsFundAuditInfoRequest],
    GetNeuronsFundAuditInfoResponse
  >,
  'get_node_provider_by_caller' : ActorMethod<[null], Result_7>,
  'get_pending_proposals' : ActorMethod<
    [[] | [GetPendingProposalsRequest]],
    Array<ProposalInfo>
  >,
  'get_proposal_info' : ActorMethod<[bigint], [] | [ProposalInfo]>,
  'get_restore_aging_summary' : ActorMethod<[], RestoreAgingSummary>,
  'list_known_neurons' : ActorMethod<[], ListKnownNeuronsResponse>,
  'list_neuron_votes' : ActorMethod<
    [ListNeuronVotesRequest],
    ListNeuronVotesResponse
  >,
  'list_neurons' : ActorMethod<[ListNeurons], ListNeuronsResponse>,
  'list_node_provider_rewards' : ActorMethod<
    [ListNodeProviderRewardsRequest],
    ListNodeProviderRewardsResponse
  >,
  'list_node_providers' : ActorMethod<[], ListNodeProvidersResponse>,
  'list_proposals' : ActorMethod<
    [ListProposalInfoRequest],
    ListProposalInfoResponse
  >,
  'manage_neuron' : ActorMethod<[ManageNeuronRequest], ManageNeuronResponse>,
  'settle_community_fund_participation' : ActorMethod<
    [SettleCommunityFundParticipation],
    Result
  >,
  'settle_neurons_fund_participation' : ActorMethod<
    [SettleNeuronsFundParticipationRequest],
    SettleNeuronsFundParticipationResponse
  >,
  'simulate_manage_neuron' : ActorMethod<
    [ManageNeuronRequest],
    ManageNeuronResponse
  >,
  'transfer_gtc_neuron' : ActorMethod<[NeuronId, NeuronId], Result>,
  /**
   * The following are methods for feature = "test"
   */
  'update_neuron' : ActorMethod<[Neuron], [] | [GovernanceError]>,
  'update_node_provider' : ActorMethod<[UpdateNodeProvider], Result>,
}
export declare const idlService: IDL.ServiceClass;
export declare const idlInitArgs: IDL.Type[];
export declare const idlFactory: IDL.InterfaceFactory;
export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];