@dfinity/sns 0.0.1

package/dist/candid/sns_governance.d.ts

@@ -0,0 +1,366 @@
+import type { Principal } from "@dfinity/principal";
+export interface AccountIdentifier {
+  hash: Array<number>;
+}
+export type Action =
+  | {
+      ManageNervousSystemParameters: NervousSystemParameters;
+    }
+  | { AddGenericNervousSystemFunction: NervousSystemFunction }
+  | { RemoveGenericNervousSystemFunction: bigint }
+  | { UpgradeSnsControlledCanister: UpgradeSnsControlledCanister }
+  | { Unspecified: {} }
+  | {
+      ExecuteGenericNervousSystemFunction: ExecuteGenericNervousSystemFunction;
+    }
+  | { Motion: Motion };
+export interface AddNeuronPermissions {
+  permissions_to_add: [] | [NeuronPermissionList];
+  principal_id: [] | [Principal];
+}
+export interface Amount {
+  e8s: bigint;
+}
+export interface Ballot {
+  vote: number;
+  cast_timestamp_seconds: bigint;
+  voting_power: bigint;
+}
+export type By = { MemoAndController: MemoAndController } | { NeuronId: {} };
+export interface CanisterStatusResultV2 {
+  controller: Principal;
+  status: CanisterStatusType;
+  freezing_threshold: bigint;
+  balance: Array<[Array<number>, bigint]>;
+  memory_size: bigint;
+  cycles: bigint;
+  settings: DefiniteCanisterSettingsArgs;
+  idle_cycles_burned_per_day: bigint;
+  module_hash: [] | [Array<number>];
+}
+export type CanisterStatusType =
+  | { stopped: null }
+  | { stopping: null }
+  | { running: null };
+export interface ClaimOrRefresh {
+  by: [] | [By];
+}
+export interface ClaimOrRefreshResponse {
+  refreshed_neuron_id: [] | [NeuronId];
+}
+export type Command =
+  | { Split: Split }
+  | { Follow: Follow }
+  | { DisburseMaturity: DisburseMaturity }
+  | { ClaimOrRefresh: ClaimOrRefresh }
+  | { Configure: Configure }
+  | { RegisterVote: RegisterVote }
+  | { MakeProposal: Proposal }
+  | { RemoveNeuronPermissions: RemoveNeuronPermissions }
+  | { AddNeuronPermissions: AddNeuronPermissions }
+  | { MergeMaturity: MergeMaturity }
+  | { Disburse: Disburse };
+export type Command_1 =
+  | { Error: GovernanceError }
+  | { Split: SplitResponse }
+  | { Follow: {} }
+  | { DisburseMaturity: DisburseMaturityResponse }
+  | { ClaimOrRefresh: ClaimOrRefreshResponse }
+  | { Configure: {} }
+  | { RegisterVote: {} }
+  | { MakeProposal: GetProposal }
+  | { RemoveNeuronPermission: {} }
+  | { MergeMaturity: MergeMaturityResponse }
+  | { Disburse: DisburseResponse }
+  | { AddNeuronPermission: {} };
+export type Command_2 =
+  | { Split: Split }
+  | { Follow: Follow }
+  | { DisburseMaturity: DisburseMaturity }
+  | { Configure: Configure }
+  | { RegisterVote: RegisterVote }
+  | { MakeProposal: Proposal }
+  | { ClaimOrRefreshNeuron: ClaimOrRefresh }
+  | { RemoveNeuronPermissions: RemoveNeuronPermissions }
+  | { AddNeuronPermissions: AddNeuronPermissions }
+  | { MergeMaturity: MergeMaturity }
+  | { Disburse: Disburse };
+export interface Configure {
+  operation: [] | [Operation];
+}
+export interface DefaultFollowees {
+  followees: Array<[bigint, Followees]>;
+}
+export interface DefiniteCanisterSettingsArgs {
+  controller: Principal;
+  freezing_threshold: bigint;
+  controllers: Array<Principal>;
+  memory_allocation: bigint;
+  compute_allocation: bigint;
+}
+export interface Disburse {
+  to_account: [] | [AccountIdentifier];
+  amount: [] | [Amount];
+}
+export interface DisburseMaturity {
+  to_account: [] | [AccountIdentifier];
+  percentage_to_disburse: number;
+}
+export interface DisburseMaturityResponse {
+  transfer_block_height: bigint;
+  amount_disbursed_e8s: bigint;
+}
+export interface DisburseResponse {
+  transfer_block_height: bigint;
+}
+export type DissolveState =
+  | { DissolveDelaySeconds: bigint }
+  | { WhenDissolvedTimestampSeconds: bigint };
+export interface ExecuteGenericNervousSystemFunction {
+  function_id: bigint;
+  payload: Array<number>;
+}
+export interface Follow {
+  function_id: bigint;
+  followees: Array<NeuronId>;
+}
+export interface Followees {
+  followees: Array<NeuronId>;
+}
+export type FunctionType =
+  | { NativeNervousSystemFunction: {} }
+  | { GenericNervousSystemFunction: GenericNervousSystemFunction };
+export interface GenericNervousSystemFunction {
+  validator_canister_id: [] | [Principal];
+  target_canister_id: [] | [Principal];
+  validator_method_name: [] | [string];
+  target_method_name: [] | [string];
+}
+export interface GetNeuron {
+  neuron_id: [] | [NeuronId];
+}
+export interface GetNeuronResponse {
+  result: [] | [Result];
+}
+export interface GetProposal {
+  proposal_id: [] | [ProposalId];
+}
+export interface GetProposalResponse {
+  result: [] | [Result_1];
+}
+export interface Governance {
+  root_canister_id: [] | [Principal];
+  id_to_nervous_system_functions: Array<[bigint, NervousSystemFunction]>;
+  metrics: [] | [GovernanceCachedMetrics];
+  mode: number;
+  parameters: [] | [NervousSystemParameters];
+  latest_reward_event: [] | [RewardEvent];
+  ledger_canister_id: [] | [Principal];
+  proposals: Array<[bigint, ProposalData]>;
+  in_flight_commands: Array<[string, NeuronInFlightCommand]>;
+  neurons: Array<[string, Neuron]>;
+  genesis_timestamp_seconds: bigint;
+}
+export interface GovernanceCachedMetrics {
+  not_dissolving_neurons_e8s_buckets: Array<[bigint, number]>;
+  garbage_collectable_neurons_count: bigint;
+  neurons_with_invalid_stake_count: bigint;
+  not_dissolving_neurons_count_buckets: Array<[bigint, bigint]>;
+  neurons_with_less_than_6_months_dissolve_delay_count: bigint;
+  dissolved_neurons_count: bigint;
+  total_staked_e8s: bigint;
+  total_supply_governance_tokens: bigint;
+  not_dissolving_neurons_count: bigint;
+  dissolved_neurons_e8s: bigint;
+  neurons_with_less_than_6_months_dissolve_delay_e8s: bigint;
+  dissolving_neurons_count_buckets: Array<[bigint, bigint]>;
+  dissolving_neurons_count: bigint;
+  dissolving_neurons_e8s_buckets: Array<[bigint, number]>;
+  timestamp_seconds: bigint;
+}
+export interface GovernanceError {
+  error_message: string;
+  error_type: number;
+}
+export interface IncreaseDissolveDelay {
+  additional_dissolve_delay_seconds: number;
+}
+export interface ListNervousSystemFunctionsResponse {
+  reserved_ids: Array<bigint>;
+  functions: Array<NervousSystemFunction>;
+}
+export interface ListNeurons {
+  of_principal: [] | [Principal];
+  limit: number;
+  start_page_at: [] | [NeuronId];
+}
+export interface ListNeuronsResponse {
+  neurons: Array<Neuron>;
+}
+export interface ListProposals {
+  include_reward_status: Array<number>;
+  before_proposal: [] | [ProposalId];
+  limit: number;
+  exclude_type: Array<bigint>;
+  include_status: Array<number>;
+}
+export interface ListProposalsResponse {
+  proposals: Array<ProposalData>;
+}
+export interface ManageNeuron {
+  subaccount: Array<number>;
+  command: [] | [Command];
+}
+export interface ManageNeuronResponse {
+  command: [] | [Command_1];
+}
+export interface MemoAndController {
+  controller: [] | [Principal];
+  memo: bigint;
+}
+export interface MergeMaturity {
+  percentage_to_merge: number;
+}
+export interface MergeMaturityResponse {
+  merged_maturity_e8s: bigint;
+  new_stake_e8s: bigint;
+}
+export interface Motion {
+  motion_text: string;
+}
+export interface NervousSystemFunction {
+  id: bigint;
+  name: string;
+  description: [] | [string];
+  function_type: [] | [FunctionType];
+}
+export interface NervousSystemParameters {
+  default_followees: [] | [DefaultFollowees];
+  max_dissolve_delay_seconds: [] | [bigint];
+  max_followees_per_function: [] | [bigint];
+  neuron_claimer_permissions: [] | [NeuronPermissionList];
+  neuron_minimum_stake_e8s: [] | [bigint];
+  initial_voting_period: [] | [bigint];
+  max_neuron_age_for_age_bonus: [] | [bigint];
+  neuron_minimum_dissolve_delay_to_vote_seconds: [] | [bigint];
+  reject_cost_e8s: [] | [bigint];
+  max_proposals_to_keep_per_action: [] | [number];
+  max_number_of_neurons: [] | [bigint];
+  transaction_fee_e8s: [] | [bigint];
+  max_number_of_proposals_with_ballots: [] | [bigint];
+  reward_distribution_period_seconds: [] | [bigint];
+  neuron_grantable_permissions: [] | [NeuronPermissionList];
+  max_number_of_principals_per_neuron: [] | [bigint];
+}
+export interface Neuron {
+  id: [] | [NeuronId];
+  permissions: Array<NeuronPermission>;
+  maturity_e8s_equivalent: bigint;
+  cached_neuron_stake_e8s: bigint;
+  created_timestamp_seconds: bigint;
+  aging_since_timestamp_seconds: bigint;
+  dissolve_state: [] | [DissolveState];
+  followees: Array<[bigint, Followees]>;
+  neuron_fees_e8s: bigint;
+}
+export interface NeuronId {
+  id: Array<number>;
+}
+export interface NeuronInFlightCommand {
+  command: [] | [Command_2];
+  timestamp: bigint;
+}
+export interface NeuronPermission {
+  principal: [] | [Principal];
+  permission_type: Array<number>;
+}
+export interface NeuronPermissionList {
+  permissions: Array<number>;
+}
+export type Operation =
+  | { StopDissolving: {} }
+  | { StartDissolving: {} }
+  | { IncreaseDissolveDelay: IncreaseDissolveDelay }
+  | { SetDissolveTimestamp: SetDissolveTimestamp };
+export interface Proposal {
+  url: string;
+  title: string;
+  action: [] | [Action];
+  summary: string;
+}
+export interface ProposalData {
+  id: [] | [ProposalId];
+  payload_text_rendering: [] | [string];
+  action: bigint;
+  failure_reason: [] | [GovernanceError];
+  ballots: Array<[string, Ballot]>;
+  reward_event_round: bigint;
+  failed_timestamp_seconds: bigint;
+  proposal_creation_timestamp_seconds: bigint;
+  reject_cost_e8s: bigint;
+  latest_tally: [] | [Tally];
+  decided_timestamp_seconds: bigint;
+  proposal: [] | [Proposal];
+  proposer: [] | [NeuronId];
+  wait_for_quiet_state: [] | [WaitForQuietState];
+  executed_timestamp_seconds: bigint;
+}
+export interface ProposalId {
+  id: bigint;
+}
+export interface RegisterVote {
+  vote: number;
+  proposal: [] | [ProposalId];
+}
+export interface RemoveNeuronPermissions {
+  permissions_to_remove: [] | [NeuronPermissionList];
+  principal_id: [] | [Principal];
+}
+export type Result = { Error: GovernanceError } | { Neuron: Neuron };
+export type Result_1 = { Error: GovernanceError } | { Proposal: ProposalData };
+export interface RewardEvent {
+  actual_timestamp_seconds: bigint;
+  periods_since_genesis: bigint;
+  distributed_e8s_equivalent: bigint;
+  settled_proposals: Array<ProposalId>;
+}
+export interface SetDissolveTimestamp {
+  dissolve_timestamp_seconds: bigint;
+}
+export interface SetMode {
+  mode: number;
+}
+export interface Split {
+  memo: bigint;
+  amount_e8s: bigint;
+}
+export interface SplitResponse {
+  created_neuron_id: [] | [NeuronId];
+}
+export interface Tally {
+  no: bigint;
+  yes: bigint;
+  total: bigint;
+  timestamp_seconds: bigint;
+}
+export interface UpgradeSnsControlledCanister {
+  new_canister_wasm: Array<number>;
+  canister_id: [] | [Principal];
+}
+export interface WaitForQuietState {
+  current_deadline_timestamp_seconds: bigint;
+}
+export interface _SERVICE {
+  get_build_metadata: () => Promise<string>;
+  get_nervous_system_parameters: (
+    arg_0: null
+  ) => Promise<NervousSystemParameters>;
+  get_neuron: (arg_0: GetNeuron) => Promise<GetNeuronResponse>;
+  get_proposal: (arg_0: GetProposal) => Promise<GetProposalResponse>;
+  get_root_canister_status: (arg_0: null) => Promise<CanisterStatusResultV2>;
+  list_nervous_system_functions: () => Promise<ListNervousSystemFunctionsResponse>;
+  list_neurons: (arg_0: ListNeurons) => Promise<ListNeuronsResponse>;
+  list_proposals: (arg_0: ListProposals) => Promise<ListProposalsResponse>;
+  manage_neuron: (arg_0: ManageNeuron) => Promise<ManageNeuronResponse>;
+  set_mode: (arg_0: SetMode) => Promise<{}>;
+}

package/dist/candid/sns_governance.did

@@ -0,0 +1,303 @@
+// Generated from IC repo commit a1080f27696c890c19d7068f668bd062f3787564 'rs/sns/governance/canister/governance.did' by import-candid
+type AccountIdentifier = record { hash : vec nat8 };
+type Action = variant {
+  ManageNervousSystemParameters : NervousSystemParameters;
+  AddGenericNervousSystemFunction : NervousSystemFunction;
+  RemoveGenericNervousSystemFunction : nat64;
+  UpgradeSnsControlledCanister : UpgradeSnsControlledCanister;
+  Unspecified : record {};
+  ExecuteGenericNervousSystemFunction : ExecuteGenericNervousSystemFunction;
+  Motion : Motion;
+};
+type AddNeuronPermissions = record {
+  permissions_to_add : opt NeuronPermissionList;
+  principal_id : opt principal;
+};
+type Amount = record { e8s : nat64 };
+type Ballot = record {
+  vote : int32;
+  cast_timestamp_seconds : nat64;
+  voting_power : nat64;
+};
+type By = variant {
+  MemoAndController : MemoAndController;
+  NeuronId : record {};
+};
+type CanisterStatusResultV2 = record {
+  controller : principal;
+  status : CanisterStatusType;
+  freezing_threshold : nat;
+  balance : vec record { vec nat8; nat };
+  memory_size : nat;
+  cycles : nat;
+  settings : DefiniteCanisterSettingsArgs;
+  idle_cycles_burned_per_day : nat;
+  module_hash : opt vec nat8;
+};
+type CanisterStatusType = variant { stopped; stopping; running };
+type ClaimOrRefresh = record { by : opt By };
+type ClaimOrRefreshResponse = record { refreshed_neuron_id : opt NeuronId };
+type Command = variant {
+  Split : Split;
+  Follow : Follow;
+  DisburseMaturity : DisburseMaturity;
+  ClaimOrRefresh : ClaimOrRefresh;
+  Configure : Configure;
+  RegisterVote : RegisterVote;
+  MakeProposal : Proposal;
+  RemoveNeuronPermissions : RemoveNeuronPermissions;
+  AddNeuronPermissions : AddNeuronPermissions;
+  MergeMaturity : MergeMaturity;
+  Disburse : Disburse;
+};
+type Command_1 = variant {
+  Error : GovernanceError;
+  Split : SplitResponse;
+  Follow : record {};
+  DisburseMaturity : DisburseMaturityResponse;
+  ClaimOrRefresh : ClaimOrRefreshResponse;
+  Configure : record {};
+  RegisterVote : record {};
+  MakeProposal : GetProposal;
+  RemoveNeuronPermission : record {};
+  MergeMaturity : MergeMaturityResponse;
+  Disburse : DisburseResponse;
+  AddNeuronPermission : record {};
+};
+type Command_2 = variant {
+  Split : Split;
+  Follow : Follow;
+  DisburseMaturity : DisburseMaturity;
+  Configure : Configure;
+  RegisterVote : RegisterVote;
+  MakeProposal : Proposal;
+  ClaimOrRefreshNeuron : ClaimOrRefresh;
+  RemoveNeuronPermissions : RemoveNeuronPermissions;
+  AddNeuronPermissions : AddNeuronPermissions;
+  MergeMaturity : MergeMaturity;
+  Disburse : Disburse;
+};
+type Configure = record { operation : opt Operation };
+type DefaultFollowees = record { followees : vec record { nat64; Followees } };
+type DefiniteCanisterSettingsArgs = record {
+  controller : principal;
+  freezing_threshold : nat;
+  controllers : vec principal;
+  memory_allocation : nat;
+  compute_allocation : nat;
+};
+type Disburse = record {
+  to_account : opt AccountIdentifier;
+  amount : opt Amount;
+};
+type DisburseMaturity = record {
+  to_account : opt AccountIdentifier;
+  percentage_to_disburse : nat32;
+};
+type DisburseMaturityResponse = record {
+  transfer_block_height : nat64;
+  amount_disbursed_e8s : nat64;
+};
+type DisburseResponse = record { transfer_block_height : nat64 };
+type DissolveState = variant {
+  DissolveDelaySeconds : nat64;
+  WhenDissolvedTimestampSeconds : nat64;
+};
+type ExecuteGenericNervousSystemFunction = record {
+  function_id : nat64;
+  payload : vec nat8;
+};
+type Follow = record { function_id : nat64; followees : vec NeuronId };
+type Followees = record { followees : vec NeuronId };
+type FunctionType = variant {
+  NativeNervousSystemFunction : record {};
+  GenericNervousSystemFunction : GenericNervousSystemFunction;
+};
+type GenericNervousSystemFunction = record {
+  validator_canister_id : opt principal;
+  target_canister_id : opt principal;
+  validator_method_name : opt text;
+  target_method_name : opt text;
+};
+type GetNeuron = record { neuron_id : opt NeuronId };
+type GetNeuronResponse = record { result : opt Result };
+type GetProposal = record { proposal_id : opt ProposalId };
+type GetProposalResponse = record { result : opt Result_1 };
+type Governance = record {
+  root_canister_id : opt principal;
+  id_to_nervous_system_functions : vec record { nat64; NervousSystemFunction };
+  metrics : opt GovernanceCachedMetrics;
+  mode : int32;
+  parameters : opt NervousSystemParameters;
+  latest_reward_event : opt RewardEvent;
+  ledger_canister_id : opt principal;
+  proposals : vec record { nat64; ProposalData };
+  in_flight_commands : vec record { text; NeuronInFlightCommand };
+  neurons : vec record { text; Neuron };
+  genesis_timestamp_seconds : nat64;
+};
+type GovernanceCachedMetrics = record {
+  not_dissolving_neurons_e8s_buckets : vec record { nat64; float64 };
+  garbage_collectable_neurons_count : nat64;
+  neurons_with_invalid_stake_count : nat64;
+  not_dissolving_neurons_count_buckets : vec record { nat64; nat64 };
+  neurons_with_less_than_6_months_dissolve_delay_count : nat64;
+  dissolved_neurons_count : nat64;
+  total_staked_e8s : nat64;
+  total_supply_governance_tokens : nat64;
+  not_dissolving_neurons_count : nat64;
+  dissolved_neurons_e8s : nat64;
+  neurons_with_less_than_6_months_dissolve_delay_e8s : nat64;
+  dissolving_neurons_count_buckets : vec record { nat64; nat64 };
+  dissolving_neurons_count : nat64;
+  dissolving_neurons_e8s_buckets : vec record { nat64; float64 };
+  timestamp_seconds : nat64;
+};
+type GovernanceError = record { error_message : text; error_type : int32 };
+type IncreaseDissolveDelay = record {
+  additional_dissolve_delay_seconds : nat32;
+};
+type ListNervousSystemFunctionsResponse = record {
+  reserved_ids : vec nat64;
+  functions : vec NervousSystemFunction;
+};
+type ListNeurons = record {
+  of_principal : opt principal;
+  limit : nat32;
+  start_page_at : opt NeuronId;
+};
+type ListNeuronsResponse = record { neurons : vec Neuron };
+type ListProposals = record {
+  include_reward_status : vec int32;
+  before_proposal : opt ProposalId;
+  limit : nat32;
+  exclude_type : vec nat64;
+  include_status : vec int32;
+};
+type ListProposalsResponse = record { proposals : vec ProposalData };
+type ManageNeuron = record { subaccount : vec nat8; command : opt Command };
+type ManageNeuronResponse = record { command : opt Command_1 };
+type MemoAndController = record { controller : opt principal; memo : nat64 };
+type MergeMaturity = record { percentage_to_merge : nat32 };
+type MergeMaturityResponse = record {
+  merged_maturity_e8s : nat64;
+  new_stake_e8s : nat64;
+};
+type Motion = record { motion_text : text };
+type NervousSystemFunction = record {
+  id : nat64;
+  name : text;
+  description : opt text;
+  function_type : opt FunctionType;
+};
+type NervousSystemParameters = record {
+  default_followees : opt DefaultFollowees;
+  max_dissolve_delay_seconds : opt nat64;
+  max_followees_per_function : opt nat64;
+  neuron_claimer_permissions : opt NeuronPermissionList;
+  neuron_minimum_stake_e8s : opt nat64;
+  initial_voting_period : opt nat64;
+  max_neuron_age_for_age_bonus : opt nat64;
+  neuron_minimum_dissolve_delay_to_vote_seconds : opt nat64;
+  reject_cost_e8s : opt nat64;
+  max_proposals_to_keep_per_action : opt nat32;
+  max_number_of_neurons : opt nat64;
+  transaction_fee_e8s : opt nat64;
+  max_number_of_proposals_with_ballots : opt nat64;
+  reward_distribution_period_seconds : opt nat64;
+  neuron_grantable_permissions : opt NeuronPermissionList;
+  max_number_of_principals_per_neuron : opt nat64;
+};
+type Neuron = record {
+  id : opt NeuronId;
+  permissions : vec NeuronPermission;
+  maturity_e8s_equivalent : nat64;
+  cached_neuron_stake_e8s : nat64;
+  created_timestamp_seconds : nat64;
+  aging_since_timestamp_seconds : nat64;
+  dissolve_state : opt DissolveState;
+  followees : vec record { nat64; Followees };
+  neuron_fees_e8s : nat64;
+};
+type NeuronId = record { id : vec nat8 };
+type NeuronInFlightCommand = record {
+  command : opt Command_2;
+  timestamp : nat64;
+};
+type NeuronPermission = record {
+  "principal" : opt principal;
+  permission_type : vec int32;
+};
+type NeuronPermissionList = record { permissions : vec int32 };
+type Operation = variant {
+  StopDissolving : record {};
+  StartDissolving : record {};
+  IncreaseDissolveDelay : IncreaseDissolveDelay;
+  SetDissolveTimestamp : SetDissolveTimestamp;
+};
+type Proposal = record {
+  url : text;
+  title : text;
+  action : opt Action;
+  summary : text;
+};
+type ProposalData = record {
+  id : opt ProposalId;
+  payload_text_rendering : opt text;
+  action : nat64;
+  failure_reason : opt GovernanceError;
+  ballots : vec record { text; Ballot };
+  reward_event_round : nat64;
+  failed_timestamp_seconds : nat64;
+  proposal_creation_timestamp_seconds : nat64;
+  reject_cost_e8s : nat64;
+  latest_tally : opt Tally;
+  decided_timestamp_seconds : nat64;
+  proposal : opt Proposal;
+  proposer : opt NeuronId;
+  wait_for_quiet_state : opt WaitForQuietState;
+  executed_timestamp_seconds : nat64;
+};
+type ProposalId = record { id : nat64 };
+type RegisterVote = record { vote : int32; proposal : opt ProposalId };
+type RemoveNeuronPermissions = record {
+  permissions_to_remove : opt NeuronPermissionList;
+  principal_id : opt principal;
+};
+type Result = variant { Error : GovernanceError; Neuron : Neuron };
+type Result_1 = variant { Error : GovernanceError; Proposal : ProposalData };
+type RewardEvent = record {
+  actual_timestamp_seconds : nat64;
+  periods_since_genesis : nat64;
+  distributed_e8s_equivalent : nat64;
+  settled_proposals : vec ProposalId;
+};
+type SetDissolveTimestamp = record { dissolve_timestamp_seconds : nat64 };
+type SetMode = record { mode : int32 };
+type Split = record { memo : nat64; amount_e8s : nat64 };
+type SplitResponse = record { created_neuron_id : opt NeuronId };
+type Tally = record {
+  no : nat64;
+  yes : nat64;
+  total : nat64;
+  timestamp_seconds : nat64;
+};
+type UpgradeSnsControlledCanister = record {
+  new_canister_wasm : vec nat8;
+  canister_id : opt principal;
+};
+type WaitForQuietState = record { current_deadline_timestamp_seconds : nat64 };
+service : (Governance) -> {
+  get_build_metadata : () -> (text) query;
+  get_nervous_system_parameters : (null) -> (NervousSystemParameters) query;
+  get_neuron : (GetNeuron) -> (GetNeuronResponse) query;
+  get_proposal : (GetProposal) -> (GetProposalResponse) query;
+  get_root_canister_status : (null) -> (CanisterStatusResultV2);
+  list_nervous_system_functions : () -> (
+      ListNervousSystemFunctionsResponse,
+    ) query;
+  list_neurons : (ListNeurons) -> (ListNeuronsResponse) query;
+  list_proposals : (ListProposals) -> (ListProposalsResponse) query;
+  manage_neuron : (ManageNeuron) -> (ManageNeuronResponse);
+  set_mode : (SetMode) -> (record {});
+}

package/dist/candid/sns_governance.idl.d.ts

@@ -0,0 +1,2 @@
+import type { IDL } from "@dfinity/candid";
+export const idlFactory: IDL.InterfaceFactory;