@thecorporation/corp-tools 26.3.23 → 26.3.25

package/dist/index.js

@@ -343,6 +343,10 @@ var CorpAPIClient = class {
     const resp = await this.request("DELETE", path);
     await this.throwIfError(resp);
   }
+  /** Public generic GET for declarative/registry-driven commands. */
+  async fetchJSON(path, params) {
+    return this.get(path, params);
+  }
   // --- Workspace ---
   getStatus() {
     return this.get(`/v1/workspaces/${pathSegment(this.workspaceId)}/status`);
@@ -721,6 +725,13 @@ var CorpAPIClient = class {
   getSignerToken(obligationId) {
     return this.post(`/v1/human-obligations/${pathSegment(obligationId)}/signer-token`);
   }
+  // --- Next Steps ---
+  getEntityNextSteps(entityId) {
+    return this.get(`/v1/entities/${pathSegment(entityId)}/next-steps`);
+  }
+  getWorkspaceNextSteps() {
+    return this.get(`/v1/workspaces/${pathSegment(this.workspaceId)}/next-steps`);
+  }
   // --- Demo ---
   seedDemo(data) {
     return this.post("/v1/demo/seed", data);
@@ -2298,6 +2309,647 @@ var VotingMethod = ["per_capita", "per_unit"];
 var WorkItemActorTypeValue = ["contact", "agent"];
 var WorkItemStatus = ["open", "claimed", "completed", "cancelled"];
 var WorkflowType = ["transfer", "fundraising"];
+
+// src/reference-tracker.ts
+var RESOURCE_KINDS = [
+  "entity",
+  "contact",
+  "share_transfer",
+  "invoice",
+  "bank_account",
+  "payment",
+  "payroll_run",
+  "distribution",
+  "reconciliation",
+  "tax_filing",
+  "deadline",
+  "classification",
+  "body",
+  "meeting",
+  "seat",
+  "agenda_item",
+  "resolution",
+  "document",
+  "work_item",
+  "agent",
+  "valuation",
+  "safe_note",
+  "instrument",
+  "share_class",
+  "round",
+  "service_request"
+];
+var VALID_RESOURCE_KINDS = new Set(RESOURCE_KINDS);
+var MAX_REFERENCE_INPUT_LEN = 256;
+function normalize(value) {
+  return value.trim().toLowerCase();
+}
+function validateReferenceInput(value, field, options = {}) {
+  const trimmed = value.trim();
+  if (!options.allowEmpty && trimmed.length === 0) {
+    throw new Error(`${field} cannot be empty.`);
+  }
+  if (trimmed.length > MAX_REFERENCE_INPUT_LEN) {
+    throw new Error(`${field} must be at most ${MAX_REFERENCE_INPUT_LEN} characters.`);
+  }
+  return trimmed;
+}
+function shortId(value) {
+  return String(value ?? "").slice(0, 8);
+}
+function slugify(value) {
+  return String(value ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function isOpaqueUuid(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    value.trim()
+  );
+}
+function isShortIdCandidate(value) {
+  const trimmed = value.trim();
+  return /^[0-9a-f-]{4,}$/i.test(trimmed) || /^[a-z]+_[a-z0-9_-]{3,}$/i.test(trimmed);
+}
+function parseLastReference(value) {
+  const trimmed = validateReferenceInput(value, "reference", { allowEmpty: false }).toLowerCase();
+  if (trimmed === "_" || trimmed === "@last") {
+    return { isLast: true };
+  }
+  if (trimmed.startsWith("@last:")) {
+    const kind = trimmed.slice(6);
+    if (!VALID_RESOURCE_KINDS.has(kind)) {
+      throw new Error(`Unknown reference kind: ${kind}`);
+    }
+    return { isLast: true, kind };
+  }
+  return { isLast: false };
+}
+function uniqueStrings(values) {
+  const out = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (!value) continue;
+    const trimmed = value.trim();
+    if (!trimmed) continue;
+    out.add(normalize(trimmed));
+    const slug = slugify(trimmed);
+    if (slug) out.add(slug);
+  }
+  return out;
+}
+function kindLabel(kind) {
+  return kind.replaceAll("_", " ");
+}
+function isEntityScopedKind(kind) {
+  return kind !== "entity" && kind !== "agent";
+}
+function extractId(record, fields) {
+  for (const field of fields) {
+    const value = record[field];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function isValidResourceKind(kind) {
+  return VALID_RESOURCE_KINDS.has(kind);
+}
+function describeReferenceRecord(kind, record) {
+  const specs = {
+    entity: { idFields: ["entity_id", "id"], labelFields: ["legal_name", "name"] },
+    contact: { idFields: ["contact_id", "id"], labelFields: ["name", "email"] },
+    share_transfer: {
+      idFields: ["transfer_id", "id"],
+      labelFields: ["from_holder", "to_holder", "transfer_type", "status"]
+    },
+    invoice: {
+      idFields: ["invoice_id", "id"],
+      labelFields: ["customer_name", "description", "due_date"]
+    },
+    bank_account: {
+      idFields: ["bank_account_id", "account_id", "id"],
+      labelFields: ["bank_name", "account_type"]
+    },
+    payment: {
+      idFields: ["payment_id", "id"],
+      labelFields: ["recipient", "description", "payment_method"]
+    },
+    payroll_run: {
+      idFields: ["payroll_run_id", "id"],
+      labelFields: ["pay_period_start", "pay_period_end"]
+    },
+    distribution: {
+      idFields: ["distribution_id", "id"],
+      labelFields: ["description", "distribution_type"]
+    },
+    reconciliation: {
+      idFields: ["reconciliation_id", "id"],
+      labelFields: ["as_of_date", "status"]
+    },
+    tax_filing: {
+      idFields: ["filing_id", "id"],
+      labelFields: ["document_type", "tax_year"]
+    },
+    deadline: {
+      idFields: ["deadline_id", "id"],
+      labelFields: ["deadline_type", "description", "due_date"]
+    },
+    classification: {
+      idFields: ["classification_id", "id"],
+      labelFields: ["contractor_name", "state", "risk_level"]
+    },
+    body: { idFields: ["body_id", "id"], labelFields: ["name"] },
+    meeting: { idFields: ["meeting_id", "id"], labelFields: ["title", "name"] },
+    seat: {
+      idFields: ["seat_id", "id"],
+      labelFields: ["seat_name", "title", "holder_name", "holder", "holder_email"]
+    },
+    agenda_item: { idFields: ["agenda_item_id", "item_id", "id"], labelFields: ["title"] },
+    resolution: { idFields: ["resolution_id", "id"], labelFields: ["title"] },
+    document: { idFields: ["document_id", "id"], labelFields: ["title", "name"] },
+    work_item: { idFields: ["work_item_id", "id"], labelFields: ["title"] },
+    agent: { idFields: ["agent_id", "id"], labelFields: ["name"] },
+    valuation: {
+      idFields: ["valuation_id", "id"],
+      labelFields: ["valuation_type", "effective_date", "date"]
+    },
+    safe_note: {
+      idFields: ["safe_note_id", "safe_id", "id"],
+      labelFields: ["investor_name", "investor", "safe_type"]
+    },
+    instrument: { idFields: ["instrument_id", "id"], labelFields: ["symbol", "kind", "name"] },
+    share_class: {
+      idFields: ["share_class_id", "id"],
+      labelFields: ["class_code", "name", "share_class"]
+    },
+    round: { idFields: ["round_id", "equity_round_id", "id"], labelFields: ["name"] },
+    service_request: {
+      idFields: ["request_id", "service_request_id", "id"],
+      labelFields: ["service_slug", "status"]
+    }
+  };
+  const spec = specs[kind];
+  const id = extractId(record, spec.idFields);
+  if (!id) {
+    return null;
+  }
+  const labels = spec.labelFields.map((field) => record[field]).filter((value) => typeof value === "string" && value.trim().length > 0);
+  const persistedHandle = typeof record.handle === "string" && record.handle.trim().length > 0 ? record.handle.trim() : void 0;
+  let label = labels[0] ?? id;
+  if (kind === "share_transfer") {
+    const fromHolder = typeof record.from_holder === "string" ? record.from_holder.trim() : "";
+    const toHolder = typeof record.to_holder === "string" ? record.to_holder.trim() : "";
+    const transferType = typeof record.transfer_type === "string" ? record.transfer_type.trim() : "";
+    const composite = [
+      fromHolder && toHolder ? `${fromHolder}-to-${toHolder}` : "",
+      transferType
+    ].filter(Boolean).join("-");
+    if (composite) {
+      label = composite;
+    }
+  }
+  return {
+    id,
+    label,
+    tokens: uniqueStrings([id, persistedHandle, ...labels]),
+    raw: record
+  };
+}
+function getReferenceId(kind, record) {
+  return describeReferenceRecord(kind, record)?.id;
+}
+function getReferenceLabel(kind, record) {
+  return describeReferenceRecord(kind, record)?.label;
+}
+function getReferenceAlias(kind, record) {
+  if (typeof record.handle === "string" && record.handle.trim().length > 0) {
+    return record.handle.trim();
+  }
+  const described = describeReferenceRecord(kind, record);
+  if (!described) return void 0;
+  const alias = slugify(described.label);
+  return alias || shortId(described.id);
+}
+function matchRank(record, normalizedQuery) {
+  if (!normalizedQuery || normalizedQuery === "*") {
+    return 5;
+  }
+  if (normalize(record.id) === normalizedQuery) {
+    return 0;
+  }
+  if (record.tokens.has(normalizedQuery)) {
+    return 1;
+  }
+  if (normalize(record.id).startsWith(normalizedQuery)) {
+    return 2;
+  }
+  if (Array.from(record.tokens).some((token) => token.startsWith(normalizedQuery))) {
+    return 3;
+  }
+  return 4;
+}
+var ReferenceTracker = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  /** Remember a reference for @last reuse. */
+  remember(kind, id, entityId) {
+    this.storage.setLastReference(kind, id, entityId);
+  }
+  /** Resolve @last / @last:kind references. */
+  resolveLastReference(ref, kind, entityId) {
+    const parsed = parseLastReference(ref);
+    if (!parsed.isLast) return parsed;
+    const lastKind = parsed.kind ?? kind;
+    if (lastKind !== kind) {
+      throw new Error(
+        `@last:${lastKind} cannot be used where a ${kindLabel(kind)} reference is required.`
+      );
+    }
+    const id = this.storage.getLastReference(lastKind, entityId);
+    return { ...parsed, id };
+  }
+  /** Find the single best match for a query against a list of records. */
+  findBestMatch(kind, query, records) {
+    const matches = this.findMatches(kind, query, records);
+    return matches.length > 0 ? matches[0] : null;
+  }
+  /** Find all matching records ranked by relevance. */
+  findMatches(kind, query, records) {
+    const trimmedQuery = validateReferenceInput(query, "query", { allowEmpty: true });
+    const described = records.map((record) => describeReferenceRecord(kind, record)).filter((record) => record !== null);
+    const normalizedQuery = normalize(trimmedQuery);
+    const matches = described.filter((record) => {
+      if (!normalizedQuery || normalizedQuery === "*") {
+        return true;
+      }
+      if (normalize(record.id).startsWith(normalizedQuery)) {
+        return true;
+      }
+      if (record.tokens.has(normalizedQuery)) {
+        return true;
+      }
+      return Array.from(record.tokens).some((token) => token.includes(normalizedQuery));
+    }).sort(
+      (left, right) => matchRank(left, normalizedQuery) - matchRank(right, normalizedQuery) || left.label.localeCompare(right.label) || left.id.localeCompare(right.id)
+    );
+    return matches.map((record) => ({
+      kind,
+      id: record.id,
+      short_id: shortId(record.id),
+      label: record.label,
+      alias: getReferenceAlias(kind, record.raw),
+      raw: record.raw
+    }));
+  }
+};
+
+// src/workflows/equity-helpers.ts
+function normalizedGrantType2(grantType) {
+  return grantType.trim().toLowerCase().replaceAll("-", "_").replaceAll(" ", "_");
+}
+function expectedInstrumentKinds2(grantType) {
+  switch (normalizedGrantType2(grantType)) {
+    case "common":
+    case "common_stock":
+      return ["common_equity"];
+    case "preferred":
+    case "preferred_stock":
+      return ["preferred_equity"];
+    case "unit":
+    case "membership_unit":
+      return ["membership_unit"];
+    case "option":
+    case "options":
+    case "stock_option":
+    case "iso":
+    case "nso":
+      return ["option_grant"];
+    case "rsa":
+      return ["common_equity", "preferred_equity"];
+    default:
+      return [];
+  }
+}
+function grantRequiresCurrent409a2(grantType, instrumentKind) {
+  return instrumentKind?.toLowerCase() === "option_grant" || expectedInstrumentKinds2(grantType).includes("option_grant");
+}
+function buildInstrumentCreationHint(grantType) {
+  const normalized = normalizedGrantType2(grantType);
+  switch (normalized) {
+    case "preferred":
+    case "preferred_stock":
+      return "Create one with: corp cap-table create-instrument --kind preferred_equity --symbol SERIES-A --authorized-units <shares>";
+    case "option":
+    case "options":
+    case "stock_option":
+    case "iso":
+    case "nso":
+      return "Create one with: corp cap-table create-instrument --kind option_grant --symbol OPTION-PLAN --authorized-units <shares>";
+    case "membership_unit":
+    case "unit":
+      return "Create one with: corp cap-table create-instrument --kind membership_unit --symbol UNIT --authorized-units <units>";
+    case "common":
+    case "common_stock":
+      return "Create one with: corp cap-table create-instrument --kind common_equity --symbol COMMON --authorized-units <shares>";
+    default:
+      return "Create a matching instrument first, then pass --instrument-id explicitly.";
+  }
+}
+function resolveInstrumentForGrant2(instruments, grantType, explicitInstrumentId) {
+  if (explicitInstrumentId) {
+    const explicit = instruments.find(
+      (instrument) => instrument.instrument_id === explicitInstrumentId
+    );
+    if (!explicit) {
+      throw new Error(
+        `Instrument ${explicitInstrumentId} was not found on the cap table.`
+      );
+    }
+    return explicit;
+  }
+  const kinds = expectedInstrumentKinds2(grantType);
+  if (kinds.length === 0) {
+    throw new Error(
+      `No default instrument mapping exists for grant type "${grantType}". ${buildInstrumentCreationHint(grantType)}`
+    );
+  }
+  const match = instruments.find(
+    (instrument) => kinds.includes(String(instrument.kind).toLowerCase())
+  );
+  if (!match) {
+    throw new Error(
+      `No instrument found for grant type "${grantType}". Expected one of: ${kinds.join(", ")}. ${buildInstrumentCreationHint(grantType)}`
+    );
+  }
+  return match;
+}
+async function entityHasActiveBoard2(client, entityId) {
+  const bodies = await client.listGovernanceBodies(entityId);
+  return bodies.some(
+    (body) => String(body.body_type ?? "").toLowerCase() === "board_of_directors" && String(body.status ?? "active").toLowerCase() === "active"
+  );
+}
+async function ensureIssuancePreflight2(client, entityId, grantType, instrument, meetingId, resolutionId) {
+  if (!meetingId || !resolutionId) {
+    if (await entityHasActiveBoard2(client, entityId)) {
+      throw new Error(
+        "Board approval is required before issuing this round. Pass --meeting-id and --resolution-id from a passed board vote."
+      );
+    }
+  }
+  if (!grantRequiresCurrent409a2(grantType, instrument?.kind)) {
+    return;
+  }
+  try {
+    await client.getCurrent409a(entityId);
+  } catch (err) {
+    const msg = String(err);
+    if (msg.includes("404") || msg.includes("Not found") || msg.includes("not found")) {
+      throw new Error(
+        "Stock option issuances require a current approved 409A valuation. Create and approve one first with: corp cap-table create-valuation --type four_oh_nine_a --date YYYY-MM-DD --methodology <method>; corp cap-table submit-valuation <valuation-ref>; corp cap-table approve-valuation <valuation-ref> --resolution-id <resolution-ref>"
+      );
+    }
+    throw err;
+  }
+}
+
+// src/workflows/issue-equity.ts
+async function issueEquity(client, args) {
+  const steps = [];
+  try {
+    const capTable = await client.getCapTable(args.entityId);
+    const issuerLegalEntityId = capTable.issuer_legal_entity_id;
+    if (!issuerLegalEntityId) {
+      return {
+        success: false,
+        error: "No issuer legal entity found. Has this entity been formed with a cap table?",
+        steps
+      };
+    }
+    const instruments = capTable.instruments ?? [];
+    if (!instruments.length) {
+      return {
+        success: false,
+        error: "No instruments found on cap table. Create one with: corp cap-table create-instrument --kind common_equity --symbol COMMON --authorized-units <shares>",
+        steps
+      };
+    }
+    const instrument = resolveInstrumentForGrant2(
+      instruments,
+      args.grantType,
+      args.instrumentId
+    );
+    const instrumentId = instrument.instrument_id;
+    steps.push({
+      name: "resolve_instrument",
+      status: "ok",
+      data: {
+        instrument_id: instrumentId,
+        symbol: instrument.symbol,
+        kind: instrument.kind
+      },
+      detail: `Using instrument: ${instrument.symbol} (${instrument.kind})`
+    });
+    await ensureIssuancePreflight2(
+      client,
+      args.entityId,
+      args.grantType,
+      instrument,
+      args.meetingId,
+      args.resolutionId
+    );
+    steps.push({ name: "preflight", status: "ok" });
+    const round = await client.startEquityRound({
+      entity_id: args.entityId,
+      name: `${args.grantType} grant \u2014 ${args.recipientName}`,
+      issuer_legal_entity_id: issuerLegalEntityId
+    });
+    const roundId = round.round_id ?? round.equity_round_id;
+    steps.push({
+      name: "start_round",
+      status: "ok",
+      data: { round_id: roundId }
+    });
+    const securityData = {
+      entity_id: args.entityId,
+      instrument_id: instrumentId,
+      quantity: args.shares,
+      recipient_name: args.recipientName,
+      grant_type: args.grantType
+    };
+    if (args.recipientEmail) securityData.email = args.recipientEmail;
+    const existingHolders = capTable.holders ?? [];
+    const matchingHolder = existingHolders.find((h) => {
+      const nameMatch = String(h.name ?? "").toLowerCase() === args.recipientName.toLowerCase();
+      const emailMatch = args.recipientEmail && String(h.email ?? "").toLowerCase() === args.recipientEmail.toLowerCase();
+      return nameMatch || emailMatch;
+    });
+    if (matchingHolder) {
+      const holderId = matchingHolder.holder_id ?? matchingHolder.contact_id ?? matchingHolder.id;
+      if (holderId) securityData.holder_id = holderId;
+    }
+    await client.addRoundSecurity(roundId, securityData);
+    steps.push({ name: "add_security", status: "ok" });
+    const issuePayload = {
+      entity_id: args.entityId
+    };
+    if (args.meetingId) issuePayload.meeting_id = args.meetingId;
+    if (args.resolutionId) issuePayload.resolution_id = args.resolutionId;
+    const result = await client.issueRound(roundId, issuePayload);
+    steps.push({ name: "issue_round", status: "ok" });
+    return {
+      success: true,
+      data: {
+        ...result,
+        round_id: roundId,
+        round,
+        shares: args.shares,
+        grant_type: args.grantType,
+        recipient: args.recipientName
+      },
+      steps
+    };
+  } catch (err) {
+    steps.push({
+      name: "error",
+      status: "failed",
+      detail: String(err)
+    });
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+      steps
+    };
+  }
+}
+
+// src/workflows/issue-safe.ts
+async function issueSafe(client, args) {
+  const steps = [];
+  const safeType = args.safeType ?? "post_money";
+  try {
+    await ensureIssuancePreflight2(
+      client,
+      args.entityId,
+      safeType,
+      void 0,
+      args.meetingId,
+      args.resolutionId
+    );
+    steps.push({ name: "preflight", status: "ok" });
+    const body = {
+      entity_id: args.entityId,
+      investor_name: args.investorName,
+      principal_amount_cents: args.amountCents,
+      valuation_cap_cents: args.valuationCapCents,
+      safe_type: safeType
+    };
+    if (args.email) body.email = args.email;
+    if (args.meetingId) body.meeting_id = args.meetingId;
+    if (args.resolutionId) body.resolution_id = args.resolutionId;
+    const result = await client.createSafeNote(body);
+    steps.push({ name: "create_safe", status: "ok" });
+    return {
+      success: true,
+      data: {
+        ...result,
+        investor_name: args.investorName,
+        amount_cents: args.amountCents,
+        valuation_cap_cents: args.valuationCapCents
+      },
+      steps
+    };
+  } catch (err) {
+    steps.push({
+      name: "error",
+      status: "failed",
+      detail: String(err)
+    });
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+      steps
+    };
+  }
+}
+
+// src/workflows/written-consent.ts
+async function writtenConsent(client, args) {
+  const steps = [];
+  try {
+    const payload = {
+      entity_id: args.entityId,
+      body_id: args.bodyId,
+      title: args.title,
+      description: args.description
+    };
+    const result = await client.writtenConsent(payload);
+    const meetingId = String(result.meeting_id ?? "");
+    steps.push({
+      name: "create_written_consent",
+      status: "ok",
+      data: { meeting_id: meetingId || void 0 }
+    });
+    if (meetingId) {
+      try {
+        const seats = await client.getGovernanceSeats(
+          args.bodyId,
+          args.entityId
+        );
+        const seatIds = seats.map(
+          (s) => String(
+            s.seat_id ?? s.id ?? ""
+          )
+        ).filter((id) => id.length > 0);
+        if (seatIds.length > 0) {
+          await client.conveneMeeting(meetingId, args.entityId, {
+            present_seat_ids: seatIds
+          });
+          steps.push({
+            name: "auto_open",
+            status: "ok",
+            data: { seat_count: seatIds.length },
+            detail: `Opened with ${seatIds.length} seat(s) present`
+          });
+        } else {
+          steps.push({
+            name: "auto_open",
+            status: "skipped",
+            detail: "No seats found on body"
+          });
+        }
+      } catch {
+        steps.push({
+          name: "auto_open",
+          status: "skipped",
+          detail: "Failed to auto-open meeting (non-fatal)"
+        });
+      }
+    } else {
+      steps.push({
+        name: "auto_open",
+        status: "skipped",
+        detail: "No meeting_id returned"
+      });
+    }
+    return {
+      success: true,
+      data: { ...result, meeting_id: meetingId || void 0 },
+      steps
+    };
+  } catch (err) {
+    steps.push({
+      name: "error",
+      status: "failed",
+      detail: String(err)
+    });
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+      steps
+    };
+  }
+}
 export {
   AccountType,
   AgendaItemStatus,
@@ -2366,10 +3018,12 @@ export {
   QuorumStatus,
   QuorumThreshold,
   READ_ONLY_TOOLS,
+  RESOURCE_KINDS,
   ReceiptStatus,
   ReconciliationStatus,
   Recurrence,
   ReferenceKind,
+  ReferenceTracker,
   ResolutionType,
   RiskLevel,
   SYSTEM_PROMPT_BASE,
@@ -2396,18 +3050,45 @@ export {
   WorkItemActorTypeValue,
   WorkItemStatus,
   WorkflowType,
+  buildInstrumentCreationHint,
+  describeReferenceRecord,
   describeToolCall,
   ensureEnvFile,
+  ensureIssuancePreflight2 as ensureIssuancePreflight,
   ensureSafeInstrument,
+  entityHasActiveBoard2 as entityHasActiveBoard,
   executeTool,
+  expectedInstrumentKinds2 as expectedInstrumentKinds,
+  extractId,
   formatConfigSection,
   generateFernetKey,
   generateSecret,
+  getReferenceAlias,
+  getReferenceId,
+  getReferenceLabel,
+  grantRequiresCurrent409a2 as grantRequiresCurrent409a,
+  isEntityScopedKind,
+  isOpaqueUuid,
+  isShortIdCandidate,
+  isValidResourceKind,
   isWriteTool,
+  issueEquity,
+  issueSafe,
+  kindLabel,
   loadEnvFile,
+  matchRank,
+  normalize,
+  normalizedGrantType2 as normalizedGrantType,
+  parseLastReference,
   processRequest,
   provisionWorkspace,
   resetCache,
-  resolveBinaryPath
+  resolveBinaryPath,
+  resolveInstrumentForGrant2 as resolveInstrumentForGrant,
+  shortId,
+  slugify,
+  uniqueStrings,
+  validateReferenceInput,
+  writtenConsent
 };
 //# sourceMappingURL=index.js.map