syncpack 10.9.3 → 12.0.0-alpha.0

package/dist/report.d.ts

@@ -0,0 +1,166 @@
+import { Data } from 'effect';
+import type { Union } from 'ts-toolbelt';
+import type { Instance } from './get-instances/instance';
+import type { Specifier } from './specifier';
+export declare namespace Report {
+    export namespace Semver {
+        type Any = Union.Strict<Report.Semver.Invalid.Any | Report.Semver.Valid.Any>;
+        namespace Valid {
+            type Any = Union.Strict<Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid>;
+        }
+        namespace Invalid {
+            type Any = Union.Strict<Report.Semver.Fixable.Any | Report.Semver.Unfixable.Any>;
+        }
+        namespace Fixable {
+            type Any = Report.SemverRangeMismatch;
+        }
+        namespace Unfixable {
+            type Any = Report.UnsupportedMismatch;
+        }
+    }
+    export namespace Version {
+        interface Group {
+            name: string;
+            reports: Report.Version.Any[];
+        }
+        type Any = Union.Strict<Report.Version.Invalid.Any | Report.Version.Valid.Any>;
+        namespace Valid {
+            type Any = Union.Strict<Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid>;
+        }
+        namespace Invalid {
+            type Any = Union.Strict<Report.Version.Fixable.Any | Report.Version.Unfixable.Any>;
+        }
+        namespace Fixable {
+            type Any = Union.Strict<Report.Banned | Report.HighestSemverMismatch | Report.LocalPackageMismatch | Report.LowestSemverMismatch | Report.PinnedMismatch | Report.SemverRangeMismatch | Report.SnappedToMismatch>;
+        }
+        namespace Unfixable {
+            type Any = Union.Strict<Report.MissingLocalVersion | Report.MissingSnappedToMismatch | Report.UnsupportedMismatch | Report.SameRangeMismatch>;
+        }
+    }
+    const Disabled_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "Disabled";
+    }>;
+    /** Semver Groups are disabled by default */
+    export class Disabled extends Disabled_base<{
+        readonly instance: Instance;
+    }> {
+    }
+    const FilteredOut_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "FilteredOut";
+    }>;
+    /** Has a name which does not match the `--filter` RegExp */
+    export class FilteredOut extends FilteredOut_base<{
+        readonly instance: Instance;
+    }> {
+    }
+    const Ignored_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "Ignored";
+    }>;
+    /** Is in an ignored version group */
+    export class Ignored extends Ignored_base<{
+        readonly instance: Instance;
+    }> {
+    }
+    const Valid_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "Valid";
+    }>;
+    /** Version satisfies the rules of its version group */
+    export class Valid extends Valid_base<{
+        readonly specifier: Specifier.Any;
+    }> {
+    }
+    const Banned_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "Banned";
+    }>;
+    /** Must be removed */
+    export class Banned extends Banned_base<{
+        readonly fixable: Specifier.Any;
+    }> {
+    }
+    const HighestSemverMismatch_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "HighestSemverMismatch";
+    }>;
+    /** Version mismatches and should use a higher version found on another */
+    export class HighestSemverMismatch extends HighestSemverMismatch_base<{
+        readonly fixable: Specifier.Any;
+    }> {
+    }
+    const LocalPackageMismatch_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "LocalPackageMismatch";
+    }>;
+    /** Version mismatches the `.version` of the package developed in this repo */
+    export class LocalPackageMismatch extends LocalPackageMismatch_base<{
+        readonly fixable: Specifier.Any;
+        readonly localInstance: Instance;
+    }> {
+    }
+    const LowestSemverMismatch_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "LowestSemverMismatch";
+    }>;
+    /** Version mismatches and should use a lower version found on another */
+    export class LowestSemverMismatch extends LowestSemverMismatch_base<{
+        readonly fixable: Specifier.Any;
+    }> {
+    }
+    const PinnedMismatch_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "PinnedMismatch";
+    }>;
+    /** Version is not identical to the `pinVersion` of its Pinned version group */
+    export class PinnedMismatch extends PinnedMismatch_base<{
+        readonly fixable: Specifier.Any;
+    }> {
+    }
+    const SemverRangeMismatch_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "SemverRangeMismatch";
+    }>;
+    /** Version is identical but the semver range does not match its semver group */
+    export class SemverRangeMismatch extends SemverRangeMismatch_base<{
+        readonly fixable: Specifier.Any;
+    }> {
+    }
+    const SnappedToMismatch_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "SnappedToMismatch";
+    }>;
+    /** Version mismatches the version used by the packages in the `snapTo` array */
+    export class SnappedToMismatch extends SnappedToMismatch_base<{
+        readonly fixable: Specifier.Any;
+        readonly localInstance: Instance;
+    }> {
+    }
+    const MissingLocalVersion_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "MissingLocalVersion";
+    }>;
+    /** Dependency should match a local package.json which is missing a .version */
+    export class MissingLocalVersion extends MissingLocalVersion_base<{
+        readonly localInstance: Instance;
+        readonly unfixable: Instance;
+    }> {
+    }
+    const MissingSnappedToMismatch_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "MissingSnappedToMismatch";
+    }>;
+    /** Dependency is not present in any of the packages in the `snapTo` array */
+    export class MissingSnappedToMismatch extends MissingSnappedToMismatch_base<{
+        readonly unfixable: Instance;
+    }> {
+    }
+    const SameRangeMismatch_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "SameRangeMismatch";
+    }>;
+    /** Specifier does not cover the specifiers of every other instance in this group */
+    export class SameRangeMismatch extends SameRangeMismatch_base<{
+        readonly unfixable: Instance;
+        /** the raw specifiers which this instance's specifier did not cover */
+        readonly mismatches: string[];
+    }> {
+    }
+    const UnsupportedMismatch_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+        readonly _tag: "UnsupportedMismatch";
+    }>;
+    /** Version mismatches and is not semver, syncpack cannot guess what to do */
+    export class UnsupportedMismatch extends UnsupportedMismatch_base<{
+        readonly unfixable: Instance;
+    }> {
+    }
+    export {};
+}

package/dist/report.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Report = void 0;
+const effect_1 = require("effect");
+var Report;
+(function (Report) {
+    /** Semver Groups are disabled by default */
+    class Disabled extends effect_1.Data.TaggedClass('Disabled') {
+    }
+    Report.Disabled = Disabled;
+    /** Has a name which does not match the `--filter` RegExp */
+    class FilteredOut extends effect_1.Data.TaggedClass('FilteredOut') {
+    }
+    Report.FilteredOut = FilteredOut;
+    /** Is in an ignored version group */
+    class Ignored extends effect_1.Data.TaggedClass('Ignored') {
+    }
+    Report.Ignored = Ignored;
+    /** Version satisfies the rules of its version group */
+    class Valid extends effect_1.Data.TaggedClass('Valid') {
+    }
+    Report.Valid = Valid;
+    /** Must be removed */
+    class Banned extends effect_1.Data.TaggedClass('Banned') {
+    }
+    Report.Banned = Banned;
+    /** Version mismatches and should use a higher version found on another */
+    class HighestSemverMismatch extends effect_1.Data.TaggedClass('HighestSemverMismatch') {
+    }
+    Report.HighestSemverMismatch = HighestSemverMismatch;
+    /** Version mismatches the `.version` of the package developed in this repo */
+    class LocalPackageMismatch extends effect_1.Data.TaggedClass('LocalPackageMismatch') {
+    }
+    Report.LocalPackageMismatch = LocalPackageMismatch;
+    /** Version mismatches and should use a lower version found on another */
+    class LowestSemverMismatch extends effect_1.Data.TaggedClass('LowestSemverMismatch') {
+    }
+    Report.LowestSemverMismatch = LowestSemverMismatch;
+    /** Version is not identical to the `pinVersion` of its Pinned version group */
+    class PinnedMismatch extends effect_1.Data.TaggedClass('PinnedMismatch') {
+    }
+    Report.PinnedMismatch = PinnedMismatch;
+    /** Version is identical but the semver range does not match its semver group */
+    class SemverRangeMismatch extends effect_1.Data.TaggedClass('SemverRangeMismatch') {
+    }
+    Report.SemverRangeMismatch = SemverRangeMismatch;
+    /** Version mismatches the version used by the packages in the `snapTo` array */
+    class SnappedToMismatch extends effect_1.Data.TaggedClass('SnappedToMismatch') {
+    }
+    Report.SnappedToMismatch = SnappedToMismatch;
+    /** Dependency should match a local package.json which is missing a .version */
+    class MissingLocalVersion extends effect_1.Data.TaggedClass('MissingLocalVersion') {
+    }
+    Report.MissingLocalVersion = MissingLocalVersion;
+    /** Dependency is not present in any of the packages in the `snapTo` array */
+    class MissingSnappedToMismatch extends effect_1.Data.TaggedClass('MissingSnappedToMismatch') {
+    }
+    Report.MissingSnappedToMismatch = MissingSnappedToMismatch;
+    /** Specifier does not cover the specifiers of every other instance in this group */
+    class SameRangeMismatch extends effect_1.Data.TaggedClass('SameRangeMismatch') {
+    }
+    Report.SameRangeMismatch = SameRangeMismatch;
+    /** Version mismatches and is not semver, syncpack cannot guess what to do */
+    class UnsupportedMismatch extends effect_1.Data.TaggedClass('UnsupportedMismatch') {
+    }
+    Report.UnsupportedMismatch = UnsupportedMismatch;
+})(Report || (exports.Report = Report = {}));

package/dist/schema.json

@@ -0,0 +1,392 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "additionalProperties": false,
+    "definitions": {
+        "Record<string,CustomTypeConfig.Any>": {
+            "additionalProperties": false,
+            "type": "object"
+        },
+        "SemverGroupConfig.Any": {
+            "anyOf": [
+                {
+                    "$ref": "#/definitions/{isDisabled:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;range?:never;}"
+                },
+                {
+                    "$ref": "#/definitions/{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;range?:never;}"
+                },
+                {
+                    "$ref": "#/definitions/{range:SemverRange;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;isIgnored?:never;}"
+                }
+            ]
+        },
+        "SemverRange": {
+            "default": "",
+            "description": "Aliases for semver range formats supported by syncpack\n\nDefaults to `\"\"` to ensure that exact dependency versions are used instead of\nloose ranges, but this can be overridden in your config file.\n\n| Supported Range |   Example |\n| --------------- | --------: |\n| `\"<\"`           |  `<1.4.2` |\n| `\"<=\"`          | `<=1.4.2` |\n| `\"\"`            |   `1.4.2` |\n| `\"~\"`           |  `~1.4.2` |\n| `\"^\"`           |  `^1.4.2` |\n| `\">=\"`          | `>=1.4.2` |\n| `\">\"`           |  `>1.4.2` |\n| `\"*\"`           |       `*` |",
+            "enum": [
+                "",
+                "*",
+                ".x",
+                "<",
+                "<=",
+                ">",
+                ">=",
+                "^",
+                "~"
+            ],
+            "type": "string"
+        },
+        "VersionGroupConfig.Any": {
+            "anyOf": [
+                {
+                    "$ref": "#/definitions/{isBanned:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
+                },
+                {
+                    "$ref": "#/definitions/{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
+                },
+                {
+                    "$ref": "#/definitions/{pinVersion:string;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;snapTo?:never;policy?:never;preferVersion?:never;}"
+                },
+                {
+                    "$ref": "#/definitions/{snapTo:string[];dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;policy?:never;preferVersion?:never;}"
+                },
+                {
+                    "$ref": "#/definitions/{policy:\"sameRange\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;preferVersion?:never;}"
+                },
+                {
+                    "$ref": "#/definitions/{preferVersion?:\"highestSemver\"|\"lowestSemver\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;}"
+                }
+            ]
+        },
+        "{isBanned:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
+            "additionalProperties": false,
+            "properties": {
+                "dependencies": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "dependencyTypes": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "isBanned": {
+                    "const": true,
+                    "type": "boolean"
+                },
+                "label": {
+                    "type": "string"
+                },
+                "packages": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "{isDisabled:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;range?:never;}": {
+            "additionalProperties": false,
+            "properties": {
+                "dependencies": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "dependencyTypes": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "isDisabled": {
+                    "const": true,
+                    "type": "boolean"
+                },
+                "label": {
+                    "type": "string"
+                },
+                "packages": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
+            "additionalProperties": false,
+            "properties": {
+                "dependencies": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "dependencyTypes": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "isIgnored": {
+                    "const": true,
+                    "type": "boolean"
+                },
+                "label": {
+                    "type": "string"
+                },
+                "packages": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "{isIgnored:true;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;range?:never;}": {
+            "additionalProperties": false,
+            "properties": {
+                "dependencies": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "dependencyTypes": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "isIgnored": {
+                    "const": true,
+                    "type": "boolean"
+                },
+                "label": {
+                    "type": "string"
+                },
+                "packages": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "{pinVersion:string;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;snapTo?:never;policy?:never;preferVersion?:never;}": {
+            "additionalProperties": false,
+            "properties": {
+                "dependencies": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "dependencyTypes": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "label": {
+                    "type": "string"
+                },
+                "packages": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "pinVersion": {
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "{policy:\"sameRange\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;preferVersion?:never;}": {
+            "additionalProperties": false,
+            "properties": {
+                "dependencies": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "dependencyTypes": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "label": {
+                    "type": "string"
+                },
+                "packages": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "policy": {
+                    "const": "sameRange",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "{preferVersion?:\"highestSemver\"|\"lowestSemver\";dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;snapTo?:never;policy?:never;}": {
+            "additionalProperties": false,
+            "properties": {
+                "dependencies": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "dependencyTypes": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "label": {
+                    "type": "string"
+                },
+                "packages": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "preferVersion": {
+                    "enum": [
+                        "highestSemver",
+                        "lowestSemver"
+                    ],
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "{range:SemverRange;dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isDisabled?:never;isIgnored?:never;}": {
+            "additionalProperties": false,
+            "properties": {
+                "dependencies": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "dependencyTypes": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "label": {
+                    "type": "string"
+                },
+                "packages": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "range": {
+                    "$ref": "#/definitions/SemverRange"
+                }
+            },
+            "type": "object"
+        },
+        "{snapTo:string[];dependencies?:string[];dependencyTypes?:string[];label?:string;packages?:string[];isIgnored?:never;isBanned?:never;pinVersion?:never;policy?:never;preferVersion?:never;}": {
+            "additionalProperties": false,
+            "properties": {
+                "dependencies": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "dependencyTypes": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "label": {
+                    "type": "string"
+                },
+                "packages": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "snapTo": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        }
+    },
+    "properties": {
+        "customTypes": {
+            "$ref": "#/definitions/Record<string,CustomTypeConfig.Any>"
+        },
+        "dependencyTypes": {
+            "items": {
+                "type": "string"
+            },
+            "type": "array"
+        },
+        "filter": {
+            "type": "string"
+        },
+        "indent": {
+            "type": "string"
+        },
+        "semverGroups": {
+            "items": {
+                "$ref": "#/definitions/SemverGroupConfig.Any"
+            },
+            "type": "array"
+        },
+        "sortAz": {
+            "items": {
+                "type": "string"
+            },
+            "type": "array"
+        },
+        "sortFirst": {
+            "items": {
+                "type": "string"
+            },
+            "type": "array"
+        },
+        "source": {
+            "items": {
+                "type": "string"
+            },
+            "type": "array"
+        },
+        "versionGroups": {
+            "items": {
+                "$ref": "#/definitions/VersionGroupConfig.Any"
+            },
+            "type": "array"
+        }
+    },
+    "type": "object"
+}
+

package/dist/semver-group/create-semver-groups.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from 'effect';
+import { SemverGroup } from '.';
+import type { Ctx } from '../get-context';
+export declare function createSemverGroups(ctx: Ctx): Effect.Effect<never, SemverGroup.ConfigError, SemverGroup.Any[]>;