@monorepolint/rules 0.5.0-alpha.1 → 0.5.0-alpha.103

package/build/types/mustSatisfyPeerDependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mustSatisfyPeerDependencies.d.ts","sourceRoot":"","sources":["../../src/mustSatisfyPeerDependencies.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAK9B,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuKZ,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAE/C,eAAO,MAAM,2BAA2B,EAAE,UAAU,CAAC,OAAO,OAAO,CAGlE,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGvC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,QAAa,CAAC;AAElD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oCAAoC,QAC0H,CAAC;AAE5K;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,yBAAyB,QACmL,CAAC;AAE1N;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,QACghB,CAAC;AAyNziB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAoFrF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAmEnE;AAoBD,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG;IAAE,KAAK,EAAE,aAAa,CAAA;CAAE,CAAC;AAC3D,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,UAAU,CAEnE"}

package/build/types/nestedWorkspaces.d.ts

@@ -0,0 +1,24 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { Context, RuleModule } from "@monorepolint/config";
+import * as r from "runtypes";
+export declare const Options: r.Literal<undefined>;
+type Options = r.Static<typeof Options>;
+export declare const nestedWorkspaces: RuleModule<typeof Options>;
+export declare const NestedWorkspaces: {
+    new (ruleEntry: import("@monorepolint/config").RuleEntry<undefined>): {
+        readonly id: string;
+        options: undefined;
+        readonly name: string;
+        checkFunc: import("@monorepolint/config").Checker<r.Literal<undefined>>;
+        readonly optionsRuntype: r.Literal<undefined>;
+        readonly ruleEntry: import("@monorepolint/config").RuleEntry<undefined>;
+        check: (context: Context) => void | Promise<void>;
+    };
+};
+export {};
+//# sourceMappingURL=nestedWorkspaces.d.ts.map

package/build/types/nestedWorkspaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestedWorkspaces.d.ts","sourceRoot":"","sources":["../../src/nestedWorkspaces.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,eAAO,MAAM,OAAO,sBAAc,CAAC;AAEnC,KAAK,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAGxC,eAAO,MAAM,gBAAgB,EAAE,UAAU,CAAC,OAAO,OAAO,CAyCvD,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;CAAgE,CAAC"}

package/build/types/packageEntry.d.ts

@@ -0,0 +1,115 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { Context, RuleModule } from "@monorepolint/config";
+import * as r from "runtypes";
+export declare const Options: r.Union<[r.Intersect<[r.Record<{
+    entries: r.Dictionary<r.Unknown, string | number | symbol>;
+}, false>, r.Partial<{
+    entriesExist: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    entriesExist: r.Array<r.String, false>;
+}, false>, r.Partial<{
+    entries: r.Literal<undefined>;
+}, false>]>, r.Record<{
+    entries: r.Dictionary<r.Unknown, string | number | symbol>;
+    entriesExist: r.Array<r.String, false>;
+}, false>]>;
+export type Options = r.Static<typeof Options>;
+export declare const packageEntry: RuleModule<typeof Options>;
+export declare const PackageEntry: {
+    new (ruleEntry: import("@monorepolint/config").RuleEntry<({
+        entries: {
+            [x: string]: unknown;
+            [x: number]: unknown;
+            [x: symbol]: unknown;
+        };
+    } & {
+        entriesExist?: undefined;
+    }) | ({
+        entriesExist: string[];
+    } & {
+        entries?: undefined;
+    }) | {
+        entries: {
+            [x: string]: unknown;
+            [x: number]: unknown;
+            [x: symbol]: unknown;
+        };
+        entriesExist: string[];
+    }>): {
+        readonly id: string;
+        options: ({
+            entries: {
+                [x: string]: unknown;
+                [x: number]: unknown;
+                [x: symbol]: unknown;
+            };
+        } & {
+            entriesExist?: undefined;
+        }) | ({
+            entriesExist: string[];
+        } & {
+            entries?: undefined;
+        }) | {
+            entries: {
+                [x: string]: unknown;
+                [x: number]: unknown;
+                [x: symbol]: unknown;
+            };
+            entriesExist: string[];
+        } | undefined;
+        readonly name: string;
+        checkFunc: import("@monorepolint/config").Checker<r.Union<[r.Intersect<[r.Record<{
+            entries: r.Dictionary<r.Unknown, string | number | symbol>;
+        }, false>, r.Partial<{
+            entriesExist: r.Literal<undefined>;
+        }, false>]>, r.Intersect<[r.Record<{
+            entriesExist: r.Array<r.String, false>;
+        }, false>, r.Partial<{
+            entries: r.Literal<undefined>;
+        }, false>]>, r.Record<{
+            entries: r.Dictionary<r.Unknown, string | number | symbol>;
+            entriesExist: r.Array<r.String, false>;
+        }, false>]>>;
+        readonly optionsRuntype: r.Union<[r.Intersect<[r.Record<{
+            entries: r.Dictionary<r.Unknown, string | number | symbol>;
+        }, false>, r.Partial<{
+            entriesExist: r.Literal<undefined>;
+        }, false>]>, r.Intersect<[r.Record<{
+            entriesExist: r.Array<r.String, false>;
+        }, false>, r.Partial<{
+            entries: r.Literal<undefined>;
+        }, false>]>, r.Record<{
+            entries: r.Dictionary<r.Unknown, string | number | symbol>;
+            entriesExist: r.Array<r.String, false>;
+        }, false>]>;
+        readonly ruleEntry: import("@monorepolint/config").RuleEntry<({
+            entries: {
+                [x: string]: unknown;
+                [x: number]: unknown;
+                [x: symbol]: unknown;
+            };
+        } & {
+            entriesExist?: undefined;
+        }) | ({
+            entriesExist: string[];
+        } & {
+            entries?: undefined;
+        }) | {
+            entries: {
+                [x: string]: unknown;
+                [x: number]: unknown;
+                [x: symbol]: unknown;
+            };
+            entriesExist: string[];
+        }>;
+        check: (context: Context) => void | Promise<void>;
+    };
+};
+export declare function createStandardizedEntryErrorMessage(key: string): string;
+export declare function createExpectedEntryErrorMessage(key: string): string;
+//# sourceMappingURL=packageEntry.d.ts.map

package/build/types/packageEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageEntry.d.ts","sourceRoot":"","sources":["../../src/packageEntry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,eAAO,MAAM,OAAO;;;;;;;;;;;WAuBnB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAE/C,eAAO,MAAM,YAAY,EAAE,UAAU,CAAC,OAAO,OAAO,CAyCnD,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAC;AAElF,wBAAgB,mCAAmC,CAAC,GAAG,EAAE,MAAM,UAE9D;AAED,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,MAAM,UAE1D"}

package/build/types/packageOrder.d.ts

@@ -0,0 +1,33 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { Context, RuleModule } from "@monorepolint/config";
+import * as r from "runtypes";
+export declare const packageOrder: RuleModule<r.Union<[r.Record<{
+    order: r.Union<[r.Array<r.String, false>, r.Function]>;
+}, false>, r.Literal<undefined>]>>;
+export declare const PackageOrder: {
+    new (ruleEntry: import("@monorepolint/config").RuleEntry<{
+        order: ((...args: any[]) => any) | string[];
+    } | undefined>): {
+        readonly id: string;
+        options: {
+            order: ((...args: any[]) => any) | string[];
+        } | undefined;
+        readonly name: string;
+        checkFunc: import("@monorepolint/config").Checker<r.Union<[r.Record<{
+            order: r.Union<[r.Array<r.String, false>, r.Function]>;
+        }, false>, r.Literal<undefined>]>>;
+        readonly optionsRuntype: r.Union<[r.Record<{
+            order: r.Union<[r.Array<r.String, false>, r.Function]>;
+        }, false>, r.Literal<undefined>]>;
+        readonly ruleEntry: import("@monorepolint/config").RuleEntry<{
+            order: ((...args: any[]) => any) | string[];
+        } | undefined>;
+        check: (context: Context) => void | Promise<void>;
+    };
+};
+//# sourceMappingURL=packageOrder.d.ts.map

package/build/types/packageOrder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageOrder.d.ts","sourceRoot":"","sources":["../../src/packageOrder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AA4C9B,eAAO,MAAM,YAAY;;kCA8BM,CAAC;AAEhC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;CAAwD,CAAC"}

package/build/types/packageScript.d.ts

@@ -0,0 +1,89 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { Context, RuleModule } from "@monorepolint/config";
+import * as r from "runtypes";
+export declare const Options: r.Record<{
+    scripts: r.Dictionary<r.Union<[r.String, r.Record<{
+        options: r.Array<r.Union<[r.String, r.Literal<undefined>]>, false>;
+        fixValue: r.Optional<r.Union<[r.String, r.Literal<undefined>, r.Literal<false>]>>;
+    }, false>]>, string | number | symbol>;
+}, false>;
+export type Options = r.Static<typeof Options>;
+export declare const MSG_NO_SCRIPTS_BLOCK = "No scripts block in package.json";
+export declare const packageScript: RuleModule<r.Record<{
+    scripts: r.Dictionary<r.Union<[r.String, r.Record<{
+        options: r.Array<r.Union<[r.String, r.Literal<undefined>]>, false>;
+        fixValue: r.Optional<r.Union<[r.String, r.Literal<undefined>, r.Literal<false>]>>;
+    }, false>]>, string | number | symbol>;
+}, false>>;
+export declare const PackageScript: {
+    new (ruleEntry: import("@monorepolint/config").RuleEntry<{
+        scripts: {
+            [x: string]: string | {
+                options: (string | undefined)[];
+                fixValue?: string | false | undefined;
+            };
+            [x: number]: string | {
+                options: (string | undefined)[];
+                fixValue?: string | false | undefined;
+            };
+            [x: symbol]: string | {
+                options: (string | undefined)[];
+                fixValue?: string | false | undefined;
+            };
+        };
+    }>): {
+        readonly id: string;
+        options: {
+            scripts: {
+                [x: string]: string | {
+                    options: (string | undefined)[];
+                    fixValue?: string | false | undefined;
+                };
+                [x: number]: string | {
+                    options: (string | undefined)[];
+                    fixValue?: string | false | undefined;
+                };
+                [x: symbol]: string | {
+                    options: (string | undefined)[];
+                    fixValue?: string | false | undefined;
+                };
+            };
+        } | undefined;
+        readonly name: string;
+        checkFunc: import("@monorepolint/config").Checker<r.Record<{
+            scripts: r.Dictionary<r.Union<[r.String, r.Record<{
+                options: r.Array<r.Union<[r.String, r.Literal<undefined>]>, false>;
+                fixValue: r.Optional<r.Union<[r.String, r.Literal<undefined>, r.Literal<false>]>>;
+            }, false>]>, string | number | symbol>;
+        }, false>>;
+        readonly optionsRuntype: r.Record<{
+            scripts: r.Dictionary<r.Union<[r.String, r.Record<{
+                options: r.Array<r.Union<[r.String, r.Literal<undefined>]>, false>;
+                fixValue: r.Optional<r.Union<[r.String, r.Literal<undefined>, r.Literal<false>]>>;
+            }, false>]>, string | number | symbol>;
+        }, false>;
+        readonly ruleEntry: import("@monorepolint/config").RuleEntry<{
+            scripts: {
+                [x: string]: string | {
+                    options: (string | undefined)[];
+                    fixValue?: string | false | undefined;
+                };
+                [x: number]: string | {
+                    options: (string | undefined)[];
+                    fixValue?: string | false | undefined;
+                };
+                [x: symbol]: string | {
+                    options: (string | undefined)[];
+                    fixValue?: string | false | undefined;
+                };
+            };
+        }>;
+        check: (context: Context) => void | Promise<void>;
+    };
+};
+//# sourceMappingURL=packageScript.d.ts.map

package/build/types/packageScript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageScript.d.ts","sourceRoot":"","sources":["../../src/packageScript.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAI3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,eAAO,MAAM,OAAO;;;;;SAUlB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAE/C,eAAO,MAAM,oBAAoB,qCAAqC,CAAC;AAEvE,eAAO,MAAM,aAAa;;;;;UAqEK,CAAC;AAEhC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0D,CAAC"}

package/build/types/requireDependency.d.ts

@@ -0,0 +1,99 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { Context, RuleModule } from "@monorepolint/config";
+import * as r from "runtypes";
+export declare const requireDependency: RuleModule<r.Partial<{
+    dependencies: r.Dictionary<r.String, string | number | symbol>;
+    devDependencies: r.Dictionary<r.String, string | number | symbol>;
+    peerDependencies: r.Dictionary<r.String, string | number | symbol>;
+    optionalDependencies: r.Dictionary<r.String, string | number | symbol>;
+}, false>>;
+export declare const RequireDependency: {
+    new (ruleEntry: import("@monorepolint/config").RuleEntry<{
+        dependencies?: {
+            [x: string]: string;
+            [x: number]: string;
+            [x: symbol]: string;
+        } | undefined;
+        devDependencies?: {
+            [x: string]: string;
+            [x: number]: string;
+            [x: symbol]: string;
+        } | undefined;
+        peerDependencies?: {
+            [x: string]: string;
+            [x: number]: string;
+            [x: symbol]: string;
+        } | undefined;
+        optionalDependencies?: {
+            [x: string]: string;
+            [x: number]: string;
+            [x: symbol]: string;
+        } | undefined;
+    }>): {
+        readonly id: string;
+        options: {
+            dependencies?: {
+                [x: string]: string;
+                [x: number]: string;
+                [x: symbol]: string;
+            } | undefined;
+            devDependencies?: {
+                [x: string]: string;
+                [x: number]: string;
+                [x: symbol]: string;
+            } | undefined;
+            peerDependencies?: {
+                [x: string]: string;
+                [x: number]: string;
+                [x: symbol]: string;
+            } | undefined;
+            optionalDependencies?: {
+                [x: string]: string;
+                [x: number]: string;
+                [x: symbol]: string;
+            } | undefined;
+        } | undefined;
+        readonly name: string;
+        checkFunc: import("@monorepolint/config").Checker<r.Partial<{
+            dependencies: r.Dictionary<r.String, string | number | symbol>;
+            devDependencies: r.Dictionary<r.String, string | number | symbol>;
+            peerDependencies: r.Dictionary<r.String, string | number | symbol>;
+            optionalDependencies: r.Dictionary<r.String, string | number | symbol>;
+        }, false>>;
+        readonly optionsRuntype: r.Partial<{
+            dependencies: r.Dictionary<r.String, string | number | symbol>;
+            devDependencies: r.Dictionary<r.String, string | number | symbol>;
+            peerDependencies: r.Dictionary<r.String, string | number | symbol>;
+            optionalDependencies: r.Dictionary<r.String, string | number | symbol>;
+        }, false>;
+        readonly ruleEntry: import("@monorepolint/config").RuleEntry<{
+            dependencies?: {
+                [x: string]: string;
+                [x: number]: string;
+                [x: symbol]: string;
+            } | undefined;
+            devDependencies?: {
+                [x: string]: string;
+                [x: number]: string;
+                [x: symbol]: string;
+            } | undefined;
+            peerDependencies?: {
+                [x: string]: string;
+                [x: number]: string;
+                [x: symbol]: string;
+            } | undefined;
+            optionalDependencies?: {
+                [x: string]: string;
+                [x: number]: string;
+                [x: symbol]: string;
+            } | undefined;
+        }>;
+        check: (context: Context) => void | Promise<void>;
+    };
+};
+//# sourceMappingURL=requireDependency.d.ts.map

package/build/types/requireDependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requireDependency.d.ts","sourceRoot":"","sources":["../../src/requireDependency.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAW9B,eAAO,MAAM,iBAAiB;;;;;UA+CC,CAAC;AAEhC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkE,CAAC"}

package/build/types/standardTsconfig.d.ts

@@ -0,0 +1,113 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { Context, RuleModule } from "@monorepolint/config";
+import * as r from "runtypes";
+declare const Options: r.Constraint<r.Partial<{
+    file: r.String;
+    generator: r.Function;
+    tsconfigReferenceFile: r.String;
+    template: r.Union<[r.Record<{}, false>, r.String]>;
+    templateFile: r.String;
+    excludedReferences: r.Union<[r.Array<r.String, false>, r.Literal<undefined>]>;
+    additionalReferences: r.Union<[r.Array<r.String, false>, r.Literal<undefined>]>;
+}, false>, {
+    file?: string | undefined;
+    generator?: ((...args: any[]) => any) | undefined;
+    tsconfigReferenceFile?: string | undefined;
+    template?: string | {} | undefined;
+    templateFile?: string | undefined;
+    excludedReferences?: string[] | undefined;
+    additionalReferences?: string[] | undefined;
+}, unknown>;
+export interface Options extends r.Static<typeof Options> {
+}
+export declare const standardTsconfig: RuleModule<r.Constraint<r.Partial<{
+    file: r.String;
+    generator: r.Function;
+    tsconfigReferenceFile: r.String;
+    template: r.Union<[r.Record<{}, false>, r.String]>;
+    templateFile: r.String;
+    excludedReferences: r.Union<[r.Array<r.String, false>, r.Literal<undefined>]>;
+    additionalReferences: r.Union<[r.Array<r.String, false>, r.Literal<undefined>]>;
+}, false>, {
+    file?: string | undefined;
+    generator?: ((...args: any[]) => any) | undefined;
+    tsconfigReferenceFile?: string | undefined;
+    template?: string | {} | undefined;
+    templateFile?: string | undefined;
+    excludedReferences?: string[] | undefined;
+    additionalReferences?: string[] | undefined;
+}, unknown>>;
+export declare const StandardTsConfig: {
+    new (ruleEntry: import("@monorepolint/config").RuleEntry<{
+        file?: string | undefined;
+        generator?: ((...args: any[]) => any) | undefined;
+        tsconfigReferenceFile?: string | undefined;
+        template?: string | {} | undefined;
+        templateFile?: string | undefined;
+        excludedReferences?: string[] | undefined;
+        additionalReferences?: string[] | undefined;
+    }>): {
+        readonly id: string;
+        options: {
+            file?: string | undefined;
+            generator?: ((...args: any[]) => any) | undefined;
+            tsconfigReferenceFile?: string | undefined;
+            template?: string | {} | undefined;
+            templateFile?: string | undefined;
+            excludedReferences?: string[] | undefined;
+            additionalReferences?: string[] | undefined;
+        } | undefined;
+        readonly name: string;
+        checkFunc: import("@monorepolint/config").Checker<r.Constraint<r.Partial<{
+            file: r.String;
+            generator: r.Function;
+            tsconfigReferenceFile: r.String;
+            template: r.Union<[r.Record<{}, false>, r.String]>;
+            templateFile: r.String;
+            excludedReferences: r.Union<[r.Array<r.String, false>, r.Literal<undefined>]>;
+            additionalReferences: r.Union<[r.Array<r.String, false>, r.Literal<undefined>]>;
+        }, false>, {
+            file?: string | undefined;
+            generator?: ((...args: any[]) => any) | undefined;
+            tsconfigReferenceFile?: string | undefined;
+            template?: string | {} | undefined;
+            templateFile?: string | undefined;
+            excludedReferences?: string[] | undefined;
+            additionalReferences?: string[] | undefined;
+        }, unknown>>;
+        readonly optionsRuntype: r.Constraint<r.Partial<{
+            file: r.String;
+            generator: r.Function;
+            tsconfigReferenceFile: r.String;
+            template: r.Union<[r.Record<{}, false>, r.String]>;
+            templateFile: r.String;
+            excludedReferences: r.Union<[r.Array<r.String, false>, r.Literal<undefined>]>;
+            additionalReferences: r.Union<[r.Array<r.String, false>, r.Literal<undefined>]>;
+        }, false>, {
+            file?: string | undefined;
+            generator?: ((...args: any[]) => any) | undefined;
+            tsconfigReferenceFile?: string | undefined;
+            template?: string | {} | undefined;
+            templateFile?: string | undefined;
+            excludedReferences?: string[] | undefined;
+            additionalReferences?: string[] | undefined;
+        }, unknown>;
+        readonly ruleEntry: import("@monorepolint/config").RuleEntry<{
+            file?: string | undefined;
+            generator?: ((...args: any[]) => any) | undefined;
+            tsconfigReferenceFile?: string | undefined;
+            template?: string | {} | undefined;
+            templateFile?: string | undefined;
+            excludedReferences?: string[] | undefined;
+            additionalReferences?: string[] | undefined;
+        }>;
+        check: (context: Context) => void | Promise<void>;
+    };
+};
+export {};
+//# sourceMappingURL=standardTsconfig.d.ts.map

package/build/types/standardTsconfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standardTsconfig.d.ts","sourceRoot":"","sources":["../../src/standardTsconfig.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAK3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAI9B,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;WAuBT,CAAC;AAEL,MAAM,WAAW,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC;CAAG;AAE5D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;YAiCE,CAAC;AAEhC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgE,CAAC"}

package/build/types/util/checkAlpha.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { Context } from "@monorepolint/config";
+export declare function checkAlpha(context: Context, block: "dependencies" | "devDependencies" | "peerDependencies" | "scripts"): void;
+export declare function createIncorrectOrderErrorMessage(block: string, packageName: string): string;
+//# sourceMappingURL=checkAlpha.d.ts.map

package/build/types/util/checkAlpha.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkAlpha.d.ts","sourceRoot":"","sources":["../../../src/util/checkAlpha.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAG/C,wBAAgB,UAAU,CACxB,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,cAAc,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,SAAS,QAgC3E;AAYD,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,UAElF"}

package/build/types/util/createNewRuleConversion.d.ts

@@ -0,0 +1,30 @@
+/*!
+ * Copyright 2022 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { Checker, Context, NewRuleModule, RuleModule, RuleEntry } from "@monorepolint/config";
+import * as r from "runtypes";
+export declare class NewRuleConverterBase<T extends r.Runtype<unknown>> implements NewRuleModule<T> {
+    readonly name: string;
+    checkFunc: Checker<T>;
+    readonly optionsRuntype: T;
+    readonly ruleEntry: RuleEntry<r.Static<T>>;
+    readonly id: string;
+    options: r.Static<T> | undefined;
+    constructor(name: string, checkFunc: Checker<T>, optionsRuntype: T, ruleEntry: RuleEntry<r.Static<T>>);
+    check: (context: Context) => void | Promise<void>;
+}
+export declare function createNewRuleConversion<T extends r.Runtype<unknown>>(name: string, old: RuleModule<T>): {
+    new (ruleEntry: RuleEntry<r.Static<T>>): {
+        readonly id: string;
+        options: r.Static<T> | undefined;
+        readonly name: string;
+        checkFunc: Checker<T>;
+        readonly optionsRuntype: T;
+        readonly ruleEntry: RuleEntry<r.Static<T>>;
+        check: (context: Context) => void | Promise<void>;
+    };
+};
+//# sourceMappingURL=createNewRuleConversion.d.ts.map

package/build/types/util/createNewRuleConversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNewRuleConversion.d.ts","sourceRoot":"","sources":["../../../src/util/createNewRuleConversion.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC9F,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAK9B,qBAAa,oBAAoB,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;aAKvE,IAAI,EAAE,MAAM;IACrB,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;aACZ,cAAc,EAAE,CAAC;aACjB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAPnD,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;gBAGf,IAAI,EAAE,MAAM,EACrB,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,EACZ,cAAc,EAAE,CAAC,EACjB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAO5C,KAAK,YAAa,OAAO,0BAAsE;CACvG;AAED,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC;oBAE3E,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;;;;;;;;;EAIhD"}

package/build/types/util/makeDirectory.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+export declare function makeDirectoryRecursively(directoryPath: string): void;
+//# sourceMappingURL=makeDirectory.d.ts.map

package/build/types/util/makeDirectory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeDirectory.d.ts","sourceRoot":"","sources":["../../../src/util/makeDirectory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,wBAAgB,wBAAwB,CAAC,aAAa,EAAE,MAAM,QAa7D"}

package/build/types/util/packageDependencyGraphService.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license Copyright 2019 Palantir Technologies, Inc. All rights reserved.
+ */
+import { Host, PackageJson } from "@monorepolint/utils";
+/** Interface for a node in a package dependency graph. */
+export interface IPackageDependencyGraphNode {
+    packageJson: PackageJson;
+    dependencies: Map<string, IPackageDependencyGraphNode>;
+    paths: {
+        packageJsonPath: string;
+        rootDirectory: string;
+    };
+}
+/** Service abstraction for constructing and traversing package dependency graphs. */
+export interface IPackageDependencyGraphService {
+    /** Construct a graph of package dependencies. */
+    buildDependencyGraph(packageJsonPath: string, host: Host, maxDepth?: number): IPackageDependencyGraphNode;
+    /** Traverse a package dependency graph. */
+    traverse(root: IPackageDependencyGraphNode, opts?: {
+        /** Traverse each unique path to a given package (potentially slow). */
+        traverseAllPaths?: boolean;
+    }): IterableIterator<IPackageDependencyGraphNode & {
+        importPath: IPackageDependencyGraphNode[];
+    }>;
+}
+/** Default implementation of the package dependency graph service. */
+export declare class PackageDependencyGraphService implements IPackageDependencyGraphService {
+    /** Construct a graph of package dependencies and return the root node. */
+    buildDependencyGraph(startPackageJsonPath: string, host: Host, maxDepth?: number): IPackageDependencyGraphNode;
+    /** Traverse a package dependency graph with an iterator. */
+    traverse(root: IPackageDependencyGraphNode, opts?: {
+        traverseAllPaths: boolean;
+    }): IterableIterator<IPackageDependencyGraphNode & {
+        importPath: IPackageDependencyGraphNode[];
+    }>;
+}
+//# sourceMappingURL=packageDependencyGraphService.d.ts.map

package/build/types/util/packageDependencyGraphService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageDependencyGraphService.d.ts","sourceRoot":"","sources":["../../../src/util/packageDependencyGraphService.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAIxD,0DAA0D;AAC1D,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,2BAA2B,CAAC,CAAC;IACvD,KAAK,EAAE;QACL,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,qFAAqF;AACrF,MAAM,WAAW,8BAA8B;IAC7C,iDAAiD;IACjD,oBAAoB,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,2BAA2B,CAAC;IAE1G,2CAA2C;IAC3C,QAAQ,CACN,IAAI,EAAE,2BAA2B,EACjC,IAAI,CAAC,EAAE;QACL,uEAAuE;QACvE,gBAAgB,CAAC,EAAE,OAAO,CAAC;KAC5B,GACA,gBAAgB,CAAC,2BAA2B,GAAG;QAAE,UAAU,EAAE,2BAA2B,EAAE,CAAA;KAAE,CAAC,CAAC;CAClG;AAED,sEAAsE;AACtE,qBAAa,6BAA8B,YAAW,8BAA8B;IAClF,0EAA0E;IACnE,oBAAoB,CACzB,oBAAoB,EAAE,MAAM,EAC5B,IAAI,EAAE,IAAI,EACV,QAAQ,CAAC,EAAE,MAAM,GAChB,2BAA2B;IAuC9B,4DAA4D;IACpD,QAAQ,CACd,IAAI,EAAE,2BAA2B,EACjC,IAAI;;KAA8B,GACjC,gBAAgB,CAAC,2BAA2B,GAAG;QAAE,UAAU,EAAE,2BAA2B,EAAE,CAAA;KAAE,CAAC;CA8BjG"}