@agoric/governance 0.10.4-upgrade-14-dev-0169c7e.0 → 0.10.4-upgrade-16-dev-8879538.0

package/src/types-ambient.d.ts

@@ -1,1047 +0,0 @@
-/**
- * * UNRANKED: "unranked voting" means that the voter specifies some number of
- *  positions, and is endorsing them equally.
- * * ORDER: The voter assigns ordinal numbers to some of the positions. The
- *  positions will be treated as an ordered list with no gaps.
- *
- * When voters are limited to choosing a single candidate, either UNRANKED or
- * ORDER would work. UNRANKED has a simpler representation so we use that.
- */
-type ChoiceMethod = 'unranked' | 'order' | 'plurality';
-/**
- * param_change is very specific. Survey means multiple answers are possible,
- * Election means some candidates are going to "win". It's not clear these are
- * orthogonal. The important distinction is that param_change has a structured
- * issue, while the others have a issue presented as a string.
- */
-type ElectionType = 'param_change' | 'election' | 'survey' | 'api_invocation' | 'offer_filter';
-type ParamType = import('./constants.js').ParamType;
-type QuorumRule = 'majority' | 'all' | 'no_quorum';
-type SimpleIssue = {
-    text: string;
-};
-type ParamValue = Amount | Brand | Installation | Instance | bigint | Ratio | string | import('@agoric/time/src/types').TimestampRecord | import('@agoric/time/src/types').RelativeTimeRecord | unknown;
-type ParamValueForType<T extends import("./constants.js").ParamType> = T extends 'amount' ? Amount<any> : T extends 'brand' ? Brand : T extends 'installation' ? Installation : T extends 'instance' ? Instance : T extends 'invitation' ? Amount<'set'> : T extends 'nat' ? bigint : T extends 'ratio' ? Ratio : T extends 'string' ? string : T extends 'timestamp' ? import('@agoric/time').Timestamp : T extends 'relativeTime' ? import('@agoric/time').RelativeTime : T extends 'unknown' ? unknown : never;
-/**
- * <T>
- */
-type ParamValueTyped<T extends import("./constants.js").ParamType = import("./constants.js").ParamType> = {
-    type: T;
-    value: ParamValueForType<T>;
-};
-/**
- * <T>
- */
-type GovernanceTerms<T extends import("./contractGovernance/typedParamManager.js").ParamTypesMap> = {
-    electionManager: import('@agoric/zoe/src/zoeService/utils.js').Instance<typeof import("./contractGovernor.js")['prepare']>;
-    governedParams: import('./contractGovernance/typedParamManager.js').ParamRecordsFromTypes<T & {
-        Electorate: 'invitation';
-    }>;
-};
-type Issue = SimpleIssue | ParamChangeIssue<unknown> | ApiInvocationIssue | OfferFilterIssue;
-/**
- * - QuestionSpec plus the Electorate Instance and
- *   a numerical threshold for the quorum. (The voteCounter doesn't know the
- *   size of the electorate, so the Electorate has to say what limit to enforce.)
- */
-type QuestionTerms = {
-    questionSpec: QuestionSpec;
-    quorumThreshold: number;
-    electorate: Instance;
-};
-type TextPosition = {
-    text: string;
-};
-type Position = TextPosition | ChangeParamsPosition | NoChangeParamsPosition | InvokeApiPosition | DontInvokeApiPosition | OfferFilterPosition | NoChangeOfferFilterPosition | InvokeApiPosition;
-type OutcomeRecord = {
-    question: Handle<'Question'>;
-} & ({
-    outcome: 'win';
-    position: Position;
-} | {
-    outcome: 'fail';
-    reason: 'No quorum';
-});
-type MultiOutcomeRecord = {
-    question: Handle<'Question'>;
-} & ({
-    outcome: 'win';
-    positions: Position[];
-} | {
-    outcome: 'fail';
-    reason: 'No quorum';
-});
-/**
- * Specification when requesting creation of a Question
- */
-type QuestionSpec<I extends Issue = Issue> = {
-    method: ChoiceMethod;
-    issue: I;
-    positions: Position[];
-    electionType: ElectionType;
-    maxChoices: number;
-    maxWinners: number;
-    closingRule: ClosingRule;
-    quorumRule: QuorumRule;
-    tieOutcome: Position;
-};
-type QuestionDetailsExtraProperties = {
-    /**
-     * - instance of the VoteCounter
-     */
-    counterInstance: Instance;
-    questionHandle: Handle<'Question'>;
-};
-/**
- * complete question details: questionSpec plus counter and questionHandle
- */
-type QuestionDetails = QuestionSpec & QuestionDetailsExtraProperties;
-type GovernancePair = {
-    governor: Instance;
-    governed: Instance;
-};
-type Question = {
-    getVoteCounter: () => Instance;
-    getDetails: () => QuestionDetails;
-};
-type CompleteUnrankedQuestion = {
-    questionHandle: Handle<'Question'>;
-    /**
-     * - a list of equal-weight preferred positions
-     */
-    chosen: Position[];
-};
-type CompleteWeightedBallot = {
-    questionHandle: Handle<'Question'>;
-    /**
-     * - list of positions with
-     * weights. VoteCounter may limit weights to a range or require uniqueness.
-     */
-    weighted: [Position, bigint][];
-};
-type CompleteOrderedBallot = {
-    questionHandle: Handle<'Question'>;
-    /**
-     * - ordered list of position from most preferred
-     * to least preferred
-     */
-    ordered: Position[];
-};
-type PositionCount = {
-    position: Position;
-    total: bigint;
-};
-type VoteStatistics = {
-    spoiled: bigint;
-    votes: number;
-    results: PositionCount[];
-};
-type QuorumCounter = {
-    check: (stats: VoteStatistics) => boolean;
-};
-type BuildQuestion = (questionSpec: QuestionSpec, instance: Instance) => Question;
-/**
- * - a facet that the Electorate should
- *   hold tightly. submitVote() is the core capability that allows the holder to
- *   specify the identity and choice of a voter. The voteCounter is making that
- *   available to the Electorate, which should wrap and attenuate it so each
- *   voter gets only the ability to cast their own vote at a weight specified by
- *   the electorate.
- */
-type VoteCounterCreatorFacet = {
-    submitVote: SubmitVote;
-};
-type VoteCounterPublicFacet = {
-    isOpen: () => boolean;
-    getQuestion: () => Question;
-    getOutcome: () => Promise<Position>;
-    getDetails: () => QuestionDetails;
-    getStats: () => Promise<VoteStatistics>;
-};
-type MultiVoteCounterPublicFacet = {
-    isOpen: () => boolean;
-    getQuestion: () => Question;
-    getOutcome: () => Promise<Position[]>;
-    getDetails: () => QuestionDetails;
-    getStats: () => Promise<VoteStatistics>;
-};
-/**
- * TEST ONLY: Should not be allowed to escape from contracts
- */
-type VoteCounterCloseFacet = {
-    closeVoting: () => void;
-};
-type VoteCounterFacets = {
-    publicFacet: VoteCounterPublicFacet;
-    creatorFacet: VoteCounterCreatorFacet;
-    closeFacet: VoteCounterCloseFacet;
-};
-type MultiVoteCounterFacets = {
-    publicFacet: MultiVoteCounterPublicFacet;
-    creatorFacet: VoteCounterCreatorFacet;
-    closeFacet: VoteCounterCloseFacet;
-};
-type BuildVoteCounter = (questionSpec: QuestionSpec, threshold: bigint, instance: Instance, publisher: ERef<Publisher<OutcomeRecord>>) => VoteCounterFacets;
-type BuildMultiVoteCounter = (questionSpec: QuestionSpec, threshold: bigint, instance: Instance, publisher: ERef<Publisher<MultiOutcomeRecord>>) => MultiVoteCounterFacets;
-type CompletedBallet = {
-    chosen: Position;
-    shares: bigint;
-};
-type SubmitVote = (voterHandle: Handle<'Voter'>, chosenPositions: Position[], weight?: bigint | undefined) => CompletedBallet;
-type GetOpenQuestions = () => Promise<Handle<'Question'>[]>;
-type GetQuestion = (h: Handle<'Question'>) => Promise<Question>;
-type ElectoratePublic = {
-    getQuestionSubscriber: () => Subscriber<QuestionDetails>;
-    /**
-     * ,
-     */
-    getOpenQuestions: GetOpenQuestions;
-    getInstance: () => Instance;
-    getQuestion: GetQuestion;
-};
-type ClaimsElectoratePublic = ElectoratePublic & {
-    makeVoterInvitation: () => ERef<Invitation>;
-};
-type CommitteeElectoratePublic = ElectoratePublic & {
-    getName: () => string;
-};
-type PoserFacet = {
-    addQuestion: AddQuestion;
-};
-type ElectorateCreatorFacet = {
-    /**
-     * can be used directly when the creator doesn't need any
-     * reassurance. When someone needs to connect addQuestion to the Electorate
-     * instance, getPoserInvitation() lets them get addQuestion with assurance.
-     */
-    addQuestion: AddQuestion;
-    getPoserInvitation: () => Promise<Invitation>;
-    getQuestionSubscriber: () => Subscriber<QuestionDetails>;
-    getPublicFacet: () => ElectoratePublic;
-};
-type GetVoterInvitations = {
-    getVoterInvitations: () => Invitation[];
-};
-/**
- * - a facet that the Electorate should hold
- *   tightly. It allows specification of the vote's weight, so the Electorate
- *   should distribute an attenuated wrapper that doesn't make that available!
- */
-type VoterFacet = {
-    submitVote: SubmitVote;
-};
-type ClosingRule = {
-    timer: ERef<Timer>;
-    deadline: import('@agoric/time/src/types').Timestamp;
-};
-type CloseVoting = (closingRule: ClosingRule, closeVoting: () => void) => any;
-type AddQuestionReturn = {
-    publicFacet: VoteCounterPublicFacet;
-    creatorFacet: VoteCounterCreatorFacet;
-    instance: import('@agoric/zoe/src/zoeService/utils.js').Instance<typeof import('./binaryVoteCounter.js').start>;
-    deadline: import('@agoric/time/src/types').Timestamp;
-    questionHandle: Handle<'Question'>;
-};
-type AddQuestion = (voteCounter: ERef<Installation>, questionSpec: QuestionSpec) => Promise<AddQuestionReturn>;
-type CreateQuestion = (name: string, proposedValue: ParamValue, voteCounterInstallation: Installation, contractInstance: Instance, closingRule: ClosingRule) => Promise<QuestionDetails>;
-type ParamChangeIssue<P = StandardParamPath> = {
-    spec: ParamChangesSpec<P>;
-    contract: import("@agoric/zoe/src/zoeService/utils.js").Instance<(zcf: ZCF<GovernanceTerms<{}>>) => {}>;
-};
-type ApiInvocationIssue = {
-    apiMethodName: string;
-    methodArgs: unknown[];
-};
-type OfferFilterIssue = {
-    strings: string[];
-};
-type ParamChangePositions = {
-    positive: ChangeParamsPosition;
-    negative: NoChangeParamsPosition;
-};
-/**
- * details for a question that can change a contract parameter
- */
-type ParamChangeIssueDetails = {
-    method: ChoiceMethod;
-    issue: ParamChangeIssue<unknown>;
-    positions: ParamChangePositions;
-    electionType: ElectionType;
-    maxChoices: number;
-    closingRule: ClosingRule;
-    quorumRule: QuorumRule;
-    tieOutcome: NoChangeParamsPosition;
-    /**
-     * - instance of the VoteCounter
-     */
-    counterInstance: Instance;
-    questionHandle: Handle<'Question'>;
-};
-/**
- * a Record containing
- *   keyword pairs with descriptions of parameters under governance.
- */
-type ParamStateRecord = Record<Keyword, ParamValueTyped>;
-type GovernanceSubscriptionState = {
-    current: ParamStateRecord;
-};
-/**
- * The base paramManager with typed getters
- */
-type ParamManagerBase = {
-    getParams: () => ERef<ParamStateRecord>;
-    getAmount: (name: string) => Amount;
-    getBrand: (name: string) => Brand;
-    getInstance: (name: string) => Instance;
-    getInstallation: (name: string) => Installation;
-    getInvitationAmount: (name: string) => Amount<'set'>;
-    getNat: (name: string) => bigint;
-    getRatio: (name: string) => Ratio;
-    getString: (name: string) => string;
-    getTimestamp: (name: string) => import('@agoric/time/src/types').TimestampRecord;
-    getRelativeTime: (name: string) => import('@agoric/time/src/types').RelativeTimeRecord;
-    getUnknown: (name: string) => any;
-    /**
-     * - for
-     * most types, the visible value is the same as proposedValue. For Invitations
-     * the visible value is the amount of the invitation.
-     */
-    getVisibleValue: (name: string, proposedValue: ParamValue) => ParamValue;
-    getInternalParamValue: (name: string) => Promise<Invitation>;
-    getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
-};
-type UpdateParams = (paramChanges: Record<string, ParamValue>) => Promise<void>;
-/**
- * These are typed `any` because the builder pattern of paramManager makes it very
- * complicated for the type system to know the set of param-specific functions
- * returned by `.build()`. Instead we let paramManager create the desired methods
- * and use typedParamManager to create a version that includes the static types.
- */
-type ParamManagerGettersAndUpdaters = Record<string, any>;
-/**
- * These are typed `any` because the builder pattern of paramManager makes it very
- * complicated for the type system to know the set of param-specific functions
- * returned by `.build()`. Instead we let paramManager create the desired methods
- * and use typedParamManager to create a version that includes the static types.
- */
-type AnyParamManager = ParamManagerBase & ParamManagerGettersAndUpdaters & {
-    updateParams: UpdateParams;
-};
-type ParameterNameList = Record<string, string[]>;
-type AssertParamManagerType = (type: ParamType, value: ParamValue, name: string) => any;
-/**
- * - ParamManager is a facility that governed
- *   contracts can use to manage their visible state in a way that allows the
- *   ContractGovernor to update values using governance. When paramManager is
- *   instantiated inside the contract, the contract has synchronous access to
- *   the values, and clients of the contract can verify that a ContractGovernor
- *   can change the values in a legible way.
- */
-type BuildParamManager = (paramDescriptions: Iterable<ParamValueTyped>) => AnyParamManager;
-type ChangeParamsPosition = {
-    /**
-     * one or more changes to parameters
-     */
-    changes: Record<string, ParamValue>;
-};
-type OfferFilterPosition = {
-    strings: string[];
-};
-type NoChangeOfferFilterPosition = {
-    dontUpdate: string[];
-};
-type InvokeApiPosition = {
-    apiMethodName: string;
-    methodArgs: unknown[];
-};
-type DontInvokeApiPosition = {
-    dontInvoke: string;
-};
-type NoChangeParamsPosition = {
-    /**
-     * Parameters in the proposal that this position
-     * is opposed to
-     */
-    noChange: string[];
-};
-type Governor = {
-    createQuestion: CreateQuestion;
-};
-type GovernedApis = {
-    [methodName: string]: (...args: any) => unknown;
-};
-type GovernorPublic = {
-    getElectorate: () => Promise<Instance>;
-    getGovernedContract: () => Instance;
-    validateVoteCounter: (voteCounter: Instance) => Promise<void>;
-    validateElectorate: (regP: ERef<Instance>) => Promise<void>;
-    validateTimer: (closingRule: ClosingRule) => void;
-};
-/**
- * identifier for a paramManager within a contract
- */
-type ParamKey = {
-    key: unknown;
-};
-/**
- * <P>
- */
-type ParamChangesSpec<P> = {
-    paramPath: P;
-    /**
-     * one or more changes to parameters
-     */
-    changes: Record<string, ParamValue>;
-};
-type ContractGovernanceVoteResult = {
-    /**
-     * - instance of the VoteCounter
-     */
-    instance: Instance;
-    details: ERef<QuestionDetails>;
-    /**
-     * - A promise for the result
-     * of updating the parameter value. Primarily useful for its behavior on
-     * rejection.
-     */
-    outcomeOfUpdate: Promise<ParamValue>;
-};
-type GovernorCreatorFacet<SF extends GovernableStartFn> = {
-    voteOnParamChanges: VoteOnParamChanges;
-    voteOnApiInvocation: VoteOnApiInvocation;
-    voteOnOfferFilter: VoteOnOfferFilter;
-    /**
-     * facet of the governed contract,
-     * with creator-like powers but without the tightly held ability to change
-     * param values.
-     */
-    getCreatorFacet: () => LimitedCF<SF>;
-    replaceElectorate: (poserInvitation: Invitation) => Promise<void>;
-    getAdminFacet: () => AdminFacet;
-    /**
-     * - public facet of the governed contract
-     */
-    getPublicFacet: () => GovernedPublicFacet<Awaited<ReturnType<SF>>['publicFacet']>;
-    /**
-     * - instance of the governed
-     * contract
-     */
-    getInstance: () => Instance;
-};
-type GovernedPublicFacetMethods = {
-    getSubscription: (key?: any) => StoredSubscription<GovernanceSubscriptionState>;
-    /**
-     * - get descriptions of
-     * all the governed parameters
-     */
-    getGovernedParams: (key?: any) => ERef<ParamStateRecord>;
-    getInvitationAmount: (name: string) => Amount;
-};
-type GovernedPublicFacet<PF extends {}> = PF & GovernedPublicFacetMethods;
-type LimitedCF<SF extends GovernableStartFn> = ReturnType<Awaited<ReturnType<SF>>['creatorFacet']['getLimitedCreatorFacet']>;
-/**
- * What a governed contract must return as its creatorFacet in order to be governed
- */
-type GovernedCreatorFacet<CF extends {}> = {
-    /**
-     * - allows accessing
-     * and updating governed parameters. Should only be directly accessible to the
-     * contractGovernor
-     */
-    getParamMgrRetriever: () => ParamManagerRetriever;
-    /**
-     * - the creator
-     * facet of the governed contract. Doesn't provide access to any governance
-     * functionality
-     */
-    getLimitedCreatorFacet: () => ERef<CF>;
-    getInvitation: (name: string) => Promise<Invitation>;
-    getGovernedApis: () => ERef<GovernedApis>;
-    getGovernedApiNames: () => (string | symbol)[];
-    setOfferFilter: (strings: string[]) => void;
-};
-type StandardParamPath = {
-    key: string;
-};
-type ParamManagerRetriever = {
-    get: (paramKey?: ParamKey) => AnyParamManager;
-};
-type VoteOnParamChanges<P = StandardParamPath> = (voteCounterInstallation: Installation, deadline: import('@agoric/time/src/types').Timestamp, paramSpec: ParamChangesSpec<P>) => ContractGovernanceVoteResult;
-type VoteOnApiInvocation = (apiMethodName: string, methodArgs: unknown[], voteCounterInstallation: Installation, deadline: import('@agoric/time/src/types').Timestamp) => Promise<ContractGovernanceVoteResult>;
-type VoteOnOfferFilter = (voteCounterInstallation: Installation, deadline: import('@agoric/time/src/types').Timestamp, strings: string[]) => ContractGovernanceVoteResult;
-type ParamGovernor = {
-    voteOnParamChanges: VoteOnParamChanges;
-    createdQuestion: CreatedQuestion;
-};
-type ApiGovernor = {
-    voteOnApiInvocation: VoteOnApiInvocation;
-    createdQuestion: CreatedQuestion;
-};
-type FilterGovernor = {
-    voteOnFilter: VoteOnOfferFilter;
-    createdQuestion: CreatedQuestion;
-};
-/**
- * Was this question created by this ContractGovernor?
- */
-type CreatedQuestion = (questionInstance: Instance) => boolean;
-type PositionIncluded = (positions: Position[], position: Position) => boolean;
-type GovernedContractTerms = {
-    timer: import('@agoric/time/src/types').TimerService;
-    issuerKeywordRecord: IssuerKeywordRecord;
-    privateArgs: object;
-};
-type AssertContractGovernance = (zoe: ERef<ZoeService>, allegedGoverned: import("@agoric/zoe/src/zoeService/utils.js").Instance<(zcf: ZCF<GovernanceTerms<{}>>) => {}>, allegedGovernor: Instance, contractGovernorInstallation: Installation<(<SF extends GovernableStartFn>(zcf: ZCF<{
-    timer: import("@agoric/time/src/types").TimerService;
-    governedContractInstallation: Installation<SF>;
-    governed: {
-        issuerKeywordRecord: IssuerKeywordRecord;
-        /**
-         * @typedef {object} CompleteOrderedBallot
-         * @property {Handle<'Question'>} questionHandle
-         * @property {Position[]} ordered - ordered list of position from most preferred
-         *   to least preferred
-         */
-        /**
-         * @typedef {object} PositionCount
-         * @property {Position} position
-         * @property {bigint} total
-         */
-        /**
-         * @typedef {object} VoteStatistics
-         * @property {bigint} spoiled
-         * @property {number} votes
-         * @property {PositionCount[]} results
-         */
-        /**
-         * @typedef {object} QuorumCounter
-         * @property {(stats: VoteStatistics) => boolean} check
-         */
-        /**
-         * @callback BuildQuestion
-         * @param {QuestionSpec} questionSpec
-         * @param {Instance} instance - voteCounter instance
-         * @returns {Question}
-         */
-        /**
-         * @typedef {object} VoteCounterCreatorFacet - a facet that the Electorate should
-         *   hold tightly. submitVote() is the core capability that allows the holder to
-         *   specify the identity and choice of a voter. The voteCounter is making that
-         *   available to the Electorate, which should wrap and attenuate it so each
-         *   voter gets only the ability to cast their own vote at a weight specified by
-         *   the electorate.
-         * @property {SubmitVote} submitVote
-         */
-        /**
-         * @typedef {object} VoteCounterPublicFacet
-         * @property {() => boolean} isOpen
-         * @property {() => Question} getQuestion
-         * @property {() => Promise<Position>} getOutcome
-         * @property {() => QuestionDetails} getDetails
-         * @property {() => Promise<VoteStatistics>} getStats
-         */
-        /**
-         * @typedef {object} MultiVoteCounterPublicFacet
-         * @property {() => boolean} isOpen
-         * @property {() => Question} getQuestion
-         * @property {() => Promise<Position[]>} getOutcome
-         * @property {() => QuestionDetails} getDetails
-         * @property {() => Promise<VoteStatistics>} getStats
-         */
-        /**
-         * @typedef {object} VoteCounterCloseFacet
-         *   TEST ONLY: Should not be allowed to escape from contracts
-         * @property {() => void} closeVoting
-         */
-        /**
-         * @typedef {object} VoteCounterFacets
-         * @property {VoteCounterPublicFacet} publicFacet
-         * @property {VoteCounterCreatorFacet} creatorFacet
-         * @property {VoteCounterCloseFacet} closeFacet
-         */
-        /**
-         * @typedef {object} MultiVoteCounterFacets
-         * @property {MultiVoteCounterPublicFacet} publicFacet
-         * @property {VoteCounterCreatorFacet} creatorFacet
-         * @property {VoteCounterCloseFacet} closeFacet
-         */
-        /**
-         * @callback BuildVoteCounter
-         * @param {QuestionSpec} questionSpec
-         * @param {bigint} threshold - questionSpec includes quorumRule; the electorate
-         *    converts that to a number that the counter can enforce.
-         * @param {Instance} instance
-         * @param {ERef<Publisher<OutcomeRecord>>} publisher
-         * @returns {VoteCounterFacets}
-         */
-        /**
-         * @callback BuildMultiVoteCounter
-         * @param {QuestionSpec} questionSpec
-         * @param {bigint} threshold - questionSpec includes quorumRule; the electorate
-         *    converts that to a number that the counter can enforce.
-         * @param {Instance} instance
-         * @param {ERef<Publisher<MultiOutcomeRecord>>} publisher
-         * @returns {MultiVoteCounterFacets}
-         */
-        /**
-         * @typedef {object} CompletedBallet
-         * @property {Position} chosen
-         * @property {bigint} shares
-         */
-        /**
-         * @callback SubmitVote
-         * @param {Handle<'Voter'>} voterHandle
-         * @param {Position[]} chosenPositions
-         * @param {bigint} [weight]
-         * @returns {CompletedBallet}
-         */
-        /**
-         * @callback GetOpenQuestions
-         * @returns {Promise<Handle<'Question'>[]>}
-         */
-        /**
-         * @callback GetQuestion
-         * @param {Handle<'Question'>} h
-         * @returns {Promise<Question>}
-         */
-        /**
-         * @typedef {object} ElectoratePublic
-         * @property {() => Subscriber<QuestionDetails>} getQuestionSubscriber
-         * @property {GetOpenQuestions} getOpenQuestions,
-         * @property {() => Instance} getInstance
-         * @property {GetQuestion} getQuestion
-         */
-        /**
-         * @typedef { ElectoratePublic & {makeVoterInvitation: () => ERef<Invitation>} } ClaimsElectoratePublic
-         * @typedef { ElectoratePublic & {getName: () => string} } CommitteeElectoratePublic
-         */
-        /**
-         * @typedef {object} PoserFacet
-         * @property {AddQuestion} addQuestion
-         */
-        /**
-         * @typedef {object} ElectorateCreatorFacet
-         * @property {AddQuestion} addQuestion can be used directly when the creator doesn't need any
-         *  reassurance. When someone needs to connect addQuestion to the Electorate
-         *  instance, getPoserInvitation() lets them get addQuestion with assurance.
-         * @property {() => Promise<Invitation>} getPoserInvitation
-         * @property {() => Subscriber<QuestionDetails>} getQuestionSubscriber
-         * @property {() => ElectoratePublic} getPublicFacet
-         */
-        /**
-         * @typedef {object} GetVoterInvitations
-         * @property {() => Invitation[]} getVoterInvitations
-         */
-        /**
-         * @typedef {object} VoterFacet - a facet that the Electorate should hold
-         *   tightly. It allows specification of the vote's weight, so the Electorate
-         *   should distribute an attenuated wrapper that doesn't make that available!
-         * @property {SubmitVote} submitVote
-         */
-        /**
-         * @typedef {object} ClosingRule
-         * @property {ERef<Timer>} timer
-         * @property {import('@agoric/time/src/types').Timestamp} deadline
-         */
-        /**
-         * @callback CloseVoting
-         * @param {ClosingRule} closingRule
-         * @param {() => void} closeVoting
-         */
-        /**
-         * @typedef {object} AddQuestionReturn
-         * @property {VoteCounterPublicFacet} publicFacet
-         * @property {VoteCounterCreatorFacet} creatorFacet
-         * @property {import('@agoric/zoe/src/zoeService/utils.js').Instance<typeof import('./binaryVoteCounter.js').start>} instance
-         * @property {import('@agoric/time/src/types').Timestamp} deadline
-         * @property {Handle<'Question'>} questionHandle
-         */
-        /**
-         * @callback AddQuestion
-         * @param {ERef<Installation>} voteCounter
-         * @param {QuestionSpec} questionSpec
-         * @returns {Promise<AddQuestionReturn>}
-         */
-        /**
-         * @callback CreateQuestion
-         *
-         * @param {string} name - The name of the parameter to change
-         * @param {ParamValue} proposedValue - the proposed value for the named
-         *   parameter
-         * @param {Installation} voteCounterInstallation - the voteCounter to
-         *   instantiate to count votes. Expected to be a binaryVoteCounter. Other
-         *   voteCounters might be added here, or might require separate governors.
-         *   under management so users can trace it back and see that it would use
-         *   this electionManager to manage parameters
-         * @param {Instance} contractInstance - include the instance of the contract
-         * @param {ClosingRule} closingRule - deadline and timer for closing voting
-         * @returns {Promise<QuestionDetails>}
-         */
-        /**
-         * @template [P=StandardParamPath] path for a paramManagerRetriever
-         * @typedef {object} ParamChangeIssue
-         * @property {ParamChangesSpec<P>} spec
-         * @property {import('@agoric/zoe/src/zoeService/utils.js').Instance<(zcf: ZCF<GovernanceTerms<{}>>) => {}>} contract
-         */
-        /**
-         * @typedef {object} ApiInvocationIssue
-         * @property {string} apiMethodName
-         * @property {unknown[]} methodArgs
-         */
-        /**
-         * @typedef {object} OfferFilterIssue
-         * @property {string[]} strings
-         */
-        /**
-         * @typedef {object} ParamChangePositions
-         * @property {ChangeParamsPosition} positive
-         * @property {NoChangeParamsPosition} negative
-         */
-        /**
-         * @typedef {object} ParamChangeIssueDetails
-         *    details for a question that can change a contract parameter
-         * @property {ChoiceMethod} method
-         * @property {ParamChangeIssue<unknown>} issue
-         * @property {ParamChangePositions} positions
-         * @property {ElectionType} electionType
-         * @property {number} maxChoices
-         * @property {ClosingRule} closingRule
-         * @property {QuorumRule} quorumRule
-         * @property {NoChangeParamsPosition} tieOutcome
-         * @property {Instance} counterInstance - instance of the VoteCounter
-         * @property {Handle<'Question'>} questionHandle
-         */
-        /**
-         * @typedef {Record<Keyword, ParamValueTyped>} ParamStateRecord a Record containing
-         *   keyword pairs with descriptions of parameters under governance.
-         */
-        /** @typedef {{current: ParamStateRecord}} GovernanceSubscriptionState */
-        /**
-         * @typedef {object} ParamManagerBase The base paramManager with typed getters
-         * @property {() => ERef<ParamStateRecord>} getParams
-         * @property {(name: string) => Amount} getAmount
-         * @property {(name: string) => Brand} getBrand
-         * @property {(name: string) => Instance} getInstance
-         * @property {(name: string) => Installation} getInstallation
-         * @property {(name: string) => Amount<'set'>} getInvitationAmount
-         * @property {(name: string) => bigint} getNat
-         * @property {(name: string) => Ratio} getRatio
-         * @property {(name: string) => string} getString
-         * @property {(name: string) => import('@agoric/time/src/types').TimestampRecord} getTimestamp
-         * @property {(name: string) => import('@agoric/time/src/types').RelativeTimeRecord} getRelativeTime
-         * @property {(name: string) => any} getUnknown
-         * @property {(name: string, proposedValue: ParamValue) => ParamValue} getVisibleValue - for
-         *   most types, the visible value is the same as proposedValue. For Invitations
-         *   the visible value is the amount of the invitation.
-         * @property {(name: string) => Promise<Invitation>} getInternalParamValue
-         * @property {() => StoredSubscription<GovernanceSubscriptionState>} getSubscription
-         */
-        /**
-         * @callback UpdateParams
-         * @param {Record<string,ParamValue>} paramChanges
-         * @returns {Promise<void>}
-         */
-        /**
-         * These are typed `any` because the builder pattern of paramManager makes it very
-         * complicated for the type system to know the set of param-specific functions
-         * returned by `.build()`. Instead we let paramManager create the desired methods
-         * and use typedParamManager to create a version that includes the static types.
-         *
-         * @typedef {Record<string, any>} ParamManagerGettersAndUpdaters
-         * @typedef {ParamManagerBase & ParamManagerGettersAndUpdaters & {updateParams: UpdateParams}} AnyParamManager
-         */
-        /**
-         * @typedef {Record<string, string[]>} ParameterNameList
-         */
-        /**
-         * @callback AssertParamManagerType
-         * @param {ParamType} type
-         * @param {ParamValue} value
-         * @param {string} name
-         */
-        /**
-         * @callback BuildParamManager - ParamManager is a facility that governed
-         *   contracts can use to manage their visible state in a way that allows the
-         *   ContractGovernor to update values using governance. When paramManager is
-         *   instantiated inside the contract, the contract has synchronous access to
-         *   the values, and clients of the contract can verify that a ContractGovernor
-         *   can change the values in a legible way.
-         * @param {Iterable<ParamValueTyped>} paramDescriptions
-         * @returns {AnyParamManager}
-         */
-        /**
-         * @typedef {object} ChangeParamsPosition
-         * @property {Record<string,ParamValue>} changes one or more changes to parameters
-         */
-        /**
-         * @typedef {object} OfferFilterPosition
-         * @property {string[]} strings
-         */
-        /**
-         * @typedef {object} NoChangeOfferFilterPosition
-         * @property {string[]} dontUpdate
-         */
-        /**
-         * @typedef {object} InvokeApiPosition
-         * @property {string} apiMethodName
-         * @property {unknown[]} methodArgs
-         */
-        /**
-         * @typedef {object} DontInvokeApiPosition
-         * @property {string} dontInvoke
-         */
-        /**
-         * @typedef {object} NoChangeParamsPosition
-         * @property {string[]} noChange Parameters in the proposal that this position
-         *   is opposed to
-         */
-        /**
-         * @typedef {object} Governor
-         * @property {CreateQuestion} createQuestion
-         */
-        /** @typedef {{ [methodName: string]: (...args: any) => unknown }} GovernedApis */
-        /**
-         * @typedef {object} GovernorPublic
-         * @property {() => Promise<Instance>} getElectorate
-         * @property {() => Instance} getGovernedContract
-         * @property {(voteCounter: Instance) => Promise<void>} validateVoteCounter
-         * @property {(regP: ERef<Instance>) => Promise<void>} validateElectorate
-         * @property {(closingRule: ClosingRule) => void} validateTimer
-         */
-        /**
-         * @typedef {object} ParamKey identifier for a paramManager within a contract
-         * @property {unknown} key
-         */
-        /**
-         * Description of a set of coordinated changes for a ParamManager
-         *
-         * @template P path for a paramManagerRetriever
-         * @typedef {object} ParamChangesSpec<P>
-         * @property {P} paramPath
-         * @property {Record<string, ParamValue>} changes one or more changes to parameters
-         */
-        /**
-         * @typedef {object} ContractGovernanceVoteResult
-         * @property {Instance} instance - instance of the VoteCounter
-         * @property {ERef<QuestionDetails>} details
-         * @property {Promise<ParamValue>} outcomeOfUpdate - A promise for the result
-         *    of updating the parameter value. Primarily useful for its behavior on
-         *    rejection.
-         */
-        /**
-         * @template {GovernableStartFn} SF Start function of governed contract
-         * @typedef {object} GovernorCreatorFacet
-         * @property {VoteOnParamChanges} voteOnParamChanges
-         * @property {VoteOnApiInvocation} voteOnApiInvocation
-         * @property {VoteOnOfferFilter} voteOnOfferFilter
-         * @property {() => LimitedCF<SF>} getCreatorFacet facet of the governed contract,
-         *   with creator-like powers but without the tightly held ability to change
-         *   param values.
-         * @property {(poserInvitation: Invitation) => Promise<void>} replaceElectorate
-         * @property {() => AdminFacet} getAdminFacet
-         * @property {() => GovernedPublicFacet<Awaited<ReturnType<SF>>['publicFacet']>} getPublicFacet - public facet of the governed contract
-         * @property {() => Instance} getInstance - instance of the governed
-         *   contract
-         */
-        /**
-         * @typedef GovernedPublicFacetMethods
-         * @property {(key?: any) => StoredSubscription<GovernanceSubscriptionState>} getSubscription
-         * @property {(key?: any) => ERef<ParamStateRecord>} getGovernedParams - get descriptions of
-         *   all the governed parameters
-         * @property {(name: string) => Amount} getInvitationAmount
-         */
-        /**
-         * @template {{}} PF Public facet
-         * @typedef {PF & GovernedPublicFacetMethods} GovernedPublicFacet
-         */
-        /**
-         * @template {GovernableStartFn} SF
-         * @typedef {ReturnType<Awaited<ReturnType<SF>>['creatorFacet']['getLimitedCreatorFacet']>} LimitedCF
-         */
-        /**
-         * @template {{}} CF creator facet
-         * @typedef GovernedCreatorFacet
-         * What a governed contract must return as its creatorFacet in order to be governed
-         * @property {() => ParamManagerRetriever} getParamMgrRetriever - allows accessing
-         *   and updating governed parameters. Should only be directly accessible to the
-         *   contractGovernor
-         * @property {() => ERef<CF>} getLimitedCreatorFacet - the creator
-         *   facet of the governed contract. Doesn't provide access to any governance
-         *   functionality
-         * @property {(name: string) => Promise<Invitation>} getInvitation
-         * @property {() => ERef<GovernedApis>} getGovernedApis
-         * @property {() => (string | symbol)[]} getGovernedApiNames
-         * @property {(strings: string[]) => void} setOfferFilter
-         */
-        /**
-         * @typedef {{key: string}} StandardParamPath
-         */
-        /**
-         * @typedef {object} ParamManagerRetriever
-         * @property {(paramKey?: ParamKey) => AnyParamManager} get
-         */
-        /**
-         * @template [P=StandardParamPath]
-         *
-         * @callback VoteOnParamChanges
-         * @param {Installation} voteCounterInstallation
-         * @param {import('@agoric/time/src/types').Timestamp} deadline
-         * @param {ParamChangesSpec<P>} paramSpec
-         * @returns {ContractGovernanceVoteResult}
-         */
-        /**
-         * @callback VoteOnApiInvocation
-         * @param {string} apiMethodName
-         * @param {unknown[]} methodArgs
-         * @param {Installation} voteCounterInstallation
-         * @param {import('@agoric/time/src/types').Timestamp} deadline
-         * @returns {Promise<ContractGovernanceVoteResult>}
-         */
-        /**
-         * @callback VoteOnOfferFilter
-         * @param {Installation} voteCounterInstallation
-         * @param {import('@agoric/time/src/types').Timestamp} deadline
-         * @param {string[]} strings
-         * @returns {ContractGovernanceVoteResult}
-         */
-        /**
-         * @typedef {object} ParamGovernor
-         * @property {VoteOnParamChanges} voteOnParamChanges
-         * @property {CreatedQuestion} createdQuestion
-         */
-        /**
-         * @typedef {object} ApiGovernor
-         * @property {VoteOnApiInvocation} voteOnApiInvocation
-         * @property {CreatedQuestion} createdQuestion
-         */
-        /**
-         * @typedef {object} FilterGovernor
-         * @property {VoteOnOfferFilter} voteOnFilter
-         * @property {CreatedQuestion} createdQuestion
-         */
-        /**
-         * @callback CreatedQuestion
-         *   Was this question created by this ContractGovernor?
-         * @param {Instance} questionInstance
-         * @returns {boolean}
-         */
-        /**
-         * @callback PositionIncluded
-         * @param {Position[]} positions
-         * @param {Position} position
-         * @returns {boolean}
-         */
-        /**
-         * @typedef {object} GovernedContractTerms
-         * @property {import('@agoric/time/src/types').TimerService} timer
-         * @property {IssuerKeywordRecord} issuerKeywordRecord
-         * @property {object} privateArgs
-         */
-        /**
-         * @callback AssertContractGovernance
-         *
-         * @param {ERef<ZoeService>} zoe
-         * @param {import('@agoric/zoe/src/zoeService/utils.js').Instance<(zcf: ZCF<GovernanceTerms<{}>>) => {}>} allegedGoverned
-         * @param {Instance} allegedGovernor
-         * @param {Installation<import('@agoric/governance/src/contractGovernor.js').prepare>} contractGovernorInstallation
-         * @returns {Promise<GovernancePair>}
-         */
-        /**
-         * @callback AssertContractElectorate - assert that the contract uses the
-         *   electorate
-         *
-         * @param {ERef<ZoeService>} zoe
-         * @param {Instance} allegedGovernor
-         * @param {Instance} allegedElectorate
-         */
-        /**
-         * @typedef {import('@agoric/zoe/src/zoeService/utils.js').ContractStartFunction
-         * & ((zcf?: any, pa?: any, baggage?: any) => ERef<{creatorFacet: GovernedCreatorFacet<{}>, publicFacet: GovernedPublicFacet<{}>}>)} GovernableStartFn
-         */
-        /**
-         * @typedef {import('./contractGovernor.js')['prepare']} GovernorSF
-         */
-        /**
-         * @see {StartedInstanceKit}
-         * @template {ERef<Installation<GovernableStartFn>>} I
-         * @typedef GovernorStartedInstallationKit
-         * Same result as StartedInstanceKit but:
-         * - typed for contractGovernor installation being started by Zoe. (It in turn starts the governed contract.)
-         * - parameterized by Installation instead of StartFunction
-         * @property {import('@agoric/zoe/src/zoeService/utils.js').Instance<GovernorSF>} instance
-         * @property {AdminFacet} adminFacet
-         * @property {GovernorCreatorFacet<InstallationStart<Awaited<I>>>} creatorFacet
-         * @property {GovernorPublic} publicFacet
-         */
-        /**
-         * @see {StartedInstanceKit}
-         * @template {GovernableStartFn} SF
-         * @typedef GovernanceFacetKit
-         * Akin to StartedInstanceKit but designed for the results of starting governed contracts. Used in bootstrap space.
-         * @property {AdminFacet} adminFacet of the governed contract
-         * @property {LimitedCF<SF>} creatorFacet creator-like facet within the governed contract (without the powers the governor needs)
-         * @property {GovernorCreatorFacet<SF>} governorCreatorFacet of the governing contract
-         * @property {AdminFacet} governorAdminFacet of the governing contract
-         * @property {Awaited<ReturnType<SF>>['publicFacet']} publicFacet
-         * @property {Instance} instance
-         * @property {Instance} governor
-         */
-        terms: {
-            governedParams: {
-                Electorate: import("./contractGovernance/typedParamManager.js").InvitationParam;
-            };
-        };
-        label?: string | undefined;
-    };
-}>, privateArgs: {
-    governed: Record<string, unknown>;
-}, baggage: MapStore<string, unknown>) => Promise<{
-    creatorFacet: GovernorCreatorFacet<SF>;
-    publicFacet: GovernorPublic;
-}>)>) => Promise<GovernancePair>;
-/**
- * - assert that the contract uses the
- *   electorate
- */
-type AssertContractElectorate = (zoe: ERef<ZoeService>, allegedGovernor: Instance, allegedElectorate: Instance) => any;
-type GovernableStartFn = import("@agoric/zoe/src/zoeService/utils.js").ContractStartFunction & ((zcf?: any, pa?: any, baggage?: any) => ERef<{
-    creatorFacet: GovernedCreatorFacet<{}>;
-    publicFacet: GovernedPublicFacet<{}>;
-}>);
-type GovernorSF = typeof import("./contractGovernor.js")['prepare'];
-/**
- * Same result as StartedInstanceKit but:
- * - typed for contractGovernor installation being started by Zoe. (It in turn starts the governed contract.)
- * - parameterized by Installation instead of StartFunction
- */
-type GovernorStartedInstallationKit<I extends ERef<Installation<GovernableStartFn>>> = {
-    instance: import('@agoric/zoe/src/zoeService/utils.js').Instance<GovernorSF>;
-    adminFacet: AdminFacet;
-    creatorFacet: GovernorCreatorFacet<InstallationStart<Awaited<I>>>;
-    publicFacet: GovernorPublic;
-};
-/**
- * Akin to StartedInstanceKit but designed for the results of starting governed contracts. Used in bootstrap space.
- */
-type GovernanceFacetKit<SF extends GovernableStartFn> = {
-    /**
-     * of the governed contract
-     */
-    adminFacet: AdminFacet;
-    /**
-     * creator-like facet within the governed contract (without the powers the governor needs)
-     */
-    creatorFacet: LimitedCF<SF>;
-    /**
-     * of the governing contract
-     */
-    governorCreatorFacet: GovernorCreatorFacet<SF>;
-    /**
-     * of the governing contract
-     */
-    governorAdminFacet: AdminFacet;
-    publicFacet: Awaited<ReturnType<SF>>['publicFacet'];
-    instance: Instance;
-    governor: Instance;
-};
-//# sourceMappingURL=types-ambient.d.ts.map