@tallyrelease/core 0.5.0-beta.14 → 0.5.0-beta.24

package/dist/affected.d.ts

@@ -1,46 +1,5 @@
-import type { Warning } from "./errors.js";
+import type { AffectedDoc, AffectedOptions } from "./model/affected-types.js";
 import type { GitReader } from "./plugin.js";
 import type { Workspace } from "./workspace.js";
-export type BaseSource = "cli" | "push-before" | "pr-merge-base" | "merge-group" | "forge-last-success" | "local-merge-base" | "none";
-export type AffectedReason = "direct" | "dependent" | "global" | "all" | "group";
-export interface AffectedUnit {
-    id: string;
-    /** Unit root, `.` for the repo root. */
-    path: string;
-    plugin: string;
-    reason: AffectedReason;
-    /** Affected direct dependencies of a dependent, or affected mates of a group member. */
-    via: string[];
-    /** True unless the unit's version is `none`. */
-    released: boolean;
-    /** Sorted unit tags. */
-    tags: string[];
-}
-/** `tallyrelease affected --json`, schema 1. */
-export interface AffectedDoc {
-    schema: 1;
-    tool: string;
-    repo: string;
-    branch: string;
-    head: string;
-    build: {
-        base: string | null;
-        baseSource: BaseSource;
-        all: boolean;
-        globalInputs: string[];
-    };
-    units: AffectedUnit[];
-    unattributed: string[];
-    warnings: Warning[];
-}
-export interface AffectedOptions {
-    /** For example `tallyrelease@0.1.0`. */
-    tool: string;
-    branch: string;
-    head: string;
-    /** Null marks every unit affected without a diff. */
-    base: string | null;
-    baseSource: BaseSource;
-}
 /** Computes the build set for `base..head` from a tree-to-tree diff. */
 export declare const computeAffected: (workspace: Workspace, git: GitReader, opts: AffectedOptions) => Promise<AffectedDoc>;

package/dist/branches.d.ts

@@ -1,23 +1,7 @@
-import type { Plan } from "./plan.js";
-import type { BumpLevel } from "./plugin.js";
-import type { ReleaseItem as PrItem } from "./release-items.js";
-import type { BranchRule } from "./release.js";
+import type { BranchRule, LimitItem, LimitSubject, Line } from "./model/branch-types.js";
+import type { Plan } from "./model/plan-types.js";
+import type { ReleaseItem } from "./release-items.js";
 import type { Workspace } from "./workspace.js";
-/** The branch rule matching the planned branch. */
-export interface Line {
-    rule: string;
-    kind: "default" | "maintenance";
-    /** Rendered with the rule's captures. */
-    channel: string | null;
-    /** Maintenance rules: `minor` for `{major}`, `patch` with `{minor}`. */
-    maxBump: "minor" | "patch" | null;
-    absolute: {
-        unit: string | null;
-        group: string | null;
-        major: number;
-        minor?: number;
-    } | null;
-}
 /**
  * Validates rule names, `unit`/`group` and channels: `E_BRANCH_RULE`, `E_CHANNEL_WILDCARD`,
  * `E_CHANNEL_INVALID` and `E_CHANNEL_DUPLICATE`.
@@ -28,39 +12,7 @@ export declare const validateBranches: (rules: readonly BranchRule[]) => void;
  * maintenance rule with `{major}` gets an absolute check for its `unit` or
  * `group`, else for `single`, the repo's only release item.
  */
-export declare const matchBranch: (rules: readonly BranchRule[], branch: string, single?: ReleaseItem | null) => Line | null;
-/** An ungrouped released unit or a fixed group. */
-export interface ReleaseItem {
-    unit: string | null;
-    group: string | null;
-}
-/** Major and minor of a version. */
-export interface Core {
-    major: number;
-    minor: number;
-}
-/** A formatted version with its core. */
-export interface CoreVersion extends Core {
-    version: string;
-}
-/** A commit that contributes to a release item's `next`. */
-export interface LimitCommit {
-    sha?: string;
-    subject: string;
-    /** Null for a Release-As only commit. */
-    level: BumpLevel | null;
-    /** Absorbed unit the change came through. */
-    via?: string;
-    /** The Release-As value it sets. */
-    releaseAs?: CoreVersion;
-}
-export interface LimitItem extends ReleaseItem {
-    /** Null on a first release. */
-    from: CoreVersion | null;
-    /** Null without a pending release. */
-    next: CoreVersion | null;
-    commits: readonly LimitCommit[];
-}
+export declare const matchBranch: (rules: readonly BranchRule[], branch: string, single?: LimitSubject | null) => Line | null;
 /**
  * Maintenance limits: `E_CAP_BASE` when the absolute item's `from` is off the
  * rule's line, `E_CAP` when a release item's `next` leaves the line of its
@@ -83,4 +35,4 @@ export interface MaintenanceCut {
  * maintenance rule with `{major}` and no `*` that targets the item or nothing,
  * rendered from `from`, at the item's base tag; else undefined.
  */
-export declare const maintenanceCut: (workspace: Workspace, plan: Plan, item: PrItem) => MaintenanceCut | undefined;
+export declare const maintenanceCut: (workspace: Workspace, plan: Plan, item: ReleaseItem) => MaintenanceCut | undefined;

package/dist/bump.d.ts

@@ -0,0 +1,27 @@
+import type { RangeFacts } from "./model/facts-types.js";
+import type { BumpLevel, Change } from "./plugin.js";
+import type { ReleaseSettings } from "./release-settings.js";
+/**
+ * A Change of a released unit; `via` names the first absorbed unit (by id) a
+ * change not attributed to the unit came through.
+ */
+export interface UnitChange {
+    readonly change: Change;
+    readonly via?: string;
+}
+/**
+ * Unreleased units reachable over `id`'s dependencies, never stepping into or
+ * through a released unit.
+ */
+export declare const reach: (id: string, dependencies: ReadonlyMap<string, readonly string[]>, released: ReadonlySet<string>) => Set<string>;
+/**
+ * Level of one change. While the major is 0, breaking changes use
+ * `preMajor.breaking` and changes whose type level is minor `preMajor.feat`.
+ * An absorbed change contributes `bumps.absorbed` when its own level is set
+ * (`minor` caps it at minor).
+ */
+export declare const changeLevel: ({ change, via }: UnitChange, settings: ReleaseSettings, preMajor: boolean) => BumpLevel | null;
+/** Max level over the changes. */
+export declare const ownBump: (changes: readonly UnitChange[], settings: ReleaseSettings, preMajor: boolean) => BumpLevel | null;
+/** Changes of the range attributed to the unit or to an absorbed unit. */
+export declare const unitChanges: (id: string, range: RangeFacts, absorbed: ReadonlySet<string>) => UnitChange[];

package/dist/bump.js

@@ -0,0 +1,48 @@
+import { maxLevel } from "./util.js";
+/**
+ * Unreleased units reachable over `id`'s dependencies, never stepping into or
+ * through a released unit.
+ */
+export const reach = (id, dependencies, released) => {
+    const found = new Set();
+    const queue = [id];
+    for (const v of queue) {
+        for (const w of dependencies.get(v) ?? []) {
+            if (!released.has(w) && !found.has(w)) {
+                found.add(w);
+                queue.push(w);
+            }
+        }
+    }
+    return found;
+};
+/**
+ * Level of one change. While the major is 0, breaking changes use
+ * `preMajor.breaking` and changes whose type level is minor `preMajor.feat`.
+ * An absorbed change contributes `bumps.absorbed` when its own level is set
+ * (`minor` caps it at minor).
+ */
+export const changeLevel = ({ change, via }, settings, preMajor) => {
+    const typed = settings.bumps.get(change.type) ?? null;
+    const level = change.breaking
+        ? preMajor
+            ? settings.preMajor.breaking
+            : "major"
+        : preMajor && typed === "minor"
+            ? settings.preMajor.feat
+            : typed;
+    if (via === undefined || level === null) {
+        return level;
+    }
+    return settings.absorbed === "minor" && level !== "patch" ? "minor" : "patch";
+};
+/** Max level over the changes. */
+export const ownBump = (changes, settings, preMajor) => changes.reduce((bump, change) => maxLevel(bump, changeLevel(change, settings, preMajor)), null);
+/** Changes of the range attributed to the unit or to an absorbed unit. */
+export const unitChanges = (id, range, absorbed) => range.changes.flatMap(({ change, units }) => {
+    if (units.includes(id)) {
+        return [{ change }];
+    }
+    const via = units.find((u) => absorbed.has(u));
+    return via === undefined ? [] : [{ change, via }];
+});

package/dist/changelog.d.ts

@@ -1,4 +1,4 @@
-import type { PlanChange, Plan } from "./plan.js";
+import type { PlanChange, Plan } from "./model/plan-types.js";
 import type { Unit, VersionScheme } from "./plugin.js";
 import type { Workspace } from "./workspace.js";
 /** `<root>/CHANGELOG.md` of a unit. */

package/dist/explain.d.ts

@@ -1,5 +1,5 @@
 import type { Warning } from "./errors.js";
-import type { Plan, PlanChange, PlanOptions, UnitPlan } from "./plan.js";
+import type { Plan, PlanChange, PlanOptions, UnitPlan } from "./model/plan-types.js";
 import type { GitReader } from "./plugin.js";
 import type { Workspace } from "./workspace.js";
 export interface ExplainedChange extends PlanChange {

package/dist/facts.d.ts

@@ -1,91 +1,10 @@
-import type { Warning } from "./errors.js";
-import type { Change, GitReader, ReadonlyFs } from "./plugin.js";
-import type { UnitTag } from "./tags.js";
+import type { PlanFacts } from "./model/facts-types.js";
+import type { GitReader, ReadonlyFs } from "./plugin.js";
 import type { Workspace } from "./workspace.js";
 export interface FactsOptions {
     head: string;
     fs: ReadonlyFs;
     debug?: (message: string) => void;
 }
-/** A Change with the ids of the units it is attributed to. */
-export interface AttributedChange {
-    readonly change: Change;
-    /** Sorted. */
-    readonly units: readonly string[];
-}
-/**
- * Changes of `(from, head]`, in core commit order, attributed to all units. A
- * unit's consumers read only its own range (`UnitFacts.from`), filtered to the
- * unit and the units it absorbs.
- */
-export interface RangeFacts {
-    readonly from: string | null;
-    readonly changes: readonly AttributedChange[];
-}
-export interface UnitFacts {
-    readonly id: string;
-    /** Fixed group name. */
-    readonly group: string | null;
-    /**
-     * Range key, null from the root: the base tag commit; for a group member
-     * its own base tag when that descends from the group base tag, else the
-     * group base tag.
-     */
-    readonly from: string | null;
-    /** Every matched tag, reachable or not, scheme-sorted. */
-    readonly tags: readonly UnitTag[];
-    /** Highest stable tag merged into head. */
-    readonly baseTag: UnitTag | null;
-    /** Source of the `from` version: the group base tag for members, else `baseTag`. */
-    readonly fromTag: UnitTag | null;
-    /** Highest stable tag on head's first-parent chain. */
-    readonly lineBaseTag: UnitTag | null;
-    /**
-     * Without a line base and with a root other than `.`: the oldest commit on
-     * head's first-parent chain that touches the unit root.
-     */
-    readonly introduced: string | null;
-    /**
-     * First-parent commits since the line base; without one, since and
-     * including `introduced`, else `total`.
-     */
-    readonly sinceLineBase: number;
-    readonly total: number;
-    /** Changes since the base tag attributed to this unit, core commit order. */
-    readonly changes: readonly AttributedChange[];
-    /** Qualified Release-As values naming this unit, core commit order. */
-    readonly releaseAs: readonly {
-        sha?: string;
-        version: string;
-    }[];
-}
-/**
- * A fixed group. Base and line base are the highest member tags as for a
- * unit; equal versions prefer the tag whose commit descends from the other's.
- */
-export interface GroupFacts {
-    readonly name: string;
-    readonly members: readonly string[];
-    /** Highest stable member tag merged into head. */
-    readonly baseTag: UnitTag | null;
-    /** Highest stable member tag on head's first-parent chain. */
-    readonly lineBaseTag: UnitTag | null;
-    /** Without a line base, the max over the members. */
-    readonly sinceLineBase: number;
-}
-/** Git and intent data of every released unit, collected before release math. */
-export interface PlanFacts {
-    readonly head: string;
-    /** Released units, sorted by id. */
-    readonly units: readonly UnitFacts[];
-    /** One entry per distinct base tag commit. */
-    readonly ranges: readonly RangeFacts[];
-    /** Sorted by name. */
-    readonly groups: readonly GroupFacts[];
-    /** Every tag name, sorted. */
-    readonly tagNames: readonly string[];
-    /** Warnings logged by intent sources and for unknown explicit units. */
-    readonly warnings: readonly Warning[];
-}
 /** Runs every `GitReader` and intent source call a plan needs. */
 export declare const collectPlanFacts: (workspace: Workspace, git: GitReader, opts: FactsOptions) => Promise<PlanFacts>;

package/dist/index.d.ts

@@ -1,11 +1,12 @@
 /** @deprecated Unused, will be removed in 1.0. */
 export declare const version = "0.0.0";
-export type { AffectedDoc, AffectedOptions, AffectedReason, AffectedUnit, BaseSource, } from "./affected.js";
+export type { AffectedDoc, AffectedOptions, AffectedReason, AffectedUnit, BaseSource, } from "./model/affected-types.js";
 export type { ChangelogDependency, ChangelogInput } from "./changelog.js";
 export type { CodeDoc, CodeOf, CodeRegistry, ErrorCode, WarningCode, } from "./codes.js";
 export type { ParsedCommit } from "./conventional.js";
 export type { ExplainedChange, ExplainOptions, ReleaseAsFooter, UnitExplanation, } from "./explain.js";
-export type { GroupPlan, Plan, PlanChange, PlanLine, PlanOptions, ReleasedUnit, UnitPlan, } from "./plan.js";
+export type { BranchRule, Line as PlanLine } from "./model/branch-types.js";
+export type { GroupPlan, Plan, PlanChange, PlanOptions, ReleasedUnit, UnitPlan, } from "./model/plan-types.js";
 export type { DepConfig, GroupConfig, ReleasePrMode, TallyConfig, UnitOverlay, VersionTemplate, } from "./config.js";
 export type { Warning } from "./errors.js";
 export type { Graph, SourcedEdge } from "./graph.js";
@@ -14,7 +15,7 @@ export type { BumpLevel, Change, Ctx, Edge, EdgeDraft, GitReader, IntentSource,
 export type { Marker, MarkerRelease } from "./marker.js";
 export type { ActivePlugin, PluginEnv } from "./plugins.js";
 export type { ReleaseItem } from "./release-items.js";
-export type { BranchRule, ReleaseSettings } from "./release.js";
+export type { ReleaseSettings } from "./release-settings.js";
 export type { SchemeEntry } from "./schemes.js";
 export type { SemVer } from "./semver.js";
 export type { IntentEntry, Workspace, WorkspaceInput } from "./workspace.js";

package/dist/model/affected-types.d.ts

@@ -0,0 +1,42 @@
+import type { Warning } from "../errors.js";
+export type BaseSource = "cli" | "push-before" | "pr-merge-base" | "merge-group" | "forge-last-success" | "local-merge-base" | "none";
+export type AffectedReason = "direct" | "dependent" | "global" | "all" | "group";
+export interface AffectedUnit {
+    id: string;
+    /** Unit root, `.` for the repo root. */
+    path: string;
+    plugin: string;
+    reason: AffectedReason;
+    /** Affected direct dependencies of a dependent, or affected mates of a group member. */
+    via: string[];
+    /** True unless the unit's version is `none`. */
+    released: boolean;
+    /** Sorted unit tags. */
+    tags: string[];
+}
+/** `tallyrelease affected --json`, schema 1. */
+export interface AffectedDoc {
+    schema: 1;
+    tool: string;
+    repo: string;
+    branch: string;
+    head: string;
+    build: {
+        base: string | null;
+        baseSource: BaseSource;
+        all: boolean;
+        globalInputs: string[];
+    };
+    units: AffectedUnit[];
+    unattributed: string[];
+    warnings: Warning[];
+}
+export interface AffectedOptions {
+    /** For example `tallyrelease@0.1.0`. */
+    tool: string;
+    branch: string;
+    head: string;
+    /** Null marks every unit affected without a diff. */
+    base: string | null;
+    baseSource: BaseSource;
+}

package/dist/model/affected-types.js

@@ -0,0 +1 @@
+export {};

package/dist/model/branch-types.d.ts

@@ -0,0 +1,57 @@
+import type { BumpLevel } from "../plugin.js";
+/** A normalized branch rule. */
+export interface BranchRule {
+    readonly name: string;
+    readonly line: "default" | "maintenance";
+    readonly channel: string | null;
+    /** Release item of the absolute maintenance check. */
+    readonly unit: string | null;
+    readonly group: string | null;
+}
+/** The branch rule matching the planned branch. */
+export interface Line {
+    rule: string;
+    kind: "default" | "maintenance";
+    /** Rendered with the rule's captures. */
+    channel: string | null;
+    /** Maintenance rules: `minor` for `{major}`, `patch` with `{minor}`. */
+    maxBump: "minor" | "patch" | null;
+    absolute: {
+        unit: string | null;
+        group: string | null;
+        major: number;
+        minor?: number;
+    } | null;
+}
+/** An ungrouped released unit or a fixed group. */
+export interface LimitSubject {
+    unit: string | null;
+    group: string | null;
+}
+/** Major and minor of a version. */
+export interface Core {
+    major: number;
+    minor: number;
+}
+/** A formatted version with its core. */
+export interface CoreVersion extends Core {
+    version: string;
+}
+/** A commit that contributes to a release item's `next`. */
+export interface LimitCommit {
+    sha?: string;
+    subject: string;
+    /** Null for a Release-As only commit. */
+    level: BumpLevel | null;
+    /** Absorbed unit the change came through. */
+    via?: string;
+    /** The Release-As value it sets. */
+    releaseAs?: CoreVersion;
+}
+export interface LimitItem extends LimitSubject {
+    /** Null on a first release. */
+    from: CoreVersion | null;
+    /** Null without a pending release. */
+    next: CoreVersion | null;
+    commits: readonly LimitCommit[];
+}

package/dist/model/branch-types.js

@@ -0,0 +1 @@
+export {};

package/dist/model/facts-types.d.ts

@@ -0,0 +1,83 @@
+import type { Warning } from "../errors.js";
+import type { Change } from "../plugin.js";
+import type { UnitTag } from "../tags.js";
+/** A Change with the ids of the units it is attributed to. */
+export interface AttributedChange {
+    readonly change: Change;
+    /** Sorted. */
+    readonly units: readonly string[];
+}
+/**
+ * Changes of `(from, head]`, in core commit order, attributed to all units. A
+ * unit's consumers read only its own range (`UnitFacts.from`), filtered to the
+ * unit and the units it absorbs.
+ */
+export interface RangeFacts {
+    readonly from: string | null;
+    readonly changes: readonly AttributedChange[];
+}
+export interface UnitFacts {
+    readonly id: string;
+    /** Fixed group name. */
+    readonly group: string | null;
+    /**
+     * Range key, null from the root: the base tag commit; for a group member
+     * its own base tag when that descends from the group base tag, else the
+     * group base tag.
+     */
+    readonly from: string | null;
+    /** Every matched tag, reachable or not, scheme-sorted. */
+    readonly tags: readonly UnitTag[];
+    /** Highest stable tag merged into head. */
+    readonly baseTag: UnitTag | null;
+    /** Source of the `from` version: the group base tag for members, else `baseTag`. */
+    readonly fromTag: UnitTag | null;
+    /** Highest stable tag on head's first-parent chain. */
+    readonly lineBaseTag: UnitTag | null;
+    /**
+     * Without a line base and with a root other than `.`: the oldest commit on
+     * head's first-parent chain that touches the unit root.
+     */
+    readonly introduced: string | null;
+    /**
+     * First-parent commits since the line base; without one, since and
+     * including `introduced`, else `total`.
+     */
+    readonly sinceLineBase: number;
+    readonly total: number;
+    /** Changes since the base tag attributed to this unit, core commit order. */
+    readonly changes: readonly AttributedChange[];
+    /** Qualified Release-As values naming this unit, core commit order. */
+    readonly releaseAs: readonly {
+        sha?: string;
+        version: string;
+    }[];
+}
+/**
+ * A fixed group. Base and line base are the highest member tags as for a
+ * unit; equal versions prefer the tag whose commit descends from the other's.
+ */
+export interface GroupFacts {
+    readonly name: string;
+    readonly members: readonly string[];
+    /** Highest stable member tag merged into head. */
+    readonly baseTag: UnitTag | null;
+    /** Highest stable member tag on head's first-parent chain. */
+    readonly lineBaseTag: UnitTag | null;
+    /** Without a line base, the max over the members. */
+    readonly sinceLineBase: number;
+}
+/** Git and intent data of every released unit, collected before release math. */
+export interface PlanFacts {
+    readonly head: string;
+    /** Released units, sorted by id. */
+    readonly units: readonly UnitFacts[];
+    /** One entry per distinct base tag commit. */
+    readonly ranges: readonly RangeFacts[];
+    /** Sorted by name. */
+    readonly groups: readonly GroupFacts[];
+    /** Every tag name, sorted. */
+    readonly tagNames: readonly string[];
+    /** Warnings logged by intent sources and for unknown explicit units. */
+    readonly warnings: readonly Warning[];
+}

package/dist/model/facts-types.js

@@ -0,0 +1 @@
+export {};

package/dist/model/plan-types.d.ts

@@ -0,0 +1,106 @@
+import type { AffectedDoc, AffectedOptions, AffectedReason } from "./affected-types.js";
+import type { Line } from "./branch-types.js";
+import type { PlanFacts } from "./facts-types.js";
+import type { BumpLevel, ReadonlyFs, VersionScheme } from "../plugin.js";
+export interface PlanChange {
+    /** Absent for file-based changes. */
+    sha?: string;
+    type: string;
+    breaking: boolean;
+    scope?: string;
+    subject: string;
+    /** `BREAKING CHANGE` footer text. */
+    notes?: string;
+    pr?: number;
+    /** Absorbed unit the change came through. */
+    via?: string;
+    /** Release-As value of this commit for the unit. */
+    releaseAs?: string;
+}
+export interface UnitPlan {
+    id: string;
+    /** Unit root, `.` for the repo root. */
+    path: string;
+    plugin: string;
+    scheme: string;
+    tags: string[];
+    group: string | null;
+    affected: {
+        reason: AffectedReason;
+        via: string[];
+    } | null;
+    kind: "prerelease" | "rebuild" | "none";
+    baseTag: string | null;
+    lineBaseTag: string | null;
+    /** Null on a first release. */
+    from: string | null;
+    bump: BumpLevel | null;
+    releaseAs: string | null;
+    propagatedFrom: string[];
+    absorbedFrom: string[];
+    next: string | null;
+    version: string | null;
+    /** The planned commit. */
+    sha: string;
+    /** Core commit order. */
+    changes: PlanChange[];
+}
+export interface GroupPlan {
+    name: string;
+    members: string[];
+    baseTag: string | null;
+    from: string | null;
+    bump: BumpLevel | null;
+    next: string | null;
+    version: string | null;
+}
+export interface ReleasedUnit {
+    id: string;
+    path: string;
+    version: string;
+    tag: string;
+    floatingTags: string[];
+    releaseSha: string;
+    /** Not built from HEAD by this run (release sha differs from HEAD, or the unit is outside the build set). */
+    catchUp: boolean;
+    /** Null when not looked up (no forge, or a forge error in `plan`). */
+    forge: ReleasedForge | null;
+    line: "default" | "maintenance";
+    /** Highest stable version tagged for the unit, never on a maintenance line. */
+    latest: boolean;
+}
+export interface ReleasedForge {
+    /** PR that merged the release sha. */
+    pr: {
+        number: number;
+        url: string;
+    } | null;
+    /** Forge release of the tag. */
+    release: {
+        url: string;
+    } | null;
+}
+/** `tallyrelease plan --json`, schema 1. */
+export interface Plan extends Omit<AffectedDoc, "units"> {
+    line: Line | null;
+    /** Topological order, cycles by id. */
+    units: UnitPlan[];
+    /** Sorted by name. */
+    groups: GroupPlan[];
+    /** Stable releases in `(build.base, head]`; empty until filled. */
+    released: ReleasedUnit[];
+}
+export interface PlanOptions extends AffectedOptions {
+    /** Files at `head`, for intent source contexts. */
+    fs: ReadonlyFs;
+    /** Also list released units outside the build set with a pending release. */
+    all?: boolean;
+    debug?: (message: string) => void;
+}
+/** Inputs of `resolvePlan`, all collected before release math. */
+export interface ResolveInput {
+    affected: AffectedDoc;
+    facts: PlanFacts;
+    schemes: ReadonlyMap<string, VersionScheme<any>>;
+    all: boolean;
+}

package/dist/model/plan-types.js

@@ -0,0 +1 @@
+export {};