eslint-plugin-better-tailwindcss 4.0.0-beta.5 → 4.0.0-beta.6

package/lib/cjs/options/default-options.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_TAG_NAMES = exports.DEFAULT_VARIABLE_NAMES = exports.DEFAULT_ATTRIBUTE_NAMES = exports.DEFAULT_CALLEE_NAMES = void 0;
-const cc_js_1 = require("./callees/cc.js");
-const clb_js_1 = require("./callees/clb.js");
-const clsx_js_1 = require("./callees/clsx.js");
-const cn_js_1 = require("./callees/cn.js");
-const cnb_js_1 = require("./callees/cnb.js");
-const ctl_js_1 = require("./callees/ctl.js");
-const cva_js_1 = require("./callees/cva.js");
-const cx_js_1 = require("./callees/cx.js");
-const dcnb_js_1 = require("./callees/dcnb.js");
-const objstr_js_1 = require("./callees/objstr.js");
-const tv_js_1 = require("./callees/tv.js");
-const twJoin_js_1 = require("./callees/twJoin.js");
-const twMerge_js_1 = require("./callees/twMerge.js");
-const rule_js_1 = require("../types/rule.js");
-exports.DEFAULT_CALLEE_NAMES = [
-    ...cc_js_1.CC,
-    ...clb_js_1.CLB,
-    ...clsx_js_1.CLSX,
-    ...cn_js_1.CN,
-    ...cnb_js_1.CNB,
-    ...ctl_js_1.CTL,
-    ...cva_js_1.CVA,
-    ...cx_js_1.CX,
-    ...dcnb_js_1.DCNB,
-    ...objstr_js_1.OBJSTR,
-    ...tv_js_1.TV,
-    ...twJoin_js_1.TW_JOIN,
-    ...twMerge_js_1.TW_MERGE
-];
-exports.DEFAULT_ATTRIBUTE_NAMES = [
-    // general
-    "^class(?:Name)?$",
-    [
-        "^class(?:Name)?$", [
-            {
-                match: rule_js_1.MatcherType.String
-            }
-        ]
-    ],
-    // angular
-    "(?:^\\[class\\]$)|(?:^\\[ngClass\\]$)",
-    [
-        "(?:^\\[class\\]$)|(?:^\\[ngClass\\]$)", [
-            {
-                match: rule_js_1.MatcherType.String
-            },
-            {
-                match: rule_js_1.MatcherType.ObjectKey
-            }
-        ]
-    ],
-    // vue
-    [
-        "^v-bind:class$", [
-            {
-                match: rule_js_1.MatcherType.String
-            },
-            {
-                match: rule_js_1.MatcherType.ObjectKey
-            }
-        ]
-    ],
-    // astro
-    [
-        "^class:list$", [
-            {
-                match: rule_js_1.MatcherType.String
-            },
-            {
-                match: rule_js_1.MatcherType.ObjectKey
-            }
-        ]
-    ]
-];
-exports.DEFAULT_VARIABLE_NAMES = [
-    [
-        "^classNames?$", [
-            {
-                match: rule_js_1.MatcherType.String
-            }
-        ]
-    ],
-    [
-        "^classes$", [
-            {
-                match: rule_js_1.MatcherType.String
-            }
-        ]
-    ],
-    [
-        "^styles?$", [
-            {
-                match: rule_js_1.MatcherType.String
-            }
-        ]
-    ]
-];
-exports.DEFAULT_TAG_NAMES = [];
-//# sourceMappingURL=default-options.js.map

package/lib/cjs/options/default-options.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"default-options.js","sourceRoot":"","sources":["../../../src/options/default-options.ts"],"names":[],"mappings":";;;AAAA,oEAA8D;AAC9D,sEAAgE;AAChE,wEAAkE;AAClE,oEAA8D;AAC9D,sEAAgE;AAChE,sEAAgE;AAChE,sEAAgE;AAChE,oEAA8D;AAC9D,wEAAkE;AAClE,4EAAsE;AACtE,oEAA8D;AAC9D,4EAAuE;AACvE,8EAAyE;AACzE,8DAA+D;AAQlD,QAAA,oBAAoB,GAAG;IAClC,GAAG,UAAE;IACL,GAAG,YAAG;IACN,GAAG,cAAI;IACP,GAAG,UAAE;IACL,GAAG,YAAG;IACN,GAAG,YAAG;IACN,GAAG,YAAG;IACN,GAAG,UAAE;IACL,GAAG,cAAI;IACP,GAAG,kBAAM;IACT,GAAG,UAAE;IACL,GAAG,mBAAO;IACV,GAAG,qBAAQ;CACM,CAAC;AAEP,QAAA,uBAAuB,GAAG;IACrC,UAAU;IACV,kBAAkB;IAClB;QACE,kBAAkB,EAAE;YAClB;gBACE,KAAK,EAAE,qBAAW,CAAC,MAAM;aAC1B;SACF;KACF;IAED,UAAU;IACV,uCAAuC;IACvC;QACE,uCAAuC,EAAE;YACvC;gBACE,KAAK,EAAE,qBAAW,CAAC,MAAM;aAC1B;YACD;gBACE,KAAK,EAAE,qBAAW,CAAC,SAAS;aAC7B;SACF;KACF;IAED,MAAM;IACN;QACE,gBAAgB,EAAE;YAChB;gBACE,KAAK,EAAE,qBAAW,CAAC,MAAM;aAC1B;YACD;gBACE,KAAK,EAAE,qBAAW,CAAC,SAAS;aAC7B;SACF;KACF;IAED,QAAQ;IACR;QACE,cAAc,EAAE;YACd;gBACE,KAAK,EAAE,qBAAW,CAAC,MAAM;aAC1B;YACD;gBACE,KAAK,EAAE,qBAAW,CAAC,SAAS;aAC7B;SACF;KACF;CACmB,CAAC;AAEV,QAAA,sBAAsB,GAAG;IACpC;QACE,eAAe,EAAE;YACf;gBACE,KAAK,EAAE,qBAAW,CAAC,MAAM;aAC1B;SACF;KACF;IACD;QACE,WAAW,EAAE;YACX;gBACE,KAAK,EAAE,qBAAW,CAAC,MAAM;aAC1B;SACF;KACF;IACD;QACE,WAAW,EAAE;YACX;gBACE,KAAK,EAAE,qBAAW,CAAC,MAAM;aAC1B;SACF;KACF;CACkB,CAAC;AAET,QAAA,iBAAiB,GAAG,EAAiB,CAAC"}

package/lib/cjs/options/descriptions.d.ts

@@ -1,153 +0,0 @@
-import type { InferOutput } from "valibot";
-export declare const COMMON_OPTIONS: import("valibot").ObjectSchema<{
-    readonly tsconfig: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "The path to the tsconfig file. Is used to resolve path aliases in the tsconfig.">]>, undefined>;
-    readonly tailwindConfig: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "The path to the tailwind config file. If not specified, the plugin will try to find it automatically or falls back to the default configuration.">]>, undefined>;
-    readonly entryPoint: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "The path to the css entry point of the project. If not specified, the plugin will fall back to the default tailwind classes.">]>, undefined>;
-    readonly tags: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Template literal tag for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.String, "Matcher type that will be applied.">]>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]], "List of matchers that will automatically be matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Template literal tag that should get linted.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]])[], "List of template literal tags that should get linted.">]>, never[]>;
-    readonly variables: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Variable name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.String, "Matcher type that will be applied.">]>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]], "List of matchers that will automatically be matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Variable name for which children get linted.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]])[], "List of variable names which values should get linted.">]>, [string, {
-        match: import("../types/rule").MatcherType.String;
-    }[]][]>;
-    readonly attributes: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Attribute name that for which children get linted.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Attribute name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.String, "Matcher type that will be applied.">]>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]], "List of matchers that will automatically be matched.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]])[], "List of attribute names that should get linted.">]>, (string | [string, ({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-    })[]])[]>;
-    readonly callees: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Callee name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.String, "Matcher type that will be applied.">]>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]], "List of matchers that will automatically be matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Callee name for which children get linted.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
-        match: import("../types/rule").MatcherType.String;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]])[], "List of function names which arguments should get linted.">]>, ([string, {
-        match: import("../types/rule").MatcherType.String;
-    }[]] | [string, {
-        match: import("../types/rule").MatcherType.ObjectKey;
-    }[]] | [string, {
-        match: import("../types/rule").MatcherType.ObjectValue;
-        pathPattern: string;
-    }[]])[]>;
-}, undefined>;
-export type CommonOptions = InferOutput<typeof COMMON_OPTIONS>;
-//# sourceMappingURL=descriptions.d.ts.map

package/lib/cjs/options/descriptions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptions.d.ts","sourceRoot":"","sources":["../../../src/options/descriptions.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAQzB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/lib/cjs/options/descriptions.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMMON_OPTIONS = void 0;
-const valibot_1 = require("valibot");
-const attributes_js_1 = require("./schemas/attributes.js");
-const callees_js_1 = require("./schemas/callees.js");
-const common_js_1 = require("./schemas/common.js");
-const tags_js_1 = require("./schemas/tags.js");
-const variables_js_1 = require("./schemas/variables.js");
-exports.COMMON_OPTIONS = (0, valibot_1.object)({
-    ...callees_js_1.CALLEES_OPTION_SCHEMA.entries,
-    ...attributes_js_1.ATTRIBUTES_OPTION_SCHEMA.entries,
-    ...variables_js_1.VARIABLES_OPTION_SCHEMA.entries,
-    ...tags_js_1.TAGS_OPTIONS_SCHEMA.entries,
-    ...common_js_1.ENTRYPOINT_OPTION_SCHEMA.entries,
-    ...common_js_1.TAILWIND_OPTION_SCHEMA.entries,
-    ...common_js_1.TSCONFIG_OPTION_SCHEMA.entries
-});
-//# sourceMappingURL=descriptions.js.map

package/lib/cjs/options/descriptions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptions.js","sourceRoot":"","sources":["../../../src/options/descriptions.ts"],"names":[],"mappings":";;;AAAA,qCAAiC;AAEjC,oFAA4F;AAC5F,8EAAsF;AACtF,4EAIsD;AACtD,wEAAiF;AACjF,kFAA0F;AAK7E,QAAA,cAAc,GAAG,IAAA,gBAAM,EAAC;IACnC,GAAG,kCAAqB,CAAC,OAAO;IAChC,GAAG,wCAAwB,CAAC,OAAO;IACnC,GAAG,sCAAuB,CAAC,OAAO;IAClC,GAAG,6BAAmB,CAAC,OAAO;IAC9B,GAAG,oCAAwB,CAAC,OAAO;IACnC,GAAG,kCAAsB,CAAC,OAAO;IACjC,GAAG,kCAAsB,CAAC,OAAO;CAClC,CAAC,CAAC"}

package/lib/cjs/options/schemas/attributes.d.ts

@@ -1,104 +0,0 @@
-import type { InferOutput } from "valibot";
-export declare const ATTRIBUTE_MATCHER_CONFIG: import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Attribute name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.String, "Matcher type that will be applied.">]>;
-}, undefined>, import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
-    readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
-}, undefined>, import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
-    readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
-}, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
-    match: import("../../types/rule").MatcherType.String;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectKey;
-    pathPattern?: string | undefined;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectValue;
-    pathPattern?: string | undefined;
-})[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
-    match: import("../../types/rule").MatcherType.String;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectKey;
-    pathPattern?: string | undefined;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectValue;
-    pathPattern?: string | undefined;
-})[]], "List of matchers that will automatically be matched.">]>;
-export type AttributeMatchers = InferOutput<typeof ATTRIBUTE_MATCHER_CONFIG>;
-export declare const ATTRIBUTE_NAME_CONFIG: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Attribute name that for which children get linted.">]>;
-export type AttributeName = InferOutput<typeof ATTRIBUTE_NAME_CONFIG>;
-export declare const ATTRIBUTES_SCHEMA: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Attribute name that for which children get linted.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Attribute name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.String, "Matcher type that will be applied.">]>;
-}, undefined>, import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
-    readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
-}, undefined>, import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
-    readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
-}, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
-    match: import("../../types/rule").MatcherType.String;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectKey;
-    pathPattern?: string | undefined;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectValue;
-    pathPattern?: string | undefined;
-})[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
-    match: import("../../types/rule").MatcherType.String;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectKey;
-    pathPattern?: string | undefined;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectValue;
-    pathPattern?: string | undefined;
-})[]], "List of matchers that will automatically be matched.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
-    match: import("../../types/rule").MatcherType.String;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectKey;
-    pathPattern?: string | undefined;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectValue;
-    pathPattern?: string | undefined;
-})[]])[], "List of attribute names that should get linted.">]>;
-export type Attributes = InferOutput<typeof ATTRIBUTES_SCHEMA>;
-export declare const ATTRIBUTES_OPTION_SCHEMA: import("valibot").ObjectSchema<{
-    readonly attributes: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Attribute name that for which children get linted.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Attribute name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.String, "Matcher type that will be applied.">]>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
-        match: import("../../types/rule").MatcherType.String;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
-        match: import("../../types/rule").MatcherType.String;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]], "List of matchers that will automatically be matched.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
-        match: import("../../types/rule").MatcherType.String;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]])[], "List of attribute names that should get linted.">]>, (string | [string, ({
-        match: import("../../types/rule").MatcherType.String;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectKey;
-    })[]])[]>;
-}, undefined>;
-export type AttributesOptions = InferOutput<typeof ATTRIBUTES_OPTION_SCHEMA>;
-//# sourceMappingURL=attributes.d.ts.map

package/lib/cjs/options/schemas/attributes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../../src/options/schemas/attributes.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;gEAkBpC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE7E,eAAO,MAAM,qBAAqB,2LAGjC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEtE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAQ7B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE/D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAEG,CAAC;AAEzC,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/lib/cjs/options/schemas/attributes.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ATTRIBUTES_OPTION_SCHEMA = exports.ATTRIBUTES_SCHEMA = exports.ATTRIBUTE_NAME_CONFIG = exports.ATTRIBUTE_MATCHER_CONFIG = void 0;
-const valibot_1 = require("valibot");
-const default_options_js_1 = require("../default-options.js");
-const matchers_js_1 = require("../schemas/matchers.js");
-exports.ATTRIBUTE_MATCHER_CONFIG = (0, valibot_1.pipe)((0, valibot_1.tuple)([
-    (0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.description)("Attribute name for which children get linted if matched.")),
-    (0, valibot_1.pipe)((0, valibot_1.array)((0, valibot_1.union)([
-        matchers_js_1.STRING_MATCHER_SCHEMA,
-        matchers_js_1.OBJECT_KEY_MATCHER_SCHEMA,
-        matchers_js_1.OBJECT_VALUE_MATCHER_SCHEMA
-    ])), (0, valibot_1.description)("List of matchers that will be applied."))
-]), (0, valibot_1.description)("List of matchers that will automatically be matched."));
-exports.ATTRIBUTE_NAME_CONFIG = (0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.description)("Attribute name that for which children get linted."));
-exports.ATTRIBUTES_SCHEMA = (0, valibot_1.pipe)((0, valibot_1.array)((0, valibot_1.union)([
-    exports.ATTRIBUTE_NAME_CONFIG,
-    exports.ATTRIBUTE_MATCHER_CONFIG
-])), (0, valibot_1.description)("List of attribute names that should get linted."));
-exports.ATTRIBUTES_OPTION_SCHEMA = (0, valibot_1.object)({
-    attributes: (0, valibot_1.optional)(exports.ATTRIBUTES_SCHEMA, default_options_js_1.DEFAULT_ATTRIBUTE_NAMES)
-});
-//# sourceMappingURL=attributes.js.map

package/lib/cjs/options/schemas/attributes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attributes.js","sourceRoot":"","sources":["../../../../src/options/schemas/attributes.ts"],"names":[],"mappings":";;;AAAA,qCASiB;AAEjB,sFAAwF;AACxF,gFAIwD;AAM3C,QAAA,wBAAwB,GAAG,IAAA,cAAI,EAC1C,IAAA,eAAK,EAAC;IACJ,IAAA,cAAI,EACF,IAAA,gBAAM,GAAE,EACR,IAAA,qBAAW,EAAC,0DAA0D,CAAC,CACxE;IACD,IAAA,cAAI,EACF,IAAA,eAAK,EACH,IAAA,eAAK,EAAC;QACJ,mCAAqB;QACrB,uCAAyB;QACzB,yCAA2B;KAC5B,CAAC,CACH,EACD,IAAA,qBAAW,EAAC,wCAAwC,CAAC,CACtD;CACF,CAAC,EACF,IAAA,qBAAW,EAAC,sDAAsD,CAAC,CACpE,CAAC;AAIW,QAAA,qBAAqB,GAAG,IAAA,cAAI,EACvC,IAAA,gBAAM,GAAE,EACR,IAAA,qBAAW,EAAC,oDAAoD,CAAC,CAClE,CAAC;AAIW,QAAA,iBAAiB,GAAG,IAAA,cAAI,EACnC,IAAA,eAAK,EACH,IAAA,eAAK,EAAC;IACJ,6BAAqB;IACrB,gCAAwB;CACzB,CAAC,CACH,EACD,IAAA,qBAAW,EAAC,iDAAiD,CAAC,CAC/D,CAAC;AAIW,QAAA,wBAAwB,GAAG,IAAA,gBAAM,EAAC;IAC7C,UAAU,EAAE,IAAA,kBAAQ,EAAC,yBAAiB,EAAE,4CAAuB,CAAC;CACjE,CAAuC,CAAC"}

package/lib/cjs/options/schemas/callees.d.ts

@@ -1,108 +0,0 @@
-import type { InferOutput } from "valibot";
-declare const CALLEE_MATCHER_SCHEMA: import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Callee name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.String, "Matcher type that will be applied.">]>;
-}, undefined>, import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
-    readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
-}, undefined>, import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
-    readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
-}, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
-    match: import("../../types/rule").MatcherType.String;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectKey;
-    pathPattern?: string | undefined;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectValue;
-    pathPattern?: string | undefined;
-})[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
-    match: import("../../types/rule").MatcherType.String;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectKey;
-    pathPattern?: string | undefined;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectValue;
-    pathPattern?: string | undefined;
-})[]], "List of matchers that will automatically be matched.">]>;
-export type CalleeMatchers = InferOutput<typeof CALLEE_MATCHER_SCHEMA>;
-declare const CALLEE_NAME_SCHEMA: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Callee name for which children get linted.">]>;
-export type CalleeName = InferOutput<typeof CALLEE_NAME_SCHEMA>;
-export declare const CALLEES_SCHEMA: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Callee name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.String, "Matcher type that will be applied.">]>;
-}, undefined>, import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
-    readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
-}, undefined>, import("valibot").ObjectSchema<{
-    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
-    readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
-}, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
-    match: import("../../types/rule").MatcherType.String;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectKey;
-    pathPattern?: string | undefined;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectValue;
-    pathPattern?: string | undefined;
-})[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
-    match: import("../../types/rule").MatcherType.String;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectKey;
-    pathPattern?: string | undefined;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectValue;
-    pathPattern?: string | undefined;
-})[]], "List of matchers that will automatically be matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Callee name for which children get linted.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
-    match: import("../../types/rule").MatcherType.String;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectKey;
-    pathPattern?: string | undefined;
-} | {
-    match: import("../../types/rule").MatcherType.ObjectValue;
-    pathPattern?: string | undefined;
-})[]])[], "List of function names which arguments should get linted.">]>;
-export type Callees = InferOutput<typeof CALLEES_SCHEMA>;
-export declare const CALLEES_OPTION_SCHEMA: import("valibot").ObjectSchema<{
-    readonly callees: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Callee name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.String, "Matcher type that will be applied.">]>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../../types/rule").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../../types/rule").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
-        readonly pathPattern: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
-    }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
-        match: import("../../types/rule").MatcherType.String;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[], "List of matchers that will be applied.">]>], undefined>, import("valibot").DescriptionAction<[string, ({
-        match: import("../../types/rule").MatcherType.String;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]], "List of matchers that will automatically be matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Callee name for which children get linted.">]>], undefined>, undefined>, import("valibot").DescriptionAction<(string | [string, ({
-        match: import("../../types/rule").MatcherType.String;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectKey;
-        pathPattern?: string | undefined;
-    } | {
-        match: import("../../types/rule").MatcherType.ObjectValue;
-        pathPattern?: string | undefined;
-    })[]])[], "List of function names which arguments should get linted.">]>, ([string, {
-        match: import("../../types/rule").MatcherType.String;
-    }[]] | [string, {
-        match: import("../../types/rule").MatcherType.ObjectKey;
-    }[]] | [string, {
-        match: import("../../types/rule").MatcherType.ObjectValue;
-        pathPattern: string;
-    }[]])[]>;
-}, undefined>;
-export type CalleesOptions = InferOutput<typeof CALLEES_OPTION_SCHEMA>;
-export {};
-//# sourceMappingURL=callees.d.ts.map

package/lib/cjs/options/schemas/callees.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"callees.d.ts","sourceRoot":"","sources":["../../../../src/options/schemas/callees.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;gEAkB1B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEvE,QAAA,MAAM,kBAAkB,mLAGvB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEhE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wEAQ1B,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC;AAEzD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAEM,CAAC;AAEzC,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/lib/cjs/options/schemas/callees.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CALLEES_OPTION_SCHEMA = exports.CALLEES_SCHEMA = void 0;
-const valibot_1 = require("valibot");
-const default_options_js_1 = require("../default-options.js");
-const matchers_js_1 = require("../schemas/matchers.js");
-const CALLEE_MATCHER_SCHEMA = (0, valibot_1.pipe)((0, valibot_1.tuple)([
-    (0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.description)("Callee name for which children get linted if matched.")),
-    (0, valibot_1.pipe)((0, valibot_1.array)((0, valibot_1.union)([
-        matchers_js_1.STRING_MATCHER_SCHEMA,
-        matchers_js_1.OBJECT_KEY_MATCHER_SCHEMA,
-        matchers_js_1.OBJECT_VALUE_MATCHER_SCHEMA
-    ])), (0, valibot_1.description)("List of matchers that will be applied."))
-]), (0, valibot_1.description)("List of matchers that will automatically be matched."));
-const CALLEE_NAME_SCHEMA = (0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.description)("Callee name for which children get linted."));
-exports.CALLEES_SCHEMA = (0, valibot_1.pipe)((0, valibot_1.array)((0, valibot_1.union)([
-    CALLEE_MATCHER_SCHEMA,
-    CALLEE_NAME_SCHEMA
-])), (0, valibot_1.description)("List of function names which arguments should get linted."));
-exports.CALLEES_OPTION_SCHEMA = (0, valibot_1.object)({
-    callees: (0, valibot_1.optional)(exports.CALLEES_SCHEMA, default_options_js_1.DEFAULT_CALLEE_NAMES)
-});
-//# sourceMappingURL=callees.js.map

package/lib/cjs/options/schemas/callees.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"callees.js","sourceRoot":"","sources":["../../../../src/options/schemas/callees.ts"],"names":[],"mappings":";;;AAAA,qCASiB;AAEjB,sFAAqF;AACrF,gFAIwD;AAMxD,MAAM,qBAAqB,GAAG,IAAA,cAAI,EAChC,IAAA,eAAK,EAAC;IACJ,IAAA,cAAI,EACF,IAAA,gBAAM,GAAE,EACR,IAAA,qBAAW,EAAC,uDAAuD,CAAC,CACrE;IACD,IAAA,cAAI,EACF,IAAA,eAAK,EACH,IAAA,eAAK,EAAC;QACJ,mCAAqB;QACrB,uCAAyB;QACzB,yCAA2B;KAC5B,CAAC,CACH,EACD,IAAA,qBAAW,EAAC,wCAAwC,CAAC,CACtD;CACF,CAAC,EACF,IAAA,qBAAW,EAAC,sDAAsD,CAAC,CACpE,CAAC;AAIF,MAAM,kBAAkB,GAAG,IAAA,cAAI,EAC7B,IAAA,gBAAM,GAAE,EACR,IAAA,qBAAW,EAAC,4CAA4C,CAAC,CAC1D,CAAC;AAIW,QAAA,cAAc,GAAG,IAAA,cAAI,EAChC,IAAA,eAAK,EACH,IAAA,eAAK,EAAC;IACJ,qBAAqB;IACrB,kBAAkB;CACnB,CAAC,CACH,EACD,IAAA,qBAAW,EAAC,2DAA2D,CAAC,CACzE,CAAC;AAIW,QAAA,qBAAqB,GAAG,IAAA,gBAAM,EAAC;IAC1C,OAAO,EAAE,IAAA,kBAAQ,EAAC,sBAAc,EAAE,yCAAoB,CAAC;CACxD,CAAuC,CAAC"}

package/lib/cjs/options/schemas/common.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/options/schemas/common.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,eAAO,MAAM,wBAAwB;;aAOnC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE5E,eAAO,MAAM,sBAAsB;;aAOjC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE9E,eAAO,MAAM,sBAAsB;;aAOjC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC"}