syncpack 10.5.1 → 10.7.2

package/dist/get-semver-groups/with-range.d.ts

@@ -1,11 +1,18 @@
-import type { SemverGroupReport } from '.';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import { SemverGroupReport } from '.';
 import type { SemverGroupConfig } from '../config/types';
 import type { Instance } from '../get-package-json-files/instance';
-export declare class WithRangeSemverGroup {
-    _tag: string;
+declare const WithRangeSemverGroup_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "WithRange";
+}>;
+export declare class WithRangeSemverGroup extends WithRangeSemverGroup_base<{
     config: SemverGroupConfig.WithRange;
     instances: Instance[];
-    constructor(config: SemverGroupConfig.WithRange);
+    isCatchAll: boolean;
+}> {
+    constructor(isCatchAll: boolean, config: SemverGroupConfig.WithRange);
     canAdd(_: Instance): boolean;
-    inspect(): SemverGroupReport[];
+    inspect(): Effect.Effect<never, SemverGroupReport.UnsupportedVersion | SemverGroupReport.WorkspaceSemverRangeMismatch | SemverGroupReport.SemverRangeMismatch, SemverGroupReport.Valid>[];
 }
+export {};

package/dist/get-semver-groups/with-range.js

@@ -1,54 +1,78 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WithRangeSemverGroup = void 0;
-const is_semver_1 = require("../lib/is-semver");
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
+const _1 = require(".");
+const is_supported_1 = require("../guards/is-supported");
 const set_semver_range_1 = require("../lib/set-semver-range");
-class WithRangeSemverGroup {
-    constructor(config) {
-        this._tag = 'WithRange';
-        this.config = config;
-        this.instances = [];
+class WithRangeSemverGroup extends Data.TaggedClass('WithRange') {
+    constructor(isCatchAll, config) {
+        super({
+            config,
+            instances: [],
+            isCatchAll,
+        });
     }
     canAdd(_) {
         return true;
     }
     inspect() {
         return this.instances.map((instance) => {
-            if (!(0, is_semver_1.isSupported)(instance.version)) {
-                return {
-                    status: 'UNSUPPORTED_VERSION',
+            if (!(0, is_supported_1.isSupported)(instance.version)) {
+                return Effect.fail(new _1.SemverGroupReport.UnsupportedVersion({
+                    name: instance.name,
                     instance,
                     isValid: false,
-                    name: instance.name,
-                };
+                }));
             }
             const isWsInstance = instance.strategy.name === 'workspace';
             const exactVersion = (0, set_semver_range_1.setSemverRange)('', instance.version);
             const expectedVersion = (0, set_semver_range_1.setSemverRange)(this.config.range, instance.version);
             if (isWsInstance && instance.version !== exactVersion) {
-                return {
-                    status: 'WORKSPACE_SEMVER_RANGE_MISMATCH',
-                    expectedVersion: exactVersion,
+                return Effect.fail(new _1.SemverGroupReport.WorkspaceSemverRangeMismatch({
+                    name: instance.name,
                     instance,
                     isValid: false,
-                    name: instance.name,
-                };
+                    expectedVersion: exactVersion,
+                }));
             }
             if (instance.version === expectedVersion) {
-                return {
-                    status: 'VALID',
+                return Effect.succeed(new _1.SemverGroupReport.Valid({
+                    name: instance.name,
                     instance,
                     isValid: true,
-                    name: instance.name,
-                };
+                }));
             }
-            return {
-                status: 'SEMVER_RANGE_MISMATCH',
-                expectedVersion,
+            return Effect.fail(new _1.SemverGroupReport.SemverRangeMismatch({
+                name: instance.name,
                 instance,
                 isValid: false,
-                name: instance.name,
-            };
+                expectedVersion,
+            }));
         });
     }
 }

package/dist/get-version-groups/banned.d.ts

@@ -1,11 +1,17 @@
-import type { VersionGroupReport } from '.';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import { VersionGroupReport } from '.';
 import type { VersionGroupConfig } from '../config/types';
 import type { Instance } from '../get-package-json-files/instance';
-export declare class BannedVersionGroup {
-    _tag: string;
+declare const BannedVersionGroup_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "Banned";
+}>;
+export declare class BannedVersionGroup extends BannedVersionGroup_base<{
     config: VersionGroupConfig.Banned;
     instances: Instance[];
+}> {
     constructor(config: VersionGroupConfig.Banned);
     canAdd(_: Instance): boolean;
-    inspect(): VersionGroupReport[];
+    inspect(): Effect.Effect<never, VersionGroupReport.Banned, never>[];
 }
+export {};

package/dist/get-version-groups/banned.js

@@ -1,24 +1,50 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BannedVersionGroup = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
+const _1 = require(".");
 const group_by_1 = require("./lib/group-by");
-class BannedVersionGroup {
+class BannedVersionGroup extends Data.TaggedClass('Banned') {
     constructor(config) {
-        this._tag = 'Banned';
-        this.config = config;
-        this.instances = [];
+        super({
+            config,
+            instances: [],
+        });
     }
     canAdd(_) {
         return true;
     }
     inspect() {
         const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
-        return Object.entries(instancesByName).map(([name, instances]) => ({
+        return Object.entries(instancesByName).map(([name, instances]) => Effect.fail(new _1.VersionGroupReport.Banned({
+            name,
             instances,
             isValid: false,
-            name,
-            status: 'BANNED',
-        }));
+        })));
     }
 }
 exports.BannedVersionGroup = BannedVersionGroup;

package/dist/get-version-groups/filtered-out.d.ts

@@ -1,13 +1,19 @@
-import type { VersionGroupReport } from '.';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import { VersionGroupReport } from '.';
 import type { GroupConfig } from '../config/types';
-import type { Context } from '../get-context';
+import type { Ctx } from '../get-context';
 import type { Instance } from '../get-package-json-files/instance';
-export declare class FilteredOutVersionGroup {
-    _tag: string;
+declare const FilteredOutVersionGroup_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "FilteredOut";
+}>;
+export declare class FilteredOutVersionGroup extends FilteredOutVersionGroup_base<{
     config: GroupConfig;
     filter: string;
     instances: Instance[];
-    constructor(ctx: Context);
+}> {
+    constructor(ctx: Ctx);
     canAdd(instance: Instance): boolean;
-    inspect(): VersionGroupReport[];
+    inspect(): Effect.Effect<never, never, VersionGroupReport.FilteredOut>[];
 }
+export {};

package/dist/get-version-groups/filtered-out.js

@@ -1,31 +1,57 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilteredOutVersionGroup = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
+const _1 = require(".");
 const get_filter_1 = require("../config/get-filter");
 const group_by_1 = require("./lib/group-by");
-class FilteredOutVersionGroup {
+class FilteredOutVersionGroup extends Data.TaggedClass('FilteredOut') {
     constructor(ctx) {
-        this._tag = 'FilteredOut';
-        this.config = {
-            dependencies: ['**'],
-            dependencyTypes: [],
-            label: 'Filtered out',
-            packages: ['**'],
-        };
-        this.filter = (0, get_filter_1.getFilter)(ctx.config);
-        this.instances = [];
+        super({
+            config: {
+                dependencies: ['**'],
+                dependencyTypes: [],
+                label: 'Filtered out',
+                packages: ['**'],
+            },
+            filter: (0, get_filter_1.getFilter)(ctx.config),
+            instances: [],
+        });
     }
     canAdd(instance) {
         return instance.name.search(new RegExp(this.filter)) === -1;
     }
     inspect() {
         const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
-        return Object.entries(instancesByName).map(([name, instances]) => ({
+        return Object.entries(instancesByName).map(([name, instances]) => Effect.succeed(new _1.VersionGroupReport.FilteredOut({
+            name,
             instances,
             isValid: true,
-            name,
-            status: 'FILTERED_OUT',
-        }));
+        })));
     }
 }
 exports.FilteredOutVersionGroup = FilteredOutVersionGroup;

package/dist/get-version-groups/ignored.d.ts

@@ -1,11 +1,17 @@
-import type { VersionGroupReport } from '.';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import { VersionGroupReport } from '.';
 import type { VersionGroupConfig } from '../config/types';
 import type { Instance } from '../get-package-json-files/instance';
-export declare class IgnoredVersionGroup {
-    _tag: string;
+declare const IgnoredVersionGroup_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "Ignored";
+}>;
+export declare class IgnoredVersionGroup extends IgnoredVersionGroup_base<{
     config: VersionGroupConfig.Ignored;
     instances: Instance[];
+}> {
     constructor(config: VersionGroupConfig.Ignored);
     canAdd(_: Instance): boolean;
-    inspect(): VersionGroupReport[];
+    inspect(): Effect.Effect<never, never, VersionGroupReport.Ignored>[];
 }
+export {};

package/dist/get-version-groups/ignored.js

@@ -1,24 +1,50 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IgnoredVersionGroup = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
+const _1 = require(".");
 const group_by_1 = require("./lib/group-by");
-class IgnoredVersionGroup {
+class IgnoredVersionGroup extends Data.TaggedClass('Ignored') {
     constructor(config) {
-        this._tag = 'Ignored';
-        this.config = config;
-        this.instances = [];
+        super({
+            config,
+            instances: [],
+        });
     }
     canAdd(_) {
         return true;
     }
     inspect() {
         const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
-        return Object.entries(instancesByName).map(([name, instances]) => ({
+        return Object.entries(instancesByName).map(([name, instances]) => Effect.succeed(new _1.VersionGroupReport.Ignored({
+            name,
             instances,
             isValid: true,
-            name,
-            status: 'IGNORED',
-        }));
+        })));
     }
 }
 exports.IgnoredVersionGroup = IgnoredVersionGroup;

package/dist/get-version-groups/index.d.ts

@@ -1,55 +1,139 @@
-import type { Context } from '../get-context';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import type { Union } from 'ts-toolbelt';
+import type { DeprecatedTypesError } from '../config/get-enabled-types';
+import type { Ctx } from '../get-context';
 import type { Instance } from '../get-package-json-files/instance';
 import { BannedVersionGroup } from './banned';
-import { CatchAllVersionGroup } from './catch-all';
 import { FilteredOutVersionGroup } from './filtered-out';
 import { IgnoredVersionGroup } from './ignored';
 import { PinnedVersionGroup } from './pinned';
 import { SameRangeVersionGroup } from './same-range';
 import { SnappedToVersionGroup } from './snapped-to';
 import { StandardVersionGroup } from './standard';
-export type AnyVersionGroup = BannedVersionGroup | CatchAllVersionGroup | FilteredOutVersionGroup | IgnoredVersionGroup | PinnedVersionGroup | SameRangeVersionGroup | SnappedToVersionGroup | StandardVersionGroup;
-export type VersionGroupReport = {
-    name: string;
-    instances: Instance[];
-} & ({
-    status: 'BANNED';
-    isValid: false;
-} | {
-    status: 'FILTERED_OUT';
-    isValid: true;
-} | {
-    status: 'HIGHEST_SEMVER_MISMATCH';
-    isValid: false;
-    expectedVersion: string;
-} | {
-    status: 'IGNORED';
-    isValid: true;
-} | {
-    status: 'LOWEST_SEMVER_MISMATCH';
-    isValid: false;
-    expectedVersion: string;
-} | {
-    status: 'PINNED_MISMATCH';
-    isValid: false;
-    expectedVersion: string;
-} | {
-    status: 'SAME_RANGE_MISMATCH';
-    isValid: false;
-} | {
-    status: 'SNAPPED_TO_MISMATCH';
-    isValid: false;
-    expectedVersion: string;
-} | {
-    status: 'UNSUPPORTED_MISMATCH';
-    isValid: false;
-} | {
-    status: 'VALID';
-    isValid: true;
-} | {
-    status: 'WORKSPACE_MISMATCH';
-    isValid: false;
-    expectedVersion: string;
-    workspaceInstance: Instance;
-});
-export declare function getVersionGroups(ctx: Context): AnyVersionGroup[];
+export type AnyVersionGroup = Union.Strict<BannedVersionGroup | FilteredOutVersionGroup | IgnoredVersionGroup | PinnedVersionGroup | SameRangeVersionGroup | SnappedToVersionGroup | StandardVersionGroup>;
+export declare namespace VersionGroupReport {
+    const Banned_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "Banned";
+    }>;
+    export class Banned extends Banned_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+    }> {
+    }
+    const FilteredOut_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "FilteredOut";
+    }>;
+    export class FilteredOut extends FilteredOut_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: true;
+    }> {
+    }
+    const HighestSemverMismatch_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "HighestSemverMismatch";
+    }>;
+    export class HighestSemverMismatch extends HighestSemverMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+        readonly expectedVersion: string;
+    }> {
+    }
+    const Ignored_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "Ignored";
+    }>;
+    export class Ignored extends Ignored_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: true;
+    }> {
+    }
+    const LowestSemverMismatch_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "LowestSemverMismatch";
+    }>;
+    export class LowestSemverMismatch extends LowestSemverMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+        readonly expectedVersion: string;
+    }> {
+    }
+    const PinnedMismatch_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "PinnedMismatch";
+    }>;
+    export class PinnedMismatch extends PinnedMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+        readonly expectedVersion: string;
+    }> {
+    }
+    const SameRangeMismatch_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "SameRangeMismatch";
+    }>;
+    export class SameRangeMismatch extends SameRangeMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+    }> {
+    }
+    const SnappedToMismatch_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "SnappedToMismatch";
+    }>;
+    export class SnappedToMismatch extends SnappedToMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+        readonly expectedVersion: string;
+        readonly snapTo: string[];
+    }> {
+    }
+    const UnsupportedMismatch_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "UnsupportedMismatch";
+    }>;
+    export class UnsupportedMismatch extends UnsupportedMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+    }> {
+    }
+    const Valid_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "Valid";
+    }>;
+    export class Valid extends Valid_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: true;
+    }> {
+    }
+    const WorkspaceMismatch_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "WorkspaceMismatch";
+    }>;
+    export class WorkspaceMismatch extends WorkspaceMismatch_base<{
+        name: string;
+        instances: Instance[];
+        readonly isValid: false;
+        readonly expectedVersion: string;
+        readonly workspaceInstance: Instance;
+    }> {
+    }
+    export type ValidCases = Union.Strict<FilteredOut | Ignored | Valid>;
+    export type InvalidCases = Union.Strict<Banned | HighestSemverMismatch | LowestSemverMismatch | PinnedMismatch | SameRangeMismatch | SnappedToMismatch | UnsupportedMismatch | WorkspaceMismatch>;
+    export type FixableCases = Union.Strict<HighestSemverMismatch | LowestSemverMismatch | PinnedMismatch | SnappedToMismatch | WorkspaceMismatch>;
+    export type UnfixableCases = Union.Strict<SameRangeMismatch | UnsupportedMismatch | WorkspaceMismatch>;
+    export type HighLowSemverMismatch = VersionGroupReport.HighestSemverMismatch | VersionGroupReport.LowestSemverMismatch;
+    export type Any = Union.Strict<ValidCases | InvalidCases>;
+    export {};
+}
+declare const VersionGroupConfigError_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "VersionGroupConfigError";
+}>;
+export declare class VersionGroupConfigError extends VersionGroupConfigError_base<{
+    readonly config: unknown;
+    readonly error: string;
+}> {
+}
+export declare function getVersionGroups(ctx: Ctx): Effect.Effect<never, VersionGroupConfigError | DeprecatedTypesError, AnyVersionGroup[]>;
+export {};