@agoric/ertp 0.16.3-other-dev-8f8782b.0 → 0.16.3-other-dev-3eb1a1d.0

package/src/amountMath.js

@@ -1,3 +1,4 @@
+import { q, Fail } from '@endo/errors';
 import { passStyleOf, assertRemotable, assertRecord } from '@endo/marshal';
 
 import { M, matches } from '@agoric/store';
@@ -6,67 +7,65 @@ import { setMathHelpers } from './mathHelpers/setMathHelpers.js';
 import { copySetMathHelpers } from './mathHelpers/copySetMathHelpers.js';
 import { copyBagMathHelpers } from './mathHelpers/copyBagMathHelpers.js';
 
-const { quote: q, Fail } = assert;
+/**
+ * @import {CopyBag, CopySet} from '@endo/patterns';
+ * @import {Amount, AssetValueForKind, Brand, CopyBagAmount, CopySetAmount, MathHelpers, NatAmount, NatValue, SetAmount, SetValue} from './types.js';
+ */
 
+// NB: AssetKind is both a constant for enumerated values and a type for those values.
 /**
  * Constants for the kinds of assets we support.
  *
- * @type {{ NAT: 'nat', SET: 'set', COPY_SET: 'copySet', COPY_BAG: 'copyBag' }}
+ * @enum {(typeof AssetKind)[keyof typeof AssetKind]}
  */
-const AssetKind = harden({
+export const AssetKind = /** @type {const} */ ({
   NAT: 'nat',
   SET: 'set',
   COPY_SET: 'copySet',
   COPY_BAG: 'copyBag',
 });
+harden(AssetKind);
 const assetKindNames = harden(Object.values(AssetKind).sort());
 
-/**
- * @param {AssetKind} allegedAK
- */
-const assertAssetKind = allegedAK => {
+/** @param {AssetKind} allegedAK */
+export const assertAssetKind = allegedAK => {
   assetKindNames.includes(allegedAK) ||
     Fail`The assetKind ${allegedAK} must be one of ${q(assetKindNames)}`;
 };
 harden(assertAssetKind);
 
 /**
- * Amounts describe digital assets. From an amount, you can learn the
- * brand of digital asset as well as "how much" or "how many". Amounts
- * have two parts: a brand (loosely speaking, the type of digital
- * asset) and the value (the answer to "how much"). For example, in
- * the phrase "5 bucks", "bucks" takes the role of the brand and the
- * value is 5. Amounts can describe fungible and non-fungible digital
- * assets. Amounts are pass-by-copy and can be made by and sent to
- * anyone.
+ * Amounts describe digital assets. From an amount, you can learn the brand of
+ * digital asset as well as "how much" or "how many". Amounts have two parts: a
+ * brand (loosely speaking, the type of digital asset) and the value (the answer
+ * to "how much"). For example, in the phrase "5 bucks", "bucks" takes the role
+ * of the brand and the value is 5. Amounts can describe fungible and
+ * non-fungible digital assets. Amounts are pass-by-copy and can be made by and
+ * sent to anyone.
  *
- * The issuer is the authoritative source of the amount in payments
- * and purses. The issuer must be able to do things such as add
- * digital assets to a purse and withdraw digital assets from a purse.
- * To do so, it must know how to add and subtract digital assets.
- * Rather than hard-coding a particular solution, we chose to
- * parameterize the issuer with a collection of polymorphic functions,
- * which we call `AmountMath`. These math functions include concepts
+ * The issuer is the authoritative source of the amount in payments and purses.
+ * The issuer must be able to do things such as add digital assets to a purse
+ * and withdraw digital assets from a purse. To do so, it must know how to add
+ * and subtract digital assets. Rather than hard-coding a particular solution,
+ * we chose to parameterize the issuer with a collection of polymorphic
+ * functions, which we call `AmountMath`. These math functions include concepts
  * like addition, subtraction, and greater than or equal to.
  *
- * We also want to make sure there is no confusion as to what kind of
- * asset we are using. Thus, AmountMath includes checks of the
- * `brand`, the unique identifier for the type of digital asset. If
- * the wrong brand is used in AmountMath, an error is thrown and the
- * operation does not succeed.
+ * We also want to make sure there is no confusion as to what kind of asset we
+ * are using. Thus, AmountMath includes checks of the `brand`, the unique
+ * identifier for the type of digital asset. If the wrong brand is used in
+ * AmountMath, an error is thrown and the operation does not succeed.
  *
- * AmountMath uses mathHelpers to do most of the work, but then adds
- * the brand to the result. The function `value` gets the value from
- * the amount by removing the brand (amount -> value), and the
- * function `make` adds the brand to produce an amount (value ->
- * amount). The function `coerce` takes an amount and checks it,
- * returning an amount (amount -> amount).
+ * AmountMath uses mathHelpers to do most of the work, but then adds the brand
+ * to the result. The function `value` gets the value from the amount by
+ * removing the brand (amount -> value), and the function `make` adds the brand
+ * to produce an amount (value -> amount). The function `coerce` takes an amount
+ * and checks it, returning an amount (amount -> amount).
  *
- * Each issuer of digital assets has an associated brand in a
- * one-to-one mapping. In untrusted contexts, such as in analyzing
- * payments and amounts, we can get the brand and find the issuer
- * which matches the brand. The issuer and the brand mutually validate
- * each other.
+ * Each issuer of digital assets has an associated brand in a one-to-one
+ * mapping. In untrusted contexts, such as in analyzing payments and amounts, we
+ * can get the brand and find the issuer which matches the brand. The issuer and
+ * the brand mutually validate each other.
  */
 
 const helpers = {
@@ -76,26 +75,19 @@ const helpers = {
   copyBag: copyBagMathHelpers,
 };
 
-/**
- * @template {AmountValue} V
- * @type {(value: V) => AssetKindForValue<V>}
- */
+/** @type {(value: unknown) => 'nat' | 'set' | 'copySet' | 'copyBag'} } */
 const assertValueGetAssetKind = value => {
   const passStyle = passStyleOf(value);
   if (passStyle === 'bigint') {
-    // @ts-expect-error cast
     return 'nat';
   }
   if (passStyle === 'copyArray') {
-    // @ts-expect-error cast
     return 'set';
   }
   if (matches(value, M.set())) {
-    // @ts-expect-error cast
     return 'copySet';
   }
   if (matches(value, M.bag())) {
-    // @ts-expect-error cast
     return 'copyBag';
   }
   // TODO This isn't quite the right error message, in case valuePassStyle
@@ -113,7 +105,7 @@ const assertValueGetAssetKind = value => {
  *
  * Made available only for testing, but it is harmless for other uses.
  *
- * @template {AmountValue} V
+ * @template V
  * @param {V} value
  * @returns {MathHelpers<V>}
  */
@@ -137,7 +129,7 @@ const optionalBrandCheck = (allegedBrand, brand) => {
  * @param {Amount<K>} leftAmount
  * @param {Amount<K>} rightAmount
  * @param {Brand<K> | undefined} brand
- * @returns {MathHelpers<*>}
+ * @returns {MathHelpers<any>}
  */
 const checkLRAndGetHelpers = (leftAmount, rightAmount, brand = undefined) => {
   assertRecord(leftAmount, 'leftAmount');
@@ -172,11 +164,11 @@ const coerceLR = (h, leftAmount, rightAmount) => {
 };
 
 /**
- * Returns true if the leftAmount is greater than or equal to the
- * rightAmount. The notion of "greater than or equal to" depends
- * on the kind of amount, as defined by the MathHelpers. For example,
- * whether rectangle A is greater than rectangle B depends on whether rectangle
- * A includes rectangle B as defined by the logic in MathHelpers.
+ * Returns true if the leftAmount is greater than or equal to the rightAmount.
+ * The notion of "greater than or equal to" depends on the kind of amount, as
+ * defined by the MathHelpers. For example, whether rectangle A is greater than
+ * rectangle B depends on whether rectangle A includes rectangle B as defined by
+ * the logic in MathHelpers.
  *
  * @template {AssetKind} K
  * @param {Amount<K>} leftAmount
@@ -194,34 +186,48 @@ const isGTE = (leftAmount, rightAmount, brand = undefined) => {
  *
  * Amounts are the canonical description of tradable goods. They are manipulated
  * by issuers and mints, and represent the goods and currency carried by purses
- * and
- * payments. They can be used to represent things like currency, stock, and the
- * abstract right to participate in a particular exchange.
+ * and payments. They can be used to represent things like currency, stock, and
+ * the abstract right to participate in a particular exchange.
  */
-const AmountMath = {
+export const AmountMath = {
+  // TODO use overloading to handle when Brand has an AssetKind and when it doesn't.
+  // a AmountForValue utility could help DRY those cases.
   /**
    * Make an amount from a value by adding the brand.
    *
-   * @template {AssetKind} K
-   * @param {Brand<K>} brand
-   * @param {AssetValueForKind<K>} allegedValue
-   * @returns {Amount<K>}
+   * Does not verify that the Brand's AssetKind matches the value's.
+   *
+   * @template {Brand} B
+   * @template {NatValue | CopySet | CopyBag | SetValue} V
+   * @param {B} brand
+   * @param {V} allegedValue
+   * @returns {B extends Brand<'nat'>
+   *     ? NatAmount
+   *     : V extends NatValue
+   *       ? NatAmount
+   *       : V extends CopySet
+   *         ? CopySetAmount<V['payload'][0]>
+   *         : V extends CopyBag
+   *           ? CopyBagAmount<V['payload'][0][0]>
+   *           : V extends SetValue
+   *             ? SetAmount<V[0]>
+   *             : never}
    */
-  // allegedValue has a conditional expression for type widening, to prevent V being bound to a a literal like 1n
   make: (brand, allegedValue) => {
     assertRemotable(brand, 'brand');
     const h = assertValueGetHelpers(allegedValue);
     const value = h.doCoerce(allegedValue);
+    // @ts-expect-error cast
     return harden({ brand, value });
   },
   /**
-   * Make sure this amount is valid enough, and return a corresponding
-   * valid amount if so.
+   * Make sure this amount is valid enough, and return a corresponding valid
+   * amount if so.
    *
-   * @template {AssetKind} K
-   * @param {Brand<K>} brand
-   * @param {Amount<K>} allegedAmount
-   * @returns {Amount<K>}
+   * @template {Amount} A
+   * @param {Brand} brand
+   * @param {A} allegedAmount
+   * @returns {A}
    */
   coerce: (brand, allegedAmount) => {
     assertRemotable(brand, 'brand');
@@ -230,46 +236,47 @@ const AmountMath = {
     brand === allegedBrand ||
       Fail`The brand in the allegedAmount ${allegedAmount} in 'coerce' didn't match the specified brand ${brand}.`;
     // Will throw on inappropriate value
+    // @ts-expect-error cast
     return AmountMath.make(brand, allegedValue);
   },
   /**
    * Extract and return the value.
    *
-   * @template {AssetKind} K
-   * @param {Brand<K>} brand
-   * @param {Amount<K>} amount
-   * @returns {AssetValueForKind<K>}
+   * @template {Amount} A
+   * @param {Brand} brand
+   * @param {A} amount
+   * @returns {A['value']}
    */
   getValue: (brand, amount) => AmountMath.coerce(brand, amount).value,
   /**
-   * Return the amount representing an empty amount. This is the
-   * identity element for MathHelpers.add and MatHelpers.subtract.
+   * Return the amount representing an empty amount. This is the identity
+   * element for MathHelpers.add and MatHelpers.subtract.
    *
    * @type {{
    *   (brand: Brand): Amount<'nat'>;
-   *   <K extends AssetKind>(brand: Brand, assetKind: K): Amount<K>;
+   *   <K extends AssetKind>(brand: Brand<K>, assetKind: K): Amount<K>;
    * }}
    */
   makeEmpty: (brand, assetKind = /** @type {const} */ ('nat')) => {
     assertRemotable(brand, 'brand');
     assertAssetKind(assetKind);
     const value = helpers[assetKind].doMakeEmpty();
+    // @ts-expect-error XXX narrowing from function overload
     return harden({ brand, value });
   },
   /**
-   * Return the amount representing an empty amount, using another
-   * amount as the template for the brand and assetKind.
+   * Return the amount representing an empty amount, using another amount as the
+   * template for the brand and assetKind.
    *
-   * @template {AssetKind} K
-   * @param {Amount<K>} amount
-   * @returns {Amount<K>}
+   * @template {Amount} A
+   * @param {A} amount
+   * @returns {A}
    */
   makeEmptyFromAmount: amount => {
     assertRecord(amount, 'amount');
     const { brand, value } = amount;
-    // @ts-expect-error cast
     const assetKind = assertValueGetAssetKind(value);
-    // @ts-expect-error cast (ignore b/c erroring in CI but not my IDE)
+    // @ts-expect-error different subtype
     return AmountMath.makeEmpty(brand, assetKind);
   },
   /**
@@ -289,13 +296,13 @@ const AmountMath = {
   },
   isGTE,
   /**
-   * Returns true if the leftAmount equals the rightAmount. We assume
-   * that if isGTE is true in both directions, isEqual is also true
+   * Returns true if the leftAmount equals the rightAmount. We assume that if
+   * isGTE is true in both directions, isEqual is also true
    *
-   * @template {AssetKind} K
-   * @param {Amount<K>} leftAmount
-   * @param {Amount<K>} rightAmount
-   * @param {Brand<K>} [brand]
+   * @template {Amount} A
+   * @param {A} leftAmount
+   * @param {A} rightAmount
+   * @param {Brand} [brand]
    * @returns {boolean}
    */
   isEqual: (leftAmount, rightAmount, brand = undefined) => {
@@ -306,83 +313,80 @@ const AmountMath = {
    * Returns a new amount that is the union of both leftAmount and rightAmount.
    *
    * For fungible amount this means adding the values. For other kinds of
-   * amount, it usually means including all of the elements from both
-   * left and right.
+   * amount, it usually means including all of the elements from both left and
+   * right.
    *
-   * @template {AssetKind} K
-   * @param {Amount<K>} leftAmount
-   * @param {Amount<K>} rightAmount
-   * @param {Brand<K>} [brand]
-   * @returns {Amount<K>}
+   * @template {Amount} A
+   * @param {A} leftAmount
+   * @param {A} rightAmount
+   * @param {Brand} [brand]
+   * @returns {A}
    */
   add: (leftAmount, rightAmount, brand = undefined) => {
     const h = checkLRAndGetHelpers(leftAmount, rightAmount, brand);
     const value = h.doAdd(...coerceLR(h, leftAmount, rightAmount));
+    // @ts-expect-error different subtype
     return harden({ brand: leftAmount.brand, value });
   },
   /**
-   * Returns a new amount that is the leftAmount minus the rightAmount
-   * (i.e. everything in the leftAmount that is not in the
-   * rightAmount). If leftAmount doesn't include rightAmount
-   * (subtraction results in a negative), throw  an error. Because the
-   * left amount must include the right amount, this is NOT equivalent
-   * to set subtraction.
+   * Returns a new amount that is the leftAmount minus the rightAmount (i.e.
+   * everything in the leftAmount that is not in the rightAmount). If leftAmount
+   * doesn't include rightAmount (subtraction results in a negative), throw an
+   * error. Because the left amount must include the right amount, this is NOT
+   * equivalent to set subtraction.
    *
-   * @template {AssetKind} K
-   * @param {Amount<K>} leftAmount
-   * @param {Amount<K>} rightAmount
-   * @param {Brand<K>} [brand]
-   * @returns {Amount<K>}
+   * @template {Amount} L
+   * @template {Amount} R
+   * @param {L} leftAmount
+   * @param {R} rightAmount
+   * @param {Brand} [brand]
+   * @returns {L extends R ? L : never}
    */
   subtract: (leftAmount, rightAmount, brand = undefined) => {
     const h = checkLRAndGetHelpers(leftAmount, rightAmount, brand);
     const value = h.doSubtract(...coerceLR(h, leftAmount, rightAmount));
+    // @ts-expect-error different subtype
     return harden({ brand: leftAmount.brand, value });
   },
   /**
    * Returns the min value between x and y using isGTE
    *
-   * @template {AssetKind} K
-   * @param {Amount<K>} x
-   * @param {Amount<K>} y
-   * @param {Brand<K>} [brand]
-   * @returns {Amount<K>}
+   * @template {Amount} A
+   * @param {A} x
+   * @param {A} y
+   * @param {Brand} [brand]
+   * @returns {A}
    */
   min: (x, y, brand = undefined) =>
     // eslint-disable-next-line no-nested-ternary
     isGTE(x, y, brand)
       ? y
       : isGTE(y, x, brand)
-      ? x
-      : Fail`${x} and ${y} are incomparable`,
+        ? x
+        : Fail`${x} and ${y} are incomparable`,
   /**
    * Returns the max value between x and y using isGTE
    *
-   * @template {AssetKind} K
-   * @param {Amount<K>} x
-   * @param {Amount<K>} y
-   * @param {Brand<K>} [brand]
-   * @returns {Amount<K>}
+   * @template {Amount} A
+   * @param {A} x
+   * @param {A} y
+   * @param {Brand} [brand]
+   * @returns {A}
    */
   max: (x, y, brand = undefined) =>
     // eslint-disable-next-line no-nested-ternary
     isGTE(x, y, brand)
       ? x
       : isGTE(y, x)
-      ? y
-      : Fail`${x} and ${y} are incomparable`,
+        ? y
+        : Fail`${x} and ${y} are incomparable`,
 };
 harden(AmountMath);
 
-/**
- * @param {Amount} amount
- */
-const getAssetKind = amount => {
+/** @param {Amount} amount */
+export const getAssetKind = amount => {
   assertRecord(amount, 'amount');
   const { value } = amount;
-  // @ts-expect-error cast (ignore b/c erroring in CI but not my IDE)
   return assertValueGetAssetKind(value);
 };
 harden(getAssetKind);
-
-export { AmountMath, AssetKind, getAssetKind, assertAssetKind };

package/src/amountStore.d.ts

@@ -0,0 +1,9 @@
+export function makeAmountStore<K extends AssetKind = AssetKind>(state: object, key: string): AmountStore<K>;
+export type AmountStore<K extends AssetKind = AssetKind> = {
+    getAmount: () => Amount<K>;
+    increment: (delta: Amount<K>) => void;
+    decrement: (delta: Amount<K>) => boolean;
+};
+import type { AssetKind } from './types.js';
+import type { Amount } from './types.js';
+//# sourceMappingURL=amountStore.d.ts.map

package/src/amountStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amountStore.d.ts","sourceRoot":"","sources":["amountStore.js"],"names":[],"mappings":"AAkBO,gCALmB,CAAC,SAAd,SAAW,qBACb,MAAM,OACN,MAAM,GACJ,WAAW,CAAC,CAAC,CAAC,CAgB1B;wBA3ByB,CAAC,SAAd,SAAW;eAEV,MAAM,OAAO,CAAC,CAAC;eACf,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,KAAK,IAAI;eAC1B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,KAAK,OAAO;;+BAPN,YAAY;4BAAZ,YAAY"}

package/src/amountStore.js

@@ -0,0 +1,34 @@
+import { AmountMath } from './amountMath.js';
+
+/** @import {Amount, AssetKind} from './types.js' */
+
+/**
+ * @template {AssetKind} [K=AssetKind]
+ * @typedef {object} AmountStore
+ * @property {() => Amount<K>} getAmount
+ * @property {(delta: Amount<K>) => void} increment
+ * @property {(delta: Amount<K>) => boolean} decrement
+ */
+
+/**
+ * @template {AssetKind} [K=AssetKind]
+ * @param {object} state
+ * @param {string} key
+ * @returns {AmountStore<K>}
+ */
+export const makeAmountStore = (state, key) => {
+  return harden({
+    getAmount: () => state[key],
+    increment: delta => {
+      state[key] = AmountMath.add(state[key], delta);
+    },
+    decrement: delta => {
+      if (AmountMath.isGTE(state[key], delta)) {
+        state[key] = AmountMath.subtract(state[key], delta);
+        return true;
+      }
+      return false;
+    },
+  });
+};
+harden(makeAmountStore);

package/src/displayInfo.d.ts

@@ -1,2 +1,5 @@
 export function coerceDisplayInfo(allegedDisplayInfo: AdditionalDisplayInfo, assetKind: AssetKind): DisplayInfo;
+import type { AdditionalDisplayInfo } from './types.js';
+import type { AssetKind } from './types.js';
+import type { DisplayInfo } from './types.js';
 //# sourceMappingURL=displayInfo.d.ts.map

package/src/displayInfo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"displayInfo.d.ts","sourceRoot":"","sources":["displayInfo.js"],"names":[],"mappings":"AAYO,sDAJI,qBAAqB,aACrB,SAAS,GACP,WAAW,CAiBvB"}
+{"version":3,"file":"displayInfo.d.ts","sourceRoot":"","sources":["displayInfo.js"],"names":[],"mappings":"AAcO,sDAJI,qBAAqB,aACrB,SAAS,GACP,WAAW,CAiBvB;2CAtBgE,YAAY;+BAAZ,YAAY;iCAAZ,YAAY"}

package/src/displayInfo.js

@@ -1,10 +1,12 @@
 // @jessie-check
 
-import { Fail } from '@agoric/assert';
+import { Fail } from '@endo/errors';
 import { mustMatch } from '@agoric/store';
 
 import { DisplayInfoShape } from './typeGuards.js';
 
+/** @import {AdditionalDisplayInfo, AssetKind, DisplayInfo} from './types.js' */
+
 /**
  * @param {AdditionalDisplayInfo} allegedDisplayInfo
  * @param {AssetKind} assetKind

package/src/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./amountMath.js";
 export * from "./issuerKit.js";
 export * from "./typeGuards.js";
+export * from "./types-index.js";
 //# sourceMappingURL=index.d.ts.map

package/src/index.js

@@ -1,5 +1,9 @@
 // @jessie-check
+/// <reference types="@agoric/internal/exported" />
 
 export * from './amountMath.js';
 export * from './issuerKit.js';
 export * from './typeGuards.js';
+
+// eslint-disable-next-line import/export
+export * from './types-index.js';

package/src/issuerKit.d.ts

@@ -1,19 +1,44 @@
-export function prepareIssuerKit<K extends AssetKind>(issuerBaggage: MapStore<string, unknown>, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined): IssuerKit<K>;
-export function hasIssuer(baggage: MapStore<string, unknown>): any;
-export function makeDurableIssuerKit<K extends AssetKind>(issuerBaggage: MapStore<string, unknown>, name: string, assetKind?: K | undefined, displayInfo?: AdditionalDisplayInfo | undefined, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined, { elementShape }?: Partial<{
+export function upgradeIssuerKit<K extends AssetKind>(issuerBaggage: import("@agoric/vat-data").Baggage, optShutdownWithFailure?: ShutdownWithFailure | undefined, recoverySetsOption?: RecoverySetsOption | undefined): IssuerKit<K>;
+export function hasIssuer(baggage: import("@agoric/vat-data").Baggage): boolean;
+export function makeDurableIssuerKit<K extends AssetKind>(issuerBaggage: import("@agoric/vat-data").Baggage, name: string, assetKind?: K | undefined, displayInfo?: AdditionalDisplayInfo | undefined, optShutdownWithFailure?: ShutdownWithFailure | undefined, { elementShape, recoverySetsOption }?: Partial<{
     elementShape: Pattern;
+    recoverySetsOption: RecoverySetsOption;
 }> | undefined): IssuerKit<K>;
-export function makeIssuerKit<K extends AssetKind = "nat">(name: string, assetKind?: K | undefined, displayInfo?: AdditionalDisplayInfo | undefined, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined, { elementShape }?: Partial<{
+export function prepareIssuerKit<K extends AssetKind>(issuerBaggage: import("@agoric/vat-data").Baggage, name: string, assetKind?: K | undefined, displayInfo?: AdditionalDisplayInfo | undefined, optShutdownWithFailure?: ShutdownWithFailure | undefined, options?: Partial<{
     elementShape: Pattern;
+    recoverySetsOption: RecoverySetsOption;
 }> | undefined): IssuerKit<K>;
-export type Baggage = import('@agoric/vat-data').Baggage;
+export function makeIssuerKit<K extends AssetKind = "nat">(name: string, assetKind?: K | undefined, displayInfo?: AdditionalDisplayInfo | undefined, optShutdownWithFailure?: ShutdownWithFailure | undefined, { elementShape, recoverySetsOption }?: Partial<{
+    elementShape: Pattern;
+    recoverySetsOption: RecoverySetsOption;
+}> | undefined): IssuerKit<K, any>;
 export type IssuerRecord<K extends AssetKind> = {
     name: string;
     assetKind: K;
     displayInfo: AdditionalDisplayInfo;
     elementShape: Pattern;
 };
+/**
+ * `elementShape`, may only be present for collection-style amounts. If present,
+ * it is a `Pattern` that every element of this issuerKits's amounts must
+ * satisfy. For example, the Zoe Invitation issuerKit uses an elementShape
+ * describing the invitation details for an individual invitation. An invitation
+ * purse or payment has an amount that can only be a set of these. (Though
+ * typically, the amount of an invitation payment is a singleton set. Such a
+ * payment is often referred to in the singular as "an invitation".)
+ *
+ * `recoverySetsOption` added in upgrade. Note that `IssuerOptionsRecord` is
+ * never stored, so we never need to worry about inheriting one from a
+ * predecessor predating the introduction of recovery sets. See
+ * `RecoverySetsOption` for defaulting behavior.
+ */
 export type IssuerOptionsRecord = Partial<{
     elementShape: Pattern;
+    recoverySetsOption: RecoverySetsOption;
 }>;
+import { AssetKind } from './amountMath.js';
+import type { ShutdownWithFailure } from '@agoric/swingset-vat';
+import type { RecoverySetsOption } from './types.js';
+import type { IssuerKit } from './types.js';
+import type { AdditionalDisplayInfo } from './types.js';
 //# sourceMappingURL=issuerKit.d.ts.map

package/src/issuerKit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"issuerKit.d.ts","sourceRoot":"","sources":["issuerKit.js"],"names":[],"mappings":"AA2FO,uMAMN;AASM,mEAAsD;AAmCtD,0GAbI,MAAM;kBAnBmB,OAAO;8BA4C1C;AA+BM,iEAbI,MAAM;kBA9DmB,OAAO;8BA0FxC;sBA3LW,OAAO,kBAAkB,EAAE,OAAO;;UAKlC,MAAM;eACN,CAAC;iBACD,qBAAqB;kBACrB,OAAO;;kCAyFR,QAAQ;IAAC,YAAY,EAAE,OAAO,CAAA;CAAC,CAAC"}
+{"version":3,"file":"issuerKit.d.ts","sourceRoot":"","sources":["issuerKit.js"],"names":[],"mappings":"AA4GO,iCAbkB,CAAC,SAAZ,SAAU,iBACb,OAAO,kBAAkB,EAAE,OAAO,kHAUhC,UAAU,CAAC,CAAC,CA4BxB;AAQM,mCAFI,OAAO,kBAAkB,EAAE,OAAO,WAEgB;AAoDtD,qCA1BkB,CAAC,SAAZ,SAAU,iBAYb,OAAO,kBAAkB,EAAE,OAAO,QAClC,MAAM;kBAtBE,OAAO;wBACD,kBAAkB;iBAgC9B,UAAU,CAAC,CAAC,CA2BxB;AAiCM,iCA1BkB,CAAC,SAAZ,SAAU,iBAYb,OAAO,kBAAkB,EAAE,OAAO,QAClC,MAAM;kBAhFE,OAAO;wBACD,kBAAkB;iBA0F9B,UAAU,CAAC,CAAC,CAuCxB;AAqCM,8BAzBmB,CAAC,SAAb,SAAU,gBAYb,MAAM;kBA1JE,OAAO;wBACD,kBAAkB;iBAoK9B,UAAU,CAAC,EAAE,GAAG,CAAC,CAiB3B;yBAtUsB,CAAC,SAAZ,SAAU;UAEV,MAAM;eACN,CAAC;iBACD,qBAAqB;kBACrB,OAAO;;;;;;;;;;;;;;;;kCA0IR,OAAO,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;IACtB,kBAAkB,EAAE,kBAAkB,CAAC;CACxC,CAAC;0BA1JsC,iBAAiB;yCAKrB,sBAAsB;wCAD0B,YAAY;+BAAZ,YAAY;2CAAZ,YAAY"}