@agoric/governance 0.10.4-dev-fa844b5.0 → 0.10.4-dev-21fe8d9.0

package/src/contractGovernorKit.d.ts

@@ -0,0 +1,46 @@
+export function prepareContractGovernorKit(baggage: import('@agoric/vat-data').Baggage, powers: {
+    timer: import('@agoric/time').TimerService;
+    zoe: ERef<ZoeService>;
+}): (startedInstanceKit: import("@agoric/zoe/src/zoeService/utils.js").StartedInstanceKit<GovernableStartFn>, limitedCreatorFacet: any) => import("@endo/exo").GuardedKit<{
+    helper: {
+        /** @type {() => Promise<Instance>} */
+        getElectorateInstance(): Promise<Instance>;
+        /** @type {() => Promise<PoserFacet>} */
+        getUpdatedPoserFacet(): Promise<PoserFacet>;
+        provideApiGovernance(): Promise<import("./types.js").ApiGovernor>;
+        provideFilterGovernance(): import("./types.js").FilterGovernor;
+        provideParamGovernance(): import("./types.js").ParamGovernor;
+    };
+    creator: {
+        /**
+         * @param {Invitation} poserInvitation
+         * @returns {Promise<void>}
+         */
+        replaceElectorate(poserInvitation: Invitation): Promise<void>;
+        /** @type {VoteOnParamChanges} */
+        voteOnParamChanges(voteCounterInstallation: Installation<any>, deadline: import("@agoric/time").Timestamp, paramSpec: import("./types.js").ParamChangesSpec<import("./types.js").StandardParamPath>): Promise<import("./types.js").ContractGovernanceVoteResult>;
+        /** @type {VoteOnApiInvocation} */
+        voteOnApiInvocation(apiMethodName: string, methodArgs: unknown[], voteCounterInstallation: Installation<any>, deadline: import("@agoric/time").Timestamp): Promise<import("./types.js").ContractGovernanceVoteResult>;
+        /** @type {VoteOnOfferFilter} */
+        voteOnOfferFilter(voteCounterInstallation: Installation<any>, deadline: import("@agoric/time").Timestamp, strings: string[]): Promise<import("./types.js").ContractGovernanceVoteResult>;
+        getCreatorFacet(): any;
+        getAdminFacet(): import("@agoric/zoe/src/zoeService/utils.js").AdminFacet<GovernableStartFn>;
+        getInstance(): import("@agoric/zoe/src/zoeService/utils.js").Instance<GovernableStartFn>;
+        getPublicFacet(): import("./types.js").GovernedPublicFacetMethods;
+    };
+    public: {
+        getElectorate(): Promise<Instance>;
+        getGovernedContract(): import("@agoric/zoe/src/zoeService/utils.js").Instance<GovernableStartFn>;
+        /** @param {Instance} counter */
+        validateVoteCounter(counter: Instance): Promise<void>;
+        /** @param {Instance} regP */
+        validateElectorate(regP: Instance): Promise<void>;
+        /** @param {ClosingRule} closingRule */
+        validateTimer(closingRule: ClosingRule): void;
+    };
+}>;
+export type ContractGovernorKit = ReturnType<ReturnType<typeof prepareContractGovernorKit>>;
+import type { GovernableStartFn } from './types.js';
+import type { PoserFacet } from './types.js';
+import type { ClosingRule } from './types.js';
+//# sourceMappingURL=contractGovernorKit.d.ts.map

package/src/contractGovernorKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contractGovernorKit.d.ts","sourceRoot":"","sources":["contractGovernorKit.js"],"names":[],"mappings":"AAkEO,oDANI,OAAO,kBAAkB,EAAE,OAAO;WAEjC,OAAO,cAAc,EAAE,YAAY;;;;QAmCvC,sCAAsC;iCAArB,QAAQ,QAAQ,CAAC;QAOlC,wCAAwC;;;;;;;QAmExC;;;WAGG;2CAFQ,UAAU,GACR,QAAQ,IAAI,CAAC;QAgB1B,iCAAiC;;QAOjC,kCAAkC;;QAelC,gCAAgC;;;;;;;;;;QA4BhC,gCAAgC;qCAApB,QAAQ;QAepB,6BAA6B;iCAAjB,QAAQ;QAWpB,uCAAuC;;;GAY9C;kCAEa,WAAW,WAAW,iCAAiC,CAAC,CAAC;uCApQ2K,YAAY;gCAAZ,YAAY;iCAAZ,YAAY"}

package/src/contractGovernorKit.js

@@ -16,6 +16,10 @@ import {
 } from './contractGovernance/governParam.js';
 import { ClosingRuleShape, ParamChangesSpecShape } from './typeGuards.js';
 
+/**
+ * @import {VoteCounterCreatorFacet, VoteCounterPublicFacet, QuestionSpec, OutcomeRecord, AddQuestion, AddQuestionReturn, ClosingRule, GovernableStartFn, LimitedCF, PoserFacet, VoteOnApiInvocation, VoteOnOfferFilter, VoteOnParamChanges} from './types.js';
+ */
+
 const trace = makeTracer('CGK', false);
 
 const ContractGovernorKitI = {

package/src/contractHelper.d.ts

@@ -0,0 +1,121 @@
+export const GOVERNANCE_STORAGE_KEY: "governance";
+export function validateElectorate(zcf: ZCF<GovernanceTerms<{}>>, paramManager: import('./contractGovernance/typedParamManager.js').TypedParamManager<any>): Promise<void>;
+import type { GovernanceTerms } from './types.js';
+/**
+ * Helper for the 90% of contracts that will have only a single set of
+ * parameters. Using this for managed parameters, a contract only has to
+ *
+ * - Define the parameter template, which includes name, type and value
+ * - Add any methods needed in the public and creator facets.
+ *
+ * It's also crucial that the governed contract not interact with the product of
+ * makeGovernorFacet(). The wrapped creatorFacet has the power to change
+ * parameter values, and the governance guarantees only hold if they're not used
+ * directly by the governed contract.
+ *
+ * @template {import('./contractGovernance/typedParamManager.js').ParamTypesMap} M
+ *   Map of types of custom governed terms
+ * @param {ZCF<GovernanceTerms<M>>} zcf
+ * @param {Invitation} initialPoserInvitation
+ * @param {M} paramTypesMap
+ * @param {ERef<StorageNode>} [storageNode]
+ * @param {ERef<Marshaller>} [marshaller]
+ */
+export function handleParamGovernance<M extends import("./contractGovernance/typedParamManager.js").ParamTypesMap>(zcf: ZCF<GovernanceTerms<M>>, initialPoserInvitation: Invitation, paramTypesMap: M, storageNode?: ERef<StorageNode> | undefined, marshaller?: ERef<Marshaller<unknown>> | undefined): {
+    publicMixin: {
+        getAmount: (name: string) => globalThis.Amount;
+        getBrand: (name: string) => globalThis.Brand;
+        getInstance: (name: string) => Instance;
+        getInstallation: (name: string) => Installation<any>;
+        getInvitationAmount: (name: string) => globalThis.Amount<"set">;
+        getNat: (name: string) => bigint;
+        getRatio: (name: string) => Ratio;
+        getString: (name: string) => string;
+        getTimestamp: (name: string) => import("@agoric/time").TimestampRecord;
+        getRelativeTime: (name: string) => import("@agoric/time").RelativeTimeRecord;
+        getUnknown: (name: string) => any;
+        getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
+        getGovernedParams: () => ERef<import("./types.js").ParamStateRecord>;
+    };
+    augmentPublicFacet: <PF extends {}>(originalPublicFacet: PF) => GovernedPublicFacet<PF>;
+    augmentVirtualPublicFacet: <OPF extends {}>(originalPublicFacet: OPF) => OPF & {
+        getBrand: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getInstallation: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getInstance: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getAmount: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getInvitationAmount: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getNat: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getRatio: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getString: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getTimestamp: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getRelativeTime: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getUnknown: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
+        getGovernedParams: () => ERef<import("./types.js").ParamStateRecord>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, OPF & {
+        getBrand: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getInstallation: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getInstance: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getAmount: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getInvitationAmount: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getNat: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getRatio: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getString: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getTimestamp: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getRelativeTime: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getUnknown: import("@agoric/swingset-liveslots").PlusContext<never, ((name: string) => globalThis.Amount<"set">) | ((name: string) => globalThis.Amount) | ((name: string) => globalThis.Brand) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time").TimestampRecord) | ((name: string) => import("@agoric/time").RelativeTimeRecord) | ((name: string) => any)>;
+        getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
+        getGovernedParams: () => ERef<import("./types.js").ParamStateRecord>;
+    }>;
+    makeGovernorFacet: <CF extends {}>(originalCreatorFacet: CF, governedApis?: {} | undefined) => GovernedCreatorFacet<CF>;
+    makeFarGovernorFacet: <CF_1 extends {}>(limitedCreatorFacet: CF_1, governedApis?: Record<string, (...any: any[]) => unknown> | undefined) => GovernedCreatorFacet<CF_1>;
+    makeVirtualGovernorFacet: <LCF extends {
+        [methodName: string]: (context?: unknown, ...rest: unknown[]) => unknown;
+    }>(limitedCreatorFacet: LCF) => {
+        governorFacet: import("@agoric/swingset-liveslots").FunctionsPlusContext<unknown, GovernedCreatorFacet<LCF>>;
+        limitedCreatorFacet: LCF;
+    };
+    makeDurableGovernorFacet: <CF_2>(baggage: import('@agoric/vat-data').Baggage, limitedCreatorFacet: CF_2, governedApis?: Record<string, (...any: any[]) => unknown> | undefined) => {
+        governorFacet: import("@endo/exo").Guarded<{
+            getParamMgrRetriever: () => {
+                get: () => import("./contractGovernance/typedParamManager.js").TypedParamManager<M & {
+                    Electorate: "invitation";
+                }>;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                get: () => import("./contractGovernance/typedParamManager.js").TypedParamManager<M & {
+                    Electorate: "invitation";
+                }>;
+            }>;
+            getInvitation: (name: any) => Promise<Invitation<unknown, undefined>>;
+            getLimitedCreatorFacet: () => CF_2;
+            /** @type {() => GovernedApis} */
+            getGovernedApis: () => GovernedApis;
+            getGovernedApiNames: () => string[];
+            setOfferFilter: (strings: any) => Promise<void>;
+        }>;
+        limitedCreatorFacet: CF_2;
+    };
+    params: import("./contractGovernance/typedParamManager.js").Getters<M & {
+        Electorate: "invitation";
+    }>;
+};
+export namespace publicMixinAPI {
+    let getSubscription: import("@endo/patterns").MethodGuard;
+    let getGovernedParams: import("@endo/patterns").MethodGuard;
+    let getAmount: import("@endo/patterns").MethodGuard;
+    let getBrand: import("@endo/patterns").MethodGuard;
+    let getInstance: import("@endo/patterns").MethodGuard;
+    let getInstallation: import("@endo/patterns").MethodGuard;
+    let getInvitationAmount: import("@endo/patterns").MethodGuard;
+    let getNat: import("@endo/patterns").MethodGuard;
+    let getRatio: import("@endo/patterns").MethodGuard;
+    let getString: import("@endo/patterns").MethodGuard;
+    let getTimestamp: import("@endo/patterns").MethodGuard;
+    let getRelativeTime: import("@endo/patterns").MethodGuard;
+    let getUnknown: import("@endo/patterns").MethodGuard;
+}
+import type { GovernanceSubscriptionState } from './types.js';
+import type { GovernedPublicFacet } from './types.js';
+import type { GovernedCreatorFacet } from './types.js';
+import type { GovernedApis } from './types.js';
+//# sourceMappingURL=contractHelper.d.ts.map

package/src/contractHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contractHelper.d.ts","sourceRoot":"","sources":["contractHelper.js"],"names":[],"mappings":"AAkBA,kDAAmD;AAsB5C,gFAFI,OAAO,2CAA2C,EAAE,iBAAiB,CAAC,GAAG,CAAC,iBAepF;qCAxCqO,YAAY;AAkOlP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yKALW,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wHAvImB,OAAO;;yCAuCI,OAAO,WAAW,OAAO,EAAE,KAAK,OAAO;;;;;8CA+B7E,OAAO,kBAAkB,EAAE,OAAO,8EAEP,OAAO;;;;;;;;;;;;;YAkBvC,iCAAiC;;;;;;;;;;EAuExC;;;;;;;;;;;;;;;;iDA3QqO,YAAY;yCAAZ,YAAY;0CAAZ,YAAY;kCAAZ,YAAY"}

package/src/contractHelper.js

@@ -10,6 +10,10 @@ import { assertElectorateMatches } from './contractGovernance/paramManager.js';
 import { makeParamManagerFromTerms } from './contractGovernance/typedParamManager.js';
 import { GovernorFacetShape } from './typeGuards.js';
 
+/**
+ * @import {VoteCounterCreatorFacet, VoteCounterPublicFacet, QuestionSpec, OutcomeRecord, AddQuestion, AddQuestionReturn, GovernanceSubscriptionState, GovernanceTerms, GovernedApis, GovernedCreatorFacet, GovernedPublicFacet} from './types.js';
+ */
+
 const { Fail, quote: q } = assert;
 
 export const GOVERNANCE_STORAGE_KEY = 'governance';

package/src/electorateTools.d.ts

@@ -0,0 +1,50 @@
+export type QuestionRecord = {
+    voteCap: ERef<VoteCounterCreatorFacet>;
+    publicFacet: VoteCounterPublicFacet;
+    deadline: import('@agoric/time').Timestamp;
+};
+/**
+ * @import {VoteCounterCreatorFacet, VoteCounterPublicFacet, QuestionSpec, OutcomeRecord, AddQuestion, AddQuestionReturn} from './types.js';
+ */
+/**
+ * @typedef {object} QuestionRecord
+ * @property {ERef<VoteCounterCreatorFacet>} voteCap
+ * @property {VoteCounterPublicFacet} publicFacet
+ * @property {import('@agoric/time').Timestamp} deadline
+ */
+/**
+ * Start up a new Counter for a question
+ *
+ * @param {ZCF} zcf
+ * @param {QuestionSpec} questionSpec
+ * @param {unknown} quorumThreshold
+ * @param {ERef<Installation>} voteCounter
+ * @param {MapStore<Handle<'Question'>, QuestionRecord>} questionStore
+ * @param {Publisher<unknown>} questionsPublisher
+ * @param {Publisher<OutcomeRecord>} outcomePublisher
+ * @returns {Promise<AddQuestionReturn>}
+ */
+export function startCounter(zcf: ZCF, questionSpec: QuestionSpec, quorumThreshold: unknown, voteCounter: ERef<Installation<any>>, questionStore: MapStore<Handle<'Question'>, QuestionRecord>, questionsPublisher: Publisher<unknown>, outcomePublisher: Publisher<OutcomeRecord>): Promise<AddQuestionReturn>;
+/** @param {MapStore<Handle<'Question'>, QuestionRecord>} questionStore */
+export function getOpenQuestions(questionStore: MapStore<Handle<'Question'>, QuestionRecord>): Promise<any>;
+/**
+ * @param {ERef<Handle<'Question'>>} questionHandleP
+ * @param {MapStore<Handle<'Question'>, QuestionRecord>} questionStore
+ */
+export function getQuestion(questionHandleP: ERef<Handle<"Question">>, questionStore: MapStore<Handle<'Question'>, QuestionRecord>): Promise<import("./types.js").Question>;
+/**
+ * @param {ZCF} zcf
+ * @param {AddQuestion} addQuestion
+ */
+export function getPoserInvitation(zcf: ZCF, addQuestion: AddQuestion): Promise<Invitation<{
+    addQuestion: AddQuestion;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    addQuestion: AddQuestion;
+}>, undefined>>;
+import type { VoteCounterCreatorFacet } from './types.js';
+import type { VoteCounterPublicFacet } from './types.js';
+import type { QuestionSpec } from './types.js';
+import type { OutcomeRecord } from './types.js';
+import type { AddQuestionReturn } from './types.js';
+import type { AddQuestion } from './types.js';
+//# sourceMappingURL=electorateTools.d.ts.map

package/src/electorateTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"electorateTools.d.ts","sourceRoot":"","sources":["electorateTools.js"],"names":[],"mappings":";;;cAYc,OAAO,cAAc,EAAE,SAAS;;AAR9C;;GAEG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;GAWG;AACH,kCATW,GAAG,+CAEH,OAAO,uDAEP,SAAS,OAAO,UAAU,CAAC,EAAE,cAAc,CAAC,sBAC5C,UAAU,OAAO,CAAC,0EAwC5B;AAED,0EAA0E;AAC1E,gDADY,SAAS,OAAO,UAAU,CAAC,EAAE,cAAc,CAAC,gBAYvD;AAED;;;GAGG;AACH,sFAFW,SAAS,OAAO,UAAU,CAAC,EAAE,cAAc,CAAC,0CAKpD;AAEH;;;GAGG;AACH,wCAHW,GAAG;;;;gBAcb;6CAlG8H,YAAY;4CAAZ,YAAY;kCAAZ,YAAY;mCAAZ,YAAY;uCAAZ,YAAY;iCAAZ,YAAY"}

package/src/electorateTools.js

@@ -2,6 +2,10 @@ import { EmptyProposalShape } from '@agoric/zoe/src/typeGuards.js';
 import { E } from '@endo/eventual-send';
 import { deeplyFulfilled, Far } from '@endo/marshal';
 
+/**
+ * @import {VoteCounterCreatorFacet, VoteCounterPublicFacet, QuestionSpec, OutcomeRecord, AddQuestion, AddQuestionReturn} from './types.js';
+ */
+
 /**
  * @typedef {object} QuestionRecord
  * @property {ERef<VoteCounterCreatorFacet>} voteCap

package/src/index.d.ts

@@ -0,0 +1,9 @@
+export { ParamTypes } from "./constants.js";
+export { ChoiceMethod, ElectionType, QuorumRule, coerceQuestionSpec, positionIncluded, buildQuestion } from "./question.js";
+export { validateQuestionDetails, validateQuestionFromCounter } from "./contractGovernor.js";
+export { handleParamGovernance, publicMixinAPI } from "./contractHelper.js";
+export { assertBallotConcernsParam, makeParamChangePositions, setupParamGovernance, CONTRACT_ELECTORATE } from "./contractGovernance/governParam.js";
+export { assertElectorateMatches, makeParamManagerBuilder } from "./contractGovernance/paramManager.js";
+export { makeParamManager, makeParamManagerSync } from "./contractGovernance/typedParamManager.js";
+export { assertContractGovernance, assertContractElectorate } from "./validators.js";
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":""}

package/src/index.js

@@ -1,6 +1,8 @@
-/// <reference path="../../network/exported.js" />
-/// <reference path="../../ERTP/exported.js" />
-/// <reference path="../../zoe/exported.js" />
+// XXX ambient types runtime imports until https://github.com/Agoric/agoric-sdk/issues/6512
+import '@agoric/ertp/exported.js';
+import '@agoric/zoe/src/contractFacet/types-ambient.js';
+import '@agoric/zoe/tools/types-ambient.js';
+import '@agoric/zoe/src/types.js';
 
 /// <reference path="./types-ambient.js" />
 

package/src/multiCandidateVoteCounter.d.ts

@@ -0,0 +1,19 @@
+/** @type {BuildMultiVoteCounter} */
+export const makeMultiCandidateVoteCounter: BuildMultiVoteCounter;
+/**
+ * @param {ZCF<{questionSpec: QuestionSpec, quorumThreshold: bigint }>} zcf
+ * @param {{outcomePublisher: Publisher<MultiOutcomeRecord>}} outcomePublisher
+ */
+export function start(zcf: ZCF<{
+    questionSpec: QuestionSpec;
+    quorumThreshold: bigint;
+}>, { outcomePublisher }: {
+    outcomePublisher: Publisher<MultiOutcomeRecord>;
+}): {
+    publicFacet: import("./types.js").MultiVoteCounterPublicFacet;
+    creatorFacet: import("./types.js").VoteCounterCreatorFacet;
+};
+import type { BuildMultiVoteCounter } from './types.js';
+import type { QuestionSpec } from './types.js';
+import type { MultiOutcomeRecord } from './types.js';
+//# sourceMappingURL=multiCandidateVoteCounter.d.ts.map

package/src/multiCandidateVoteCounter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiCandidateVoteCounter.d.ts","sourceRoot":"","sources":["multiCandidateVoteCounter.js"],"names":[],"mappings":"AAqCA,oCAAoC;AACpC,kEAuLE;AAEF;;;GAGG;AACH;;qBAH6D,MAAM;;;;;;EAiBlE;2CA5NmG,YAAY;kCAAZ,YAAY;wCAAZ,YAAY"}

package/src/multiCandidateVoteCounter.js

@@ -18,6 +18,10 @@ import {
 import { makeQuorumCounter } from './quorumCounter.js';
 import { breakTie } from './breakTie.js';
 
+/**
+ * @import {QuestionSpec, BuildMultiVoteCounter, MultiOutcomeRecord, Position, VoteStatistics} from './types.js';
+ */
+
 const { Fail } = assert;
 
 const validateQuestionSpec = questionSpec => {

package/src/noActionElectorate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @import {ElectoratePublic, ElectorateCreatorFacet} from './types.js';
+ */
+/**
+ * This Electorate visibly has no members, takes no votes, and approves no
+ * changes.
+ *
+ *  @type {ContractStartFn<ElectoratePublic, ElectorateCreatorFacet>}
+ */
+export const start: ContractStartFn<ElectoratePublic, ElectorateCreatorFacet, any, any>;
+import type { ElectoratePublic } from './types.js';
+import type { ElectorateCreatorFacet } from './types.js';
+//# sourceMappingURL=noActionElectorate.d.ts.map

package/src/noActionElectorate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noActionElectorate.d.ts","sourceRoot":"","sources":["noActionElectorate.js"],"names":[],"mappings":"AAOA;;GAEG;AAEH;;;;;GAKG;AACH,wFAiDE;sCA1DyD,YAAY;4CAAZ,YAAY"}

package/src/noActionElectorate.js

@@ -5,6 +5,10 @@ import { EmptyProposalShape } from '@agoric/zoe/src/typeGuards.js';
 
 import { ElectoratePublicI, ElectorateCreatorI } from './typeGuards.js';
 
+/**
+ * @import {ElectoratePublic, ElectorateCreatorFacet} from './types.js';
+ */
+
 /**
  * This Electorate visibly has no members, takes no votes, and approves no
  * changes.

package/src/question.d.ts

@@ -0,0 +1,31 @@
+/** @type {BuildQuestion} */
+export const buildQuestion: BuildQuestion;
+export namespace ChoiceMethod {
+    let UNRANKED: "unranked";
+    let ORDER: "order";
+    let PLURALITY: "plurality";
+}
+export namespace ElectionType {
+    let PARAM_CHANGE: "param_change";
+    let ELECTION: "election";
+    let SURVEY: "survey";
+    let API_INVOCATION: "api_invocation";
+    let OFFER_FILTER: "offer_filter";
+}
+/**
+ * @internal
+ * @param {QuestionSpec} allegedQuestionSpec
+ * @returns {QuestionSpec}
+ */
+export function coerceQuestionSpec({ method, issue, positions, electionType, maxChoices, maxWinners, closingRule, quorumRule, tieOutcome, }: QuestionSpec): QuestionSpec;
+/** @type {PositionIncluded} */
+export const positionIncluded: PositionIncluded;
+export namespace QuorumRule {
+    let MAJORITY: "majority";
+    let NO_QUORUM: "no_quorum";
+    let ALL: "all";
+}
+import type { BuildQuestion } from './types.js';
+import type { QuestionSpec } from './types.js';
+import type { PositionIncluded } from './types.js';
+//# sourceMappingURL=question.d.ts.map

package/src/question.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["question.js"],"names":[],"mappings":"AAqFA,4BAA4B;AAC5B,0CAgBE;;;;;;;;;;;;;AAxDF;;;;GAIG;AACH,yKAgCC;AAxCD,+BAA+B;AAC/B,gDAA4E;;;;;;mCAtCF,YAAY;kCAAZ,YAAY;sCAAZ,YAAY"}

package/src/question.js

@@ -3,6 +3,10 @@ import { makeHandle } from '@agoric/zoe/src/makeHandle.js';
 
 import { QuestionI, QuestionSpecShape } from './typeGuards.js';
 
+/**
+ * @import {BuildQuestion, PositionIncluded, Question, QuestionSpec} from './types.js';
+ */
+
 // Topics being voted on are 'Questions'. Before a Question is known to a
 // electorate, the parameters can be described with a QuestionSpec. Once the
 // question has been presented to an Electorate, there is a QuestionDetails

package/src/quorumCounter.d.ts

@@ -0,0 +1,6 @@
+export function makeQuorumCounter(quorumThreshold: any): {
+    check: (stats: any) => boolean;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    check: (stats: any) => boolean;
+}>;
+//# sourceMappingURL=quorumCounter.d.ts.map

package/src/quorumCounter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quorumCounter.d.ts","sourceRoot":"","sources":["quorumCounter.js"],"names":[],"mappings":"AAQO;;;;GAUN"}

package/src/quorumCounter.js

@@ -2,6 +2,10 @@
 
 import { Far } from '@endo/marshal';
 
+/**
+ * @import {QuorumCounter} from './types.js';
+ */
+
 export const makeQuorumCounter = quorumThreshold => {
   const check = stats => {
     const votes = stats.results.reduce(