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

package/exported.d.ts

@@ -0,0 +1,37 @@
+/* eslint-disable -- doesn't understand .d.ts */
+
+export * from './src/types.js';
+
+// XXX re-export types into global namespace, for consumers that expect these to
+//  be ambient. Why the _ prefix? Because without it TS gets confused between the
+//  import and export symbols. h/t https://stackoverflow.com/a/66588974
+//  Note one big downside vs ambients is that these types will appear to be on `globalThis`.
+// UNTIL https://github.com/Agoric/agoric-sdk/issues/6512
+import {
+  GovernanceFacetKit as _GovernanceFacetKit,
+  GovernanceTerms as _GovernanceTerms,
+  GovernorCreatorFacet as _GovernorCreatorFacet,
+  GovernanceSubscriptionState as _GovernanceSubscriptionState,
+  GovernorStartedInstallationKit as _GovernorStartedInstallationKit,
+  GovernedCreatorFacet as _GovernedCreatorFacet,
+  ParamStateRecord as _ParamStateRecord,
+  GovernedPublicFacet as _GovernedPublicFacet,
+  CommitteeElectoratePublic as _CommitteeElectoratePublic,
+  GovernedApis as _GovernedApis,
+  GovernableStartFn as _GovernableStartFn,
+} from './src/types.js';
+declare global {
+  export {
+    _CommitteeElectoratePublic as CommitteeElectoratePublic,
+    _GovernableStartFn as GovernableStartFn,
+    _GovernanceFacetKit as GovernanceFacetKit,
+    _GovernanceSubscriptionState as GovernanceSubscriptionState,
+    _GovernanceTerms as GovernanceTerms,
+    _GovernedApis as GovernedApis,
+    _GovernedCreatorFacet as GovernedCreatorFacet,
+    _GovernedPublicFacet as GovernedPublicFacet,
+    _GovernorCreatorFacet as GovernorCreatorFacet,
+    _GovernorStartedInstallationKit as GovernorStartedInstallationKit,
+    _ParamStateRecord as ParamStateRecord,
+  };
+}

package/exported.js

@@ -1 +1 @@
-import './src/types-ambient.js';
+// Dummy file for .d.ts twin to declare ambients

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/governance",
-  "version": "0.10.4-dev-fa844b5.0+fa844b5",
+  "version": "0.10.4-dev-21fe8d9.0+21fe8d9",
   "description": "Core governance support",
   "type": "module",
   "main": "src/index.js",
@@ -10,8 +10,8 @@
   "scripts": {
     "build": "yarn build:bundles",
     "build:bundles": "node ./scripts/build-bundles.js",
-    "prepack": "echo \"export {}; \" | cat - src/types-ambient.js > src/types.js && tsc --build --clean tsconfig.build.json",
-    "postpack": "git clean -f '*.d.ts*' src/types.js",
+    "prepack": "tsc --build tsconfig.build.json",
+    "postpack": "git clean -f '*.d.ts*'",
     "test": "ava",
     "test:c8": "c8 $C8_OPTIONS ava --config=ava-nesm.config.js",
     "test:xs": "exit 0",
@@ -31,15 +31,15 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-fa844b5.0+fa844b5",
-    "@agoric/ertp": "0.16.3-dev-fa844b5.0+fa844b5",
-    "@agoric/internal": "0.3.3-dev-fa844b5.0+fa844b5",
-    "@agoric/network": "0.1.1-dev-fa844b5.0+fa844b5",
-    "@agoric/notifier": "0.6.3-dev-fa844b5.0+fa844b5",
-    "@agoric/store": "0.9.3-dev-fa844b5.0+fa844b5",
-    "@agoric/time": "0.3.3-dev-fa844b5.0+fa844b5",
-    "@agoric/vat-data": "0.5.3-dev-fa844b5.0+fa844b5",
-    "@agoric/zoe": "0.26.3-dev-fa844b5.0+fa844b5",
+    "@agoric/assert": "0.6.1-dev-21fe8d9.0+21fe8d9",
+    "@agoric/ertp": "0.16.3-dev-21fe8d9.0+21fe8d9",
+    "@agoric/internal": "0.3.3-dev-21fe8d9.0+21fe8d9",
+    "@agoric/network": "0.1.1-dev-21fe8d9.0+21fe8d9",
+    "@agoric/notifier": "0.6.3-dev-21fe8d9.0+21fe8d9",
+    "@agoric/store": "0.9.3-dev-21fe8d9.0+21fe8d9",
+    "@agoric/time": "0.3.3-dev-21fe8d9.0+21fe8d9",
+    "@agoric/vat-data": "0.5.3-dev-21fe8d9.0+21fe8d9",
+    "@agoric/zoe": "0.26.3-dev-21fe8d9.0+21fe8d9",
     "@endo/bundle-source": "^3.2.1",
     "@endo/captp": "^4.1.0",
     "@endo/eventual-send": "^1.2.0",
@@ -50,7 +50,7 @@
     "import-meta-resolve": "^2.2.1"
   },
   "devDependencies": {
-    "@agoric/swingset-vat": "0.32.3-dev-fa844b5.0+fa844b5",
+    "@agoric/swingset-vat": "0.32.3-dev-21fe8d9.0+21fe8d9",
     "@endo/bundle-source": "^3.2.1",
     "@endo/init": "^1.1.0",
     "ava": "^5.3.0",
@@ -61,6 +61,7 @@
     "src/",
     "tools/",
     "exported.js",
+    "exported.d.ts",
     "NEWS.md"
   ],
   "ava": {
@@ -78,5 +79,5 @@
   "typeCoverage": {
     "atLeast": 89.27
   },
-  "gitHead": "fa844b51a10ab02af61af19207c164c99c2d8d8c"
+  "gitHead": "21fe8d921225214fb388191548ad63d81912e65f"
 }

package/src/binaryVoteCounter.d.ts

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

package/src/binaryVoteCounter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binaryVoteCounter.d.ts","sourceRoot":"","sources":["binaryVoteCounter.js"],"names":[],"mappings":"AA4CA,+BAA+B;AAC/B,qDA6JE;AAMF;;;GAGG;AACH;;qBAH6D,MAAM;;;;;;EAqBlE;sCAlNyF,YAAY;kCAAZ,YAAY;mCAAZ,YAAY"}

package/src/binaryVoteCounter.js

@@ -17,6 +17,10 @@ import {
 } from './typeGuards.js';
 import { makeQuorumCounter } from './quorumCounter.js';
 
+/**
+ * @import {BuildVoteCounter, OutcomeRecord, Position, QuestionSpec, VoteStatistics} from './types.js';
+ */
+
 const { Fail } = assert;
 
 const validateBinaryQuestionSpec = questionSpec => {

package/src/breakTie.d.ts

@@ -0,0 +1,3 @@
+export function breakTie(positions: Position[], n: number): Position[];
+import type { Position } from './types.js';
+//# sourceMappingURL=breakTie.d.ts.map

package/src/breakTie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breakTie.d.ts","sourceRoot":"","sources":["breakTie.js"],"names":[],"mappings":"AA4BO,mDAHI,MAAM,cAKhB;8BA7B0B,YAAY"}

package/src/breakTie.js

@@ -1,3 +1,7 @@
+/**
+ * @import {Position} from './types.js';
+ */
+
 /**
  * Randomly shuffle an array
  * https://stackoverflow.com/a/12646864

package/src/closingRule.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @import {CloseVoting} from './types.js';
+ */
+/** @type {CloseVoting} */
+export const scheduleClose: CloseVoting;
+import type { CloseVoting } from './types.js';
+//# sourceMappingURL=closingRule.d.ts.map

package/src/closingRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closingRule.d.ts","sourceRoot":"","sources":["closingRule.js"],"names":[],"mappings":"AAOA;;GAEG;AAEH,0BAA0B;AAC1B,wCAQE;iCAZ4B,YAAY"}

package/src/closingRule.js

@@ -5,6 +5,10 @@
 import { E } from '@endo/eventual-send';
 import { Far } from '@endo/marshal';
 
+/**
+ * @import {CloseVoting} from './types.js';
+ */
+
 /** @type {CloseVoting} */
 export const scheduleClose = (closingRule, closeVoting) => {
   const { timer, deadline } = closingRule;

package/src/committee.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @typedef { ElectorateCreatorFacet & {
+ *   getVoterInvitations: () => Promise<Invitation<{ voter: { castBallotFor(handle: any, choice?: any, ): void}}>>[]
+ * }} CommitteeElectorateCreatorFacet
+ */
+/** @type {ContractMeta} */
+export const meta: ContractMeta;
+export function start(zcf: ZCF<{
+    committeeName: string;
+    committeeSize: number;
+}>, privateArgs: {
+    storageNode: ERef<StorageNode>;
+    marshaller: ERef<Marshaller<unknown>>;
+}, baggage: import('@agoric/vat-data').Baggage): {
+    creatorFacet: CommitteeElectorateCreatorFacet;
+    publicFacet: CommitteeElectoratePublic;
+};
+export type CommitteeElectorateCreatorFacet = ElectorateCreatorFacet & {
+    getVoterInvitations: () => Promise<Invitation<{
+        voter: {
+            castBallotFor(handle: any, choice?: any): void;
+        };
+    }>>[];
+};
+import type { CommitteeElectoratePublic } from './types.js';
+import type { ElectorateCreatorFacet } from './types.js';
+//# sourceMappingURL=committee.d.ts.map

package/src/committee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"committee.d.ts","sourceRoot":"","sources":["committee.js"],"names":[],"mappings":"AAwBA;;;;GAIG;AAEH,2BAA2B;AAC3B,mBADW,YAAY,CAOrB;AAoBK,2BARI,IAAI;IACd,aAAiB,EAAE,MAAM,CAAC;IAC1B,aAAiB,EAAE,MAAM,CAAC;CACvB,CAAC;;;YAEM,OAAO,kBAAkB,EAAE,OAAO;kBACjB,+BAA+B;;EAkI1D;;yBA/JyB,MAAM,QAAQ,WAAW;QAAE,KAAK,EAAE;YAAE,aAAa,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,GAAK,IAAI,CAAA;SAAC,CAAA;KAAC,CAAC,CAAC,EAAE;;+CAPH,YAAY;4CAAZ,YAAY"}

package/src/committee.js

@@ -16,6 +16,10 @@ import { QuorumRule } from './question.js';
 import { ElectorateCreatorI, ElectoratePublicI } from './typeGuards.js';
 import { prepareVoterKit } from './voterKit.js';
 
+/**
+ * @import {ElectorateCreatorFacet, CommitteeElectoratePublic, QuestionDetails, OutcomeRecord, AddQuestion} from './types.js';
+ */
+
 const { ceilDivide } = natSafeMath;
 
 /**

package/src/constants.d.ts

@@ -0,0 +1,16 @@
+export namespace ParamTypes {
+    let AMOUNT: "amount";
+    let BRAND: "brand";
+    let INSTALLATION: "installation";
+    let INSTANCE: "instance";
+    let INVITATION: "invitation";
+    let NAT: "nat";
+    let RATIO: "ratio";
+    let STRING: "string";
+    let PASSABLE_RECORD: "record";
+    let TIMESTAMP: "timestamp";
+    let RELATIVE_TIME: "relativeTime";
+    let UNKNOWN: "unknown";
+}
+export type ParamType = (typeof ParamTypes)[keyof typeof ParamTypes];
+//# sourceMappingURL=constants.d.ts.map

package/src/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["constants.js"],"names":[],"mappings":";;;;;;;;;;;;;;wBAuBc,CAAA,iBAAiB,EAAC,MAAM,iBAAiB,CAAC"}

package/src/contractGovernance/assertions.d.ts

@@ -0,0 +1,7 @@
+export function makeLooksLikeBrand(name: any): (brand: Brand) => void;
+export function makeAssertInstallation(name: any): (installation: any) => void;
+export function makeAssertInstance(name: any): (instance: any) => void;
+export function makeAssertBrandedRatio(name: any, modelRatio: any): (ratio: any) => boolean;
+export function assertRelativeTime(value: any): void;
+export function assertTimestamp(value: any): void;
+//# sourceMappingURL=assertions.d.ts.map

package/src/contractGovernance/assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["assertions.js"],"names":[],"mappings":"AAOA,uDACc,KAAK,UAIlB;AAGD,+EAMC;AAGD,uEAMC;AAGD,4FASC;AAGD,qDAEC;AAGD,kDAEC"}

package/src/contractGovernance/governApi.d.ts

@@ -0,0 +1,32 @@
+/**
+ * manage contracts that allow governance to invoke functions.
+ *
+ * @param {ERef<{ [methodName: string]: (...args: any) => unknown }>} governedApis
+ * @param {Array<string | symbol>} governedNames names of the governed API methods
+ * @param {ERef<import('@agoric/time').TimerService>} timer
+ * @param {() => Promise<PoserFacet>} getUpdatedPoserFacet
+ * @returns {ApiGovernor}
+ */
+export function setupApiGovernance(governedApis: ERef<{
+    [methodName: string]: (...args: any) => unknown;
+}>, governedNames: Array<string | symbol>, timer: ERef<import("@agoric/time").TimerService>, getUpdatedPoserFacet: () => Promise<PoserFacet>): ApiGovernor;
+/**
+ * Make a pair of positions for a question about whether to invoke an API. If
+ * the vote passes, the method will be called on the governedApis facet with the
+ * arguments that were provided.
+ *
+ * @param {string} apiMethodName
+ * @param {unknown[]} methodArgs
+ */
+export function makeApiInvocationPositions(apiMethodName: string, methodArgs: unknown[]): {
+    positive: {
+        apiMethodName: string;
+        methodArgs: unknown[];
+    };
+    negative: {
+        dontInvoke: string;
+    };
+};
+import type { PoserFacet } from '../types.js';
+import type { ApiGovernor } from '../types.js';
+//# sourceMappingURL=governApi.d.ts.map

package/src/contractGovernance/governApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governApi.d.ts","sourceRoot":"","sources":["governApi.js"],"names":[],"mappings":"AA+BA;;;;;;;;GAQG;AACH;oCANkD,GAAG,KAAK,OAAO;mBACtD,MAAM,MAAM,GAAG,MAAM,CAAC,kHA2FhC;AA7GD;;;;;;;GAOG;AACH,0DAHW,MAAM,cACN,OAAO,EAAE;;;;;;;;EAMnB;gCAjB4F,aAAa;iCAAb,aAAa"}

package/src/contractGovernance/governApi.js

@@ -9,6 +9,10 @@ import {
   coerceQuestionSpec,
 } from '../question.js';
 
+/**
+ * @import {Position, ApiGovernor, ApiInvocationIssue, PoserFacet, VoteOnApiInvocation} from '../types.js';
+ */
+
 const { Fail, quote: q } = assert;
 
 /**

package/src/contractGovernance/governFilter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Setup to allow governance to block some invitations.
+ *
+ * @param {ERef<import('@agoric/time').TimerService>} timer
+ * @param {() => Promise<PoserFacet>} getUpdatedPoserFacet
+ * @param {GovernedCreatorFacet<{}>} governedCF
+ * @returns {FilterGovernor}
+ */
+export function setupFilterGovernance(timer: ERef<import("@agoric/time").TimerService>, getUpdatedPoserFacet: () => Promise<PoserFacet>, governedCF: GovernedCreatorFacet<{}>): FilterGovernor;
+/**
+ * @import {Position, ApiGovernor, ApiInvocationIssue, PoserFacet, VoteOnApiInvocation, FilterGovernor, GovernedCreatorFacet, OfferFilterIssue, VoteOnOfferFilter} from '../types.js';
+ */
+/**
+ * Make a pair of positions for a question about whether to update the offer
+ * filter. If the vote passes, the list of blocked invitation strings will be
+ * updated.
+ *
+ * @param {string[]} strings
+ */
+export function makeOfferFilterPositions(strings: string[]): {
+    positive: {
+        strings: string[];
+    };
+    negative: {
+        dontUpdate: string[];
+    };
+};
+import type { PoserFacet } from '../types.js';
+import type { GovernedCreatorFacet } from '../types.js';
+import type { FilterGovernor } from '../types.js';
+//# sourceMappingURL=governFilter.d.ts.map

package/src/contractGovernance/governFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governFilter.d.ts","sourceRoot":"","sources":["governFilter.js"],"names":[],"mappings":"AA6BA;;;;;;;GAOG;AACH,+LAmEC;AA5FD;;GAEG;AAEH;;;;;;GAMG;AACH,kDAFW,MAAM,EAAE;;;;;;;EAMlB;gCAduK,aAAa;0CAAb,aAAa;oCAAb,aAAa"}

package/src/contractGovernance/governFilter.js

@@ -10,6 +10,10 @@ import {
   coerceQuestionSpec,
 } from '../question.js';
 
+/**
+ * @import {Position, ApiGovernor, ApiInvocationIssue, PoserFacet, VoteOnApiInvocation, FilterGovernor, GovernedCreatorFacet, OfferFilterIssue, VoteOnOfferFilter} from '../types.js';
+ */
+
 /**
  * Make a pair of positions for a question about whether to update the offer
  * filter. If the vote passes, the list of blocked invitation strings will be

package/src/contractGovernance/governParam.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @param {ERef<ParamManagerRetriever>} paramManagerRetriever
+ * @param {Instance} contractInstance
+ * @param {import('@agoric/time').TimerService} timer
+ * @param {() => Promise<PoserFacet>} getUpdatedPoserFacet
+ * @returns {ParamGovernor}
+ */
+export function setupParamGovernance(paramManagerRetriever: ERef<ParamManagerRetriever>, contractInstance: Instance, timer: import('@agoric/time').TimerService, getUpdatedPoserFacet: () => Promise<PoserFacet>): ParamGovernor;
+/**
+ * Return a record containing the positive and negative positions for a
+ * question on changing the param to the proposedValue.
+ *
+ * @param {Record<string, ParamValue>} changes
+ * @returns {ParamChangePositions}
+ */
+export function makeParamChangePositions(changes: Record<string, unknown>): ParamChangePositions;
+/**
+ * assert that the parameter described by paramSpec is proposed to be changed in
+ * the question described by questionSpec.
+ *
+ * @param {{ parameterName: string, paramPath: unknown}} paramSpec
+ * @param {QuestionSpec<ParamChangeIssue<unknown>>} questionSpec
+ */
+export function assertBallotConcernsParam(paramSpec: {
+    parameterName: string;
+    paramPath: unknown;
+}, questionSpec: QuestionSpec<ParamChangeIssue<unknown>>): void;
+/**
+ * The electorate that governs changes to the contract's parameters. It must be
+ * declared in the governed contract.
+ */
+export const CONTRACT_ELECTORATE: "Electorate";
+import type { ParamManagerRetriever } from '../types.js';
+import type { PoserFacet } from '../types.js';
+import type { ParamGovernor } from '../types.js';
+import type { ParamChangePositions } from '../types.js';
+import type { ParamChangeIssue } from '../types.js';
+import type { QuestionSpec } from '../types.js';
+//# sourceMappingURL=governParam.d.ts.map

package/src/contractGovernance/governParam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governParam.d.ts","sourceRoot":"","sources":["governParam.js"],"names":[],"mappings":"AAwDA;;;;;;GAMG;AACH,2GALW,QAAQ,SACR,OAAO,cAAc,EAAE,YAAY,kEA0F7C;AA9HD;;;;;;GAMG;AACH,iGAMC;AAED;;;;;;GAMG;AACH,qDAHW;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAC,+DAYtD;AArCD;;;GAGG;AACH,+CAAyC;2CATsI,aAAa;gCAAb,aAAa;mCAAb,aAAa;0CAAb,aAAa;sCAAb,aAAa;kCAAb,aAAa"}

package/src/contractGovernance/governParam.js

@@ -9,6 +9,9 @@ import {
   QuorumRule,
 } from '../question.js';
 import { ParamChangesQuestionDetailsShape } from '../typeGuards.js';
+/**
+ * @import {ParamValue, ParamChangePositions, QuestionSpec, ChangeParamsPosition, ParamChangeIssue, ParamGovernor, ParamManagerRetriever, PoserFacet, VoteOnParamChanges} from '../types.js';
+ */
 
 const { Fail } = assert;
 

package/src/contractGovernance/paramManager.d.ts

@@ -0,0 +1,49 @@
+export type ParamManagerBuilder = {
+    addAmount: (name: string, value: Amount) => ParamManagerBuilder;
+    addBrand: (name: string, value: Brand) => ParamManagerBuilder;
+    addInstallation: (name: string, value: Installation) => ParamManagerBuilder;
+    addInstance: (name: string, value: Instance) => ParamManagerBuilder;
+    addInvitation: (name: string, value: Invitation) => ParamManagerBuilder;
+    addNat: (name: string, value: bigint) => ParamManagerBuilder;
+    addRatio: (name: string, value: Ratio) => ParamManagerBuilder;
+    addRecord: (name: string, value: import('@endo/marshal').CopyRecord<unknown>) => ParamManagerBuilder;
+    addString: (name: string, value: string) => ParamManagerBuilder;
+    addTimestamp: (name: string, value: import('@agoric/time').Timestamp) => ParamManagerBuilder;
+    addRelativeTime: (name: string, value: import('@agoric/time').RelativeTime) => ParamManagerBuilder;
+    addUnknown: (name: string, value: any) => ParamManagerBuilder;
+    build: () => AnyParamManager;
+};
+/**
+ * @param {ParamManagerBase} paramManager
+ * @param {{[CONTRACT_ELECTORATE]: ParamValueTyped<'invitation'>}} governedParams
+ */
+export function assertElectorateMatches(paramManager: ParamManagerBase, governedParams: {
+    Electorate: ParamValueTyped<"invitation">;
+}): void;
+/**
+ * @typedef {object} ParamManagerBuilder
+ * @property {(name: string, value: Amount) => ParamManagerBuilder} addAmount
+ * @property {(name: string, value: Brand) => ParamManagerBuilder} addBrand
+ * @property {(name: string, value: Installation) => ParamManagerBuilder} addInstallation
+ * @property {(name: string, value: Instance) => ParamManagerBuilder} addInstance
+ * @property {(name: string, value: Invitation) => ParamManagerBuilder} addInvitation
+ * @property {(name: string, value: bigint) => ParamManagerBuilder} addNat
+ * @property {(name: string, value: Ratio) => ParamManagerBuilder} addRatio
+ * @property {(name: string, value: import('@endo/marshal').CopyRecord<unknown>) => ParamManagerBuilder} addRecord
+ * @property {(name: string, value: string) => ParamManagerBuilder} addString
+ * @property {(name: string, value: import('@agoric/time').Timestamp) => ParamManagerBuilder} addTimestamp
+ * @property {(name: string, value: import('@agoric/time').RelativeTime) => ParamManagerBuilder} addRelativeTime
+ * @property {(name: string, value: any) => ParamManagerBuilder} addUnknown
+ * @property {() => AnyParamManager} build
+ */
+/**
+ * @param {import('@agoric/notifier').StoredPublisherKit<GovernanceSubscriptionState>} publisherKit
+ * @param {ERef<ZoeService>} [zoe]
+ */
+export function makeParamManagerBuilder(publisherKit: import("@agoric/notifier").StoredPublisherKit<GovernanceSubscriptionState>, zoe?: ERef<ZoeService> | undefined): ParamManagerBuilder;
+import type { AnyParamManager } from '../types.js';
+import type { ParamManagerBase } from '../types.js';
+import { CONTRACT_ELECTORATE } from './governParam.js';
+import type { ParamValueTyped } from '../types.js';
+import type { GovernanceSubscriptionState } from '../types.js';
+//# sourceMappingURL=paramManager.d.ts.map

package/src/contractGovernance/paramManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paramManager.d.ts","sourceRoot":"","sources":["paramManager.js"],"names":[],"mappings":";eA4Cc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,mBAAmB;cACpD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,mBAAmB;qBACnD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,KAAK,mBAAmB;iBAC1D,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,KAAK,mBAAmB;mBACtD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,KAAK,mBAAmB;YACxD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,mBAAmB;cACpD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,mBAAmB;eACnD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,eAAe,EAAE,UAAU,CAAC,OAAO,CAAC,KAAK,mBAAmB;eACzF,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,mBAAmB;kBACpD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,cAAc,EAAE,SAAS,KAAK,mBAAmB;qBAC9E,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,cAAc,EAAE,YAAY,KAAK,mBAAmB;gBACjF,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,mBAAmB;;;AA7B/D;;;GAGG;AACH;;SAUC;AAED;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AACH,2LAgXC;qCA1ZiI,aAAa;sCAAb,aAAa;oCAH3G,kBAAkB;qCAG4E,aAAa;iDAAb,aAAa"}

package/src/contractGovernance/paramManager.js

@@ -18,6 +18,10 @@ import {
 } from './assertions.js';
 import { CONTRACT_ELECTORATE } from './governParam.js';
 
+/**
+ * @import {AnyParamManager, GovernanceSubscriptionState, ParamManagerBase, ParamStateRecord, ParamValueTyped, UpdateParams} from '../types.js';
+ */
+
 const { Fail, quote: q } = assert;
 
 /**
@@ -90,7 +94,7 @@ const makeParamManagerBuilder = (publisherKit, zoe) => {
    * @param {Keyword} name
    * @param {unknown} value
    * @param {(val) => void} assertion
-   * @param {ParamType} type
+   * @param {import('../constants.js').ParamType} type
    */
   const buildCopyParam = (name, value, assertion, type) => {
     let current;

package/src/contractGovernance/typedParamManager.d.ts

@@ -0,0 +1,38 @@
+export function makeParamManager<T extends Record<string, SyncSpecTuple | AsyncSpecTuple>>(publisherKit: import("@agoric/notifier").StoredPublisherKit<GovernanceSubscriptionState>, spec: T, zcf: ZCF): TypedParamManager<{ [K in keyof T]: T[K][0]; }>;
+export function makeParamManagerSync<T extends Record<string, SyncSpecTuple>>(publisherKit: import("@agoric/notifier").StoredPublisherKit<GovernanceSubscriptionState>, spec: T): TypedParamManager<{ [K in keyof T]: T[K][0]; }>;
+export function makeParamManagerFromTerms<I extends Record<string, Invitation<unknown, undefined>> & {
+    Electorate: Invitation;
+}, M extends ParamTypesMap>(publisherKit: import("@agoric/notifier").StoredPublisherKit<GovernanceSubscriptionState>, zcf: ZCF<GovernanceTerms<M>>, invitations: I, paramTypesMap: M): TypedParamManager<M & { [K in keyof I]: "invitation"; }>;
+export type ParamTypesMap = {
+    [x: string]: ParamType;
+};
+export type ParamTypesMapFromRecord<M extends ParamStateRecord> = { [R in keyof M]: M[R]["type"]; };
+export type ParamRecordsFromTypes<M extends ParamTypesMap> = { [T in keyof M]: {
+    type: M[T];
+    value: ParamValueForType<M[T]>;
+}; };
+export type Getters<M extends ParamTypesMap> = { [K in keyof M as `get${string & K}`]: () => ParamValueForType<M[K]>; };
+export type Updaters<T extends ParamTypesMap> = { [K in keyof T as `update${string & K}`]: (value: ParamValueForType<T[K]>) => void; };
+export type TypedParamManager<M extends ParamTypesMap> = ParamManagerBase & Getters<M> & Updaters<M> & {
+    readonly: () => Getters<M>;
+} & {
+    updateParams: UpdateParams;
+};
+/**
+ * param spec tuple
+ */
+export type ST<T extends ParamType> = [type: T, value: ParamValueForType<T>];
+export type InvitationParam = {
+    type: 'invitation';
+    value: Amount<'set'>;
+};
+export type SyncSpecTuple = [type: "amount", value: globalThis.Amount<any>] | [type: "brand", value: globalThis.Brand] | [type: "installation", value: Installation<any>] | [type: "instance", value: Instance] | [type: "nat", value: bigint] | [type: "ratio", value: Ratio] | [type: "string", value: string] | [type: "timestamp", value: import("@agoric/time").Timestamp] | [type: "relativeTime", value: import("@agoric/time").RelativeTime] | [type: "unknown", value: unknown];
+export type AsyncSpecTuple = ['invitation', Invitation];
+import type { GovernanceSubscriptionState } from '../types.js';
+import type { GovernanceTerms } from '../types.js';
+import type { ParamType } from '../constants.js';
+import type { ParamStateRecord } from '../types.js';
+import type { ParamValueForType } from '../types.js';
+import type { ParamManagerBase } from '../types.js';
+import type { UpdateParams } from '../types.js';
+//# sourceMappingURL=typedParamManager.d.ts.map

package/src/contractGovernance/typedParamManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedParamManager.d.ts","sourceRoot":"","sources":["typedParamManager.js"],"names":[],"mappings":"AAyFO,mMAHI,GAAG,mDAwBb;AAaM,kOAWN;AAYM;gBARiD,UAAU;gPAmCjE;;;;;;;;;;+HA3IiF,IAAI;;cAMhB,MAAM,QAAQ,CAAC,CAAC;;;;;;;;8BAoBzE;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,OAAO,KAAK,CAAC,CAAA;CAAE;4BAO5C,4bASK;6BAEL,CAAC,YAAY,EAAE,UAAU,CAAC;iDAtE2M,aAAa;qCAAb,aAAa;+BACnO,iBAAiB;sCADqM,aAAa;uCAAb,aAAa;sCAAb,aAAa;kCAAb,aAAa"}

package/src/contractGovernance/typedParamManager.js

@@ -5,6 +5,11 @@ import { makeParamManagerBuilder } from './paramManager.js';
 
 const { Fail, quote: q } = assert;
 
+/**
+ * @import {VoteCounterCreatorFacet, VoteCounterPublicFacet, QuestionSpec, OutcomeRecord, AddQuestion, AddQuestionReturn, GovernanceSubscriptionState, GovernanceTerms, ParamManagerBase, ParamStateRecord, ParamValueForType, UpdateParams} from '../types.js';
+ * @import {ParamType} from '../constants.js';
+ */
+
 /**
  * @typedef {Record<Keyword, ParamType>} ParamTypesMap
  */

package/src/contractGovernor.d.ts

@@ -0,0 +1,29 @@
+/** @type {ContractMeta} */
+export const meta: ContractMeta;
+export function validateQuestionDetails(zoe: ERef<ZoeService>, electorate: Instance, details: ParamChangeIssueDetails): Promise<[void, void, void]>;
+export function validateQuestionFromCounter(zoe: ERef<ZoeService>, electorate: Instance, voteCounter: Instance): Promise<[void, void, void]>;
+export function start<SF extends GovernableStartFn>(zcf: ZCF<{
+    timer: import('@agoric/time').TimerService;
+    governedContractInstallation: Installation<SF>;
+    governed: {
+        issuerKeywordRecord: IssuerKeywordRecord;
+        terms: {
+            governedParams: {
+                [CONTRACT_ELECTORATE]: import('./contractGovernance/typedParamManager.js').InvitationParam;
+            };
+        };
+        label?: string;
+    };
+}>, privateArgs: {
+    governed: Record<string, unknown>;
+}, baggage: import('@agoric/vat-data').Baggage): Promise<{
+    creatorFacet: GovernorCreatorFacet<SF>;
+    publicFacet: GovernorPublic;
+}>;
+export type ContractGovernorTerms = StandardTerms;
+import type { ParamChangeIssueDetails } from './types.js';
+import type { GovernableStartFn } from './types.js';
+import { CONTRACT_ELECTORATE } from './contractGovernance/governParam.js';
+import type { GovernorCreatorFacet } from './types.js';
+import type { GovernorPublic } from './types.js';
+//# sourceMappingURL=contractGovernor.d.ts.map

package/src/contractGovernor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contractGovernor.d.ts","sourceRoot":"","sources":["contractGovernor.js"],"names":[],"mappings":"AAiBA,2BAA2B;AAC3B,mBADW,YAAY,CAGrB;AAYK,2EAHI,QAAQ,iEAmBlB;AAYM,+EAHI,QAAQ,eACR,QAAQ,+BAWlB;AA0FM;WAjBK,OAAO,cAAc,EAAE,YAAY;;cAEhC;QACd,mBAAyB,EAAE,mBAAmB,CAAC;QAC/C,KAAW,EAAE;YAAC,cAAc,EAAE;gBAAC,qBAAqB,EAAE,OAAO,2CAA2C,EAAE,eAAe,CAAA;aAAC,CAAA;SAAC,CAAC;QAC5H,KAAW,CAAC,EAAE,MAAM,CAAC;KAChB;iBAEK;IACV,QAAY,EAAE,OAAO,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC,WAKO,OAAO,kBAAkB,EAAE,OAAO;;;GA6D5C;oCAjJY,aAAa;6CA/DyE,YAAY;uCAAZ,YAAY;oCAL3E,qCAAqC;0CAK0B,YAAY;oCAAZ,YAAY"}

package/src/contractGovernor.js

@@ -7,6 +7,10 @@ import { CONTRACT_ELECTORATE } from './contractGovernance/governParam.js';
 import { prepareContractGovernorKit } from './contractGovernorKit.js';
 import { ParamChangesQuestionDetailsShape } from './typeGuards.js';
 
+/**
+ * @import {GovernableStartFn, GovernorCreatorFacet, GovernorPublic, ParamChangeIssueDetails} from './types.js';
+ */
+
 const { Fail } = assert;
 
 const trace = makeTracer('CGov', false);