syncpack 12.0.1 → 12.2.0

package/dist/config/types.d.ts

@@ -1,4 +1,5 @@
-import type { Union } from 'ts-toolbelt';
+import type { CUSTOM_TYPES } from '../constants';
+import type { Specifier } from '../specifier';
 /**
  * Aliases for semver range formats supported by syncpack
  *
@@ -18,12 +19,16 @@ import type { Union } from 'ts-toolbelt';
  *
  * @default ""
  */
-export type SemverRange = '' | '*' | '>' | '>=' | '.x' | '<' | '<=' | '^' | '~';
+export type SemverRange = '' | '*' | '>' | '>=' | '.x' | '<' | '<=' | '^' | '~' | 'workspace:';
+type DefaultDependencyType = keyof typeof CUSTOM_TYPES;
+export type DependencyType = DefaultDependencyType | `!${DefaultDependencyType}` | (string & {});
+export type SpecifierType = Specifier.Any['name'] | `!${Specifier.Any['name']}` | (string & {});
 export interface GroupConfig {
     dependencies?: string[];
-    dependencyTypes?: string[];
+    dependencyTypes?: DependencyType[];
     label?: string;
     packages?: string[];
+    specifierTypes?: SpecifierType[];
 }
 export declare namespace SemverGroupConfig {
     interface Disabled extends GroupConfig {
@@ -35,7 +40,7 @@ export declare namespace SemverGroupConfig {
     interface WithRange extends GroupConfig {
         range: SemverRange;
     }
-    type Any = Union.Strict<Disabled | Ignored | WithRange>;
+    type Any = Disabled | Ignored | WithRange;
 }
 export declare namespace VersionGroupConfig {
     interface Banned extends GroupConfig {
@@ -59,7 +64,7 @@ export declare namespace VersionGroupConfig {
     interface Standard extends GroupConfig {
         preferVersion?: 'highestSemver' | 'lowestSemver';
     }
-    type Any = Union.Strict<Banned | Ignored | Pinned | SameRange | SnappedTo | Standard>;
+    type Any = Banned | Ignored | Pinned | SameRange | SnappedTo | Standard;
 }
 declare namespace CustomTypeConfig {
     interface NameAndVersionProps {
@@ -79,20 +84,21 @@ declare namespace CustomTypeConfig {
         path: string;
         strategy: 'versionsByName';
     }
-    type Any = Union.Strict<NameAndVersionProps | NamedVersionString | UnnamedVersionString | VersionsByName>;
+    type Any = NameAndVersionProps | NamedVersionString | UnnamedVersionString | VersionsByName;
 }
 export interface CliConfig {
     readonly configPath?: string;
     readonly filter: string;
     readonly indent: string;
     readonly source: string[];
+    readonly specs: string;
     readonly types: string;
 }
 export interface RcConfig {
     /** @see https://jamiemason.github.io/syncpack/config/custom-types */
     customTypes: Record<string, CustomTypeConfig.Any>;
     /** @see https://jamiemason.github.io/syncpack/config/dependency-types */
-    dependencyTypes: string[];
+    dependencyTypes: DependencyType[];
     /** @see https://jamiemason.github.io/syncpack/config/filter */
     filter: string;
     /** @see https://jamiemason.github.io/syncpack/config/indent */
@@ -105,6 +111,8 @@ export interface RcConfig {
     sortFirst: string[];
     /** @see https://jamiemason.github.io/syncpack/config/source */
     source: string[];
+    /** @see https://jamiemason.github.io/syncpack/config/specifier-types */
+    specifierTypes: SpecifierType[];
     /** @see https://jamiemason.github.io/syncpack/config/version-groups */
     versionGroups: VersionGroupConfig.Any[];
 }

package/dist/constants.d.ts

@@ -24,13 +24,76 @@ export declare const RANGE: {
     readonly WORKSPACE: "workspace:";
 };
 export declare const INTERNAL_TYPES: readonly ["dev", "local", "overrides", "peer", "pnpmOverrides", "prod", "resolutions"];
+export declare const CUSTOM_TYPES: {
+    readonly dev: {
+        readonly strategy: "versionsByName";
+        readonly path: "devDependencies";
+    };
+    readonly local: {
+        readonly strategy: "name~version";
+        readonly namePath: "name";
+        readonly path: "version";
+    };
+    readonly overrides: {
+        readonly strategy: "versionsByName";
+        readonly path: "overrides";
+    };
+    readonly peer: {
+        readonly strategy: "versionsByName";
+        readonly path: "peerDependencies";
+    };
+    readonly pnpmOverrides: {
+        readonly strategy: "versionsByName";
+        readonly path: "pnpm.overrides";
+    };
+    readonly prod: {
+        readonly strategy: "versionsByName";
+        readonly path: "dependencies";
+    };
+    readonly resolutions: {
+        readonly strategy: "versionsByName";
+        readonly path: "resolutions";
+    };
+};
 export declare const DEFAULT_CONFIG: {
-    readonly dependencyTypes: readonly ["**"];
-    readonly filter: ".";
-    readonly indent: "  ";
-    readonly semverGroups: readonly [];
-    readonly sortAz: readonly ["contributors", "dependencies", "devDependencies", "keywords", "peerDependencies", "resolutions", "scripts"];
-    readonly sortFirst: readonly ["name", "description", "version", "author"];
-    readonly source: readonly ["package.json", "packages/*/package.json"];
-    readonly versionGroups: readonly [];
+    customTypes: {
+        readonly dev: {
+            readonly strategy: "versionsByName";
+            readonly path: "devDependencies";
+        };
+        readonly local: {
+            readonly strategy: "name~version";
+            readonly namePath: "name";
+            readonly path: "version";
+        };
+        readonly overrides: {
+            readonly strategy: "versionsByName";
+            readonly path: "overrides";
+        };
+        readonly peer: {
+            readonly strategy: "versionsByName";
+            readonly path: "peerDependencies";
+        };
+        readonly pnpmOverrides: {
+            readonly strategy: "versionsByName";
+            readonly path: "pnpm.overrides";
+        };
+        readonly prod: {
+            readonly strategy: "versionsByName";
+            readonly path: "dependencies";
+        };
+        readonly resolutions: {
+            readonly strategy: "versionsByName";
+            readonly path: "resolutions";
+        };
+    };
+    dependencyTypes: "**"[];
+    filter: string;
+    indent: string;
+    semverGroups: never[];
+    sortAz: string[];
+    sortFirst: string[];
+    source: string[];
+    specifierTypes: "**"[];
+    versionGroups: never[];
 };

package/dist/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CONFIG = exports.INTERNAL_TYPES = exports.RANGE = exports.ICON = exports.CWD = void 0;
+exports.DEFAULT_CONFIG = exports.CUSTOM_TYPES = exports.INTERNAL_TYPES = exports.RANGE = exports.ICON = exports.CWD = void 0;
 /** Single source of truth, intended to aid testing or to override */
 exports.CWD = process.env.MOCK_CWD || process.cwd();
 /** Single source of truth for icons used in output */
@@ -35,7 +35,39 @@ exports.INTERNAL_TYPES = [
     'prod',
     'resolutions',
 ];
+exports.CUSTOM_TYPES = {
+    dev: {
+        strategy: 'versionsByName',
+        path: 'devDependencies',
+    },
+    local: {
+        strategy: 'name~version',
+        namePath: 'name',
+        path: 'version',
+    },
+    overrides: {
+        strategy: 'versionsByName',
+        path: 'overrides',
+    },
+    peer: {
+        strategy: 'versionsByName',
+        path: 'peerDependencies',
+    },
+    pnpmOverrides: {
+        strategy: 'versionsByName',
+        path: 'pnpm.overrides',
+    },
+    prod: {
+        strategy: 'versionsByName',
+        path: 'dependencies',
+    },
+    resolutions: {
+        strategy: 'versionsByName',
+        path: 'resolutions',
+    },
+};
 exports.DEFAULT_CONFIG = {
+    customTypes: exports.CUSTOM_TYPES,
     dependencyTypes: ['**'],
     filter: '.',
     indent: '  ',
@@ -51,5 +83,6 @@ exports.DEFAULT_CONFIG = {
     ],
     sortFirst: ['name', 'description', 'version', 'author'],
     source: ['package.json', 'packages/*/package.json'],
+    specifierTypes: ['**'],
     versionGroups: [],
 };

package/dist/get-instances/instance.d.ts

@@ -2,6 +2,7 @@ import type { Effect } from 'effect';
 import type { Strategy } from '../config/get-custom-types';
 import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
 import type { SemverGroup } from '../semver-group';
+import { Specifier } from '../specifier';
 import type { VersionGroup } from '../version-group';
 import type { Delete } from '../version-group/lib/delete';
 export declare class Instance {
@@ -10,7 +11,7 @@ export declare class Instance {
     /** The .name property of the package.json file of this instance */
     pkgName: string;
     /** The specifier as it is on disk before being fixed */
-    rawSpecifier: string;
+    rawSpecifier: Specifier.Any;
     /** The package this dependency is installed in this specific time */
     packageJsonFile: PackageJsonFile;
     /** Locates where in the file this dependency is installed */

package/dist/get-instances/instance.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Instance = void 0;
+const specifier_1 = require("../specifier");
 class Instance {
     /** The name of this dependency */
     name;
@@ -19,16 +20,16 @@ class Instance {
     constructor(name, rawSpecifier, packageJsonFile, strategy) {
         this.name = name;
         this.pkgName = packageJsonFile.jsonFile.contents.name || 'PACKAGE_JSON_HAS_NO_NAME';
-        this.rawSpecifier = rawSpecifier;
         this.packageJsonFile = packageJsonFile;
         this.strategy = strategy;
         this.semverGroup = null;
         this.versionGroup = null;
+        this.rawSpecifier = specifier_1.Specifier.create(this, rawSpecifier);
     }
     /** Mutate the package.json file in memory with the latest version specifier */
     write(rawSpecifier) {
-        this.rawSpecifier = rawSpecifier;
-        return this.strategy.write(this.packageJsonFile, [this.name, this.rawSpecifier]);
+        this.rawSpecifier = specifier_1.Specifier.create(this, rawSpecifier);
+        return this.strategy.write(this.packageJsonFile, [this.name, this.rawSpecifier.raw]);
     }
 }
 exports.Instance = Instance;

package/dist/guards/can-add-to-group.js

@@ -4,11 +4,12 @@ exports.canAddToGroup = void 0;
 const minimatch_1 = require("minimatch");
 const is_non_empty_array_1 = require("tightrope/guard/is-non-empty-array");
 function canAddToGroup(packageJsonFilesByName, group, instance) {
-    const { dependencies, dependencyTypes, packages } = group.config;
+    const { dependencies, dependencyTypes, packages, specifierTypes } = group.config;
     return (group.canAdd(instance) &&
         matchesDependencyTypes(dependencyTypes, instance) &&
         matchesPackages(packages, instance) &&
-        matchesDependencies(packageJsonFilesByName, group, dependencies, instance));
+        matchesDependencies(packageJsonFilesByName, group, dependencies, instance) &&
+        matchesSpecifierTypes(specifierTypes, instance));
 }
 exports.canAddToGroup = canAddToGroup;
 function matchesDependencies(packageJsonFilesByName, group, dependencies, instance) {
@@ -28,14 +29,20 @@ function matchesPackages(packages, instance) {
     return packages.some((pattern) => (0, minimatch_1.minimatch)(instance.pkgName, pattern));
 }
 function matchesDependencyTypes(dependencyTypes, instance) {
+    return matchesKnownList(dependencyTypes, instance.strategy.name);
+}
+function matchesSpecifierTypes(specifierTypes, instance) {
+    return matchesKnownList(specifierTypes, instance.rawSpecifier.name);
+}
+function matchesKnownList(values, value) {
     // matches if not defined
-    if (!(0, is_non_empty_array_1.isNonEmptyArray)(dependencyTypes))
+    if (!(0, is_non_empty_array_1.isNonEmptyArray)(values))
         return true;
-    if (dependencyTypes.join('') === '**')
+    if (values.join('') === '**')
         return true;
     const negative = [];
     const positive = [];
-    dependencyTypes.forEach((name) => {
+    values.forEach((name) => {
         if (name.startsWith('!')) {
             negative.push(name.replace('!', ''));
         }
@@ -43,7 +50,7 @@ function matchesDependencyTypes(dependencyTypes, instance) {
             positive.push(name);
         }
     });
-    if ((0, is_non_empty_array_1.isNonEmptyArray)(negative) && !negative.includes(instance.strategy.name))
+    if ((0, is_non_empty_array_1.isNonEmptyArray)(negative) && !negative.includes(value))
         return true;
-    return (0, is_non_empty_array_1.isNonEmptyArray)(positive) && positive.includes(instance.strategy.name);
+    return (0, is_non_empty_array_1.isNonEmptyArray)(positive) && positive.includes(value);
 }

package/dist/io/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { cosmiconfigSync } from 'cosmiconfig';
+import { cosmiconfig } from 'cosmiconfig';
 import { Context } from 'effect';
 import { prompt } from 'enquirer';
 import * as fs from 'fs';
@@ -7,7 +7,7 @@ import * as globby from 'globby';
 import * as readYamlFile from 'read-yaml-file';
 export interface Io {
     cosmiconfig: {
-        cosmiconfigSync: typeof cosmiconfigSync;
+        cosmiconfig: typeof cosmiconfig;
     };
     enquirer: {
         prompt: typeof prompt<any>;

package/dist/io/index.js

@@ -33,7 +33,7 @@ const readYamlFile = __importStar(require("read-yaml-file"));
 exports.IoTag = effect_1.Context.Tag();
 exports.io = {
     cosmiconfig: {
-        cosmiconfigSync: cosmiconfig_1.cosmiconfigSync,
+        cosmiconfig: cosmiconfig_1.cosmiconfig,
     },
     enquirer: {
         prompt: enquirer_1.prompt,

package/dist/io/read-config-file-sync.js

@@ -7,7 +7,7 @@ const is_non_empty_object_1 = require("tightrope/guard/is-non-empty-object");
 const read_json_file_sync_1 = require("./read-json-file-sync");
 const getOptionOfNonEmptyObject = effect_1.Option.liftPredicate((is_non_empty_object_1.isNonEmptyObject));
 function readConfigFileSync(io, configPath) {
-    return (0, effect_1.pipe)(effect_1.Effect.try(() => io.cosmiconfig.cosmiconfigSync('syncpack')), effect_1.Effect.flatMap((client) => effect_1.Effect.try(() => (configPath ? client.load(configPath) : client.search()))), effect_1.Effect.flatMap((result) => result !== null ? getValueFromCosmiconfig(result) : findConfigInPackageJson(io)), effect_1.Effect.tap((config) => effect_1.Effect.logDebug(`config file found: ${JSON.stringify(config)}`)), effect_1.Effect.tapError(() => effect_1.Effect.logDebug('no config file found, will use defaults')), effect_1.Effect.catchAll(() => effect_1.Effect.succeed({})));
+    return (0, effect_1.pipe)(effect_1.Effect.try(() => io.cosmiconfig.cosmiconfig('syncpack')), effect_1.Effect.flatMap((client) => effect_1.Effect.tryPromise(() => (configPath ? client.load(configPath) : client.search()))), effect_1.Effect.flatMap((result) => result !== null ? getValueFromCosmiconfig(result) : findConfigInPackageJson(io)), effect_1.Effect.tap((config) => effect_1.Effect.logDebug(`config file found: ${JSON.stringify(config)}`)), effect_1.Effect.tapError(() => effect_1.Effect.logDebug('no config file found, will use defaults')), effect_1.Effect.catchAll(() => effect_1.Effect.succeed({})));
 }
 exports.readConfigFileSync = readConfigFileSync;
 /**

package/dist/option.d.ts

@@ -1,8 +1,9 @@
 export declare const option: {
     readonly config: readonly ["-c, --config <path>", "path to a syncpack config file"];
     readonly filter: readonly ["-f, --filter [pattern]", string];
-    readonly indent: readonly ["-i, --indent [value]", "override indentation. defaults to \"  \""];
+    readonly indent: readonly ["-i, --indent [value]", `override indentation. defaults to "${string}"`];
     readonly source: readonly ["-s, --source [pattern]", "glob pattern for package.json files to read from", typeof collect, string[]];
+    readonly specs: readonly ["-s, --specs <names>", string];
     readonly types: readonly ["-t, --types <names>", string];
 };
 declare function collect(value: string, previous: string[]): string[];

package/dist/option.js

@@ -19,6 +19,10 @@ exports.option = {
         collect,
         [],
     ],
+    specs: [
+        '-s, --specs <names>',
+        (0, chalk_1.default) `only include dependencies whose version specifier match these types (eg. {yellow specs=latest,range,workspace-protocol})`,
+    ],
     types: [
         '-t, --types <names>',
         (0, chalk_1.default) `only include dependencies matching these types (eg. {yellow types=dev,prod,myCustomType})`,

package/dist/report.d.ts

@@ -1,15 +1,14 @@
-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 type Any = Semver.Any | Version.Any;
     export namespace Semver {
-        type Any = Union.Strict<Report.Semver.Invalid.Any | Report.Semver.Valid.Any>;
+        type Any = Report.Semver.Invalid.Any | Report.Semver.Valid.Any;
         namespace Valid {
-            type Any = Union.Strict<Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid>;
+            type Any = Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid;
         }
         namespace Invalid {
-            type Any = Union.Strict<Report.Semver.Fixable.Any | Report.Semver.Unfixable.Any>;
+            type Any = Report.Semver.Fixable.Any | Report.Semver.Unfixable.Any;
         }
         namespace Fixable {
             type Any = Report.SemverRangeMismatch;
@@ -23,144 +22,110 @@ export declare namespace Report {
             name: string;
             reports: Report.Version.Any[];
         }
-        type Any = Union.Strict<Report.Version.Invalid.Any | Report.Version.Valid.Any>;
+        type Any = Report.Version.Invalid.Any | Report.Version.Valid.Any;
         namespace Valid {
-            type Any = Union.Strict<Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid>;
+            type Any = Report.Disabled | Report.FilteredOut | Report.Ignored | Report.Valid;
         }
         namespace Invalid {
-            type Any = Union.Strict<Report.Version.Fixable.Any | Report.Version.Unfixable.Any>;
+            type Any = 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>;
+            type Any = 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>;
+            type Any = 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/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
-        readonly _tag: "Disabled";
-    }>;
-    /** Semver Groups are disabled by default */
-    export class Disabled extends Disabled_base<{
+    class Excluded {
+        readonly _tagGroup = "Excluded";
+        readonly isInvalid = false;
         readonly instance: Instance;
-    }> {
+        constructor(instance: Instance);
+    }
+    class Unfixable {
+        readonly _tagGroup = "Unfixable";
+        readonly isInvalid = true;
+        readonly unfixable: Instance;
+        constructor(unfixable: Instance);
+    }
+    class Fixable {
+        readonly _tagGroup = "Fixable";
+        readonly isInvalid = true;
+        readonly fixable: Specifier.Any;
+        constructor(fixable: Specifier.Any);
+    }
+    /** Semver Groups are disabled by default */
+    export class Disabled extends Excluded {
+        readonly _tag = "Disabled";
     }
-    const FilteredOut_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
-        readonly _tag: "FilteredOut";
-    }>;
     /** Has a name which does not match the `--filter` RegExp */
-    export class FilteredOut extends FilteredOut_base<{
-        readonly instance: Instance;
-    }> {
+    export class FilteredOut extends Excluded {
+        readonly _tag = "FilteredOut";
     }
-    const Ignored_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
-        readonly _tag: "Ignored";
-    }>;
     /** Is in an ignored version group */
-    export class Ignored extends Ignored_base<{
-        readonly instance: Instance;
-    }> {
+    export class Ignored extends Excluded {
+        readonly _tag = "Ignored";
     }
-    const Valid_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
-        readonly _tag: "Valid";
-    }>;
     /** Version satisfies the rules of its version group */
-    export class Valid extends Valid_base<{
+    export class Valid {
+        readonly _tag = "Valid";
+        readonly _tagGroup = "Valid";
+        readonly isInvalid = false;
         readonly specifier: Specifier.Any;
-    }> {
+        constructor(specifier: Specifier.Any);
     }
-    const Banned_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
-        readonly _tag: "Banned";
-    }>;
     /** Must be removed */
-    export class Banned extends Banned_base<{
-        readonly fixable: Specifier.Any;
-    }> {
+    export class Banned extends Fixable {
+        readonly _tag = "Banned";
     }
-    const HighestSemverMismatch_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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;
-    }> {
+    export class HighestSemverMismatch extends Fixable {
+        readonly _tag = "HighestSemverMismatch";
     }
-    const LocalPackageMismatch_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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;
+    export class LocalPackageMismatch extends Fixable {
+        readonly _tag = "LocalPackageMismatch";
         readonly localInstance: Instance;
-    }> {
+        constructor(fixable: Specifier.Any, localInstance: Instance);
     }
-    const LowestSemverMismatch_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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;
-    }> {
+    export class LowestSemverMismatch extends Fixable {
+        readonly _tag = "LowestSemverMismatch";
     }
-    const PinnedMismatch_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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;
-    }> {
+    export class PinnedMismatch extends Fixable {
+        readonly _tag = "PinnedMismatch";
     }
-    const SemverRangeMismatch_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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;
-    }> {
+    export class SemverRangeMismatch extends Fixable {
+        readonly _tag = "SemverRangeMismatch";
     }
-    const SnappedToMismatch_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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;
+    export class SnappedToMismatch extends Fixable {
+        readonly _tag = "SnappedToMismatch";
         readonly localInstance: Instance;
-    }> {
+        constructor(fixable: Specifier.Any, localInstance: Instance);
     }
-    const MissingLocalVersion_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
-        readonly _tag: "MissingLocalVersion";
-    }>;
     /** Dependency should match a local package.json which is missing a .version */
-    export class MissingLocalVersion extends MissingLocalVersion_base<{
+    export class MissingLocalVersion extends Unfixable {
+        readonly _tag = "MissingLocalVersion";
         readonly localInstance: Instance;
-        readonly unfixable: Instance;
-    }> {
+        constructor(unfixable: Instance, localInstance: Instance);
     }
-    const MissingSnappedToMismatch_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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;
-    }> {
+    export class MissingSnappedToMismatch extends Unfixable {
+        readonly _tag = "MissingSnappedToMismatch";
     }
-    const SameRangeMismatch_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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;
+    export class SameRangeMismatch extends Unfixable {
+        readonly _tag = "SameRangeMismatch";
         /** the raw specifiers which this instance's specifier did not cover */
         readonly mismatches: string[];
-    }> {
+        constructor(unfixable: Instance, mismatches: string[]);
     }
-    const UnsupportedMismatch_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<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 class UnsupportedMismatch extends Unfixable {
+        readonly _tag = "UnsupportedMismatch";
     }
     export {};
 }