eslint-plugin-better-tailwindcss 3.7.6 → 3.7.7

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

@@ -42,7 +42,7 @@ exports.TV_COMPOUND_VARIANTS_CLASS = [
     [
         {
             match: rule_js_1.MatcherType.ObjectValue,
-            pathPattern: "^compoundVariants\\[\\d+\\]\\.(?:className|class)$"
+            pathPattern: "^compoundVariants\\[\\d+\\]\\.(?:className|class).*$"
         }
     ]
 ];
@@ -51,7 +51,7 @@ exports.TV_COMPOUND_SLOTS_CLASS = [
     [
         {
             match: rule_js_1.MatcherType.ObjectValue,
-            pathPattern: "^compoundSlots\\[\\d+\\]\\.(?:className|class)$"
+            pathPattern: "^compoundSlots\\[\\d+\\]\\.(?:className|class).*$"
         }
     ]
 ];

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

@@ -1 +1 @@
-{"version":3,"file":"tv.js","sourceRoot":"","sources":["../../../../src/options/callees/tv.ts"],"names":[],"mappings":";;;AAAA,8DAA+D;AAKlD,QAAA,UAAU,GAAG;IACxB,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,MAAM;SAC1B;KACF;CACuB,CAAC;AAEd,QAAA,iBAAiB,GAAG;IAC/B,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,WAAW;YAC9B,WAAW,EAAE,cAAc;SAC5B;KACF;CACuB,CAAC;AAEd,QAAA,cAAc,GAAG;IAC5B,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,WAAW;YAC9B,WAAW,EAAE,QAAQ;SACtB;KACF;CACuB,CAAC;AAEd,QAAA,eAAe,GAAG;IAC7B,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,WAAW;YAC9B,WAAW,EAAE,WAAW;SACzB;KACF;CACuB,CAAC;AAEd,QAAA,0BAA0B,GAAG;IACxC,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,WAAW;YAC9B,WAAW,EAAE,oDAAoD;SAClE;KACF;CACuB,CAAC;AAEd,QAAA,uBAAuB,GAAG;IACrC,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,WAAW;YAC9B,WAAW,EAAE,iDAAiD;SAC/D;KACF;CACuB,CAAC;AAE3B,8EAA8E;AACjE,QAAA,EAAE,GAAG;IAChB,kBAAU;IACV,yBAAiB;IACjB,kCAA0B;IAC1B,sBAAc;IACd,uBAAe;IACf,+BAAuB;CACN,CAAC"}
+{"version":3,"file":"tv.js","sourceRoot":"","sources":["../../../../src/options/callees/tv.ts"],"names":[],"mappings":";;;AAAA,8DAA+D;AAKlD,QAAA,UAAU,GAAG;IACxB,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,MAAM;SAC1B;KACF;CACuB,CAAC;AAEd,QAAA,iBAAiB,GAAG;IAC/B,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,WAAW;YAC9B,WAAW,EAAE,cAAc;SAC5B;KACF;CACuB,CAAC;AAEd,QAAA,cAAc,GAAG;IAC5B,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,WAAW;YAC9B,WAAW,EAAE,QAAQ;SACtB;KACF;CACuB,CAAC;AAEd,QAAA,eAAe,GAAG;IAC7B,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,WAAW;YAC9B,WAAW,EAAE,WAAW;SACzB;KACF;CACuB,CAAC;AAEd,QAAA,0BAA0B,GAAG;IACxC,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,WAAW;YAC9B,WAAW,EAAE,sDAAsD;SACpE;KACF;CACuB,CAAC;AAEd,QAAA,uBAAuB,GAAG;IACrC,IAAI;IACJ;QACE;YACE,KAAK,EAAE,qBAAW,CAAC,WAAW;YAC9B,WAAW,EAAE,mDAAmD;SACjE;KACF;CACuB,CAAC;AAE3B,8EAA8E;AACjE,QAAA,EAAE,GAAG;IAChB,kBAAU;IACV,yBAAiB;IACjB,kCAA0B;IAC1B,sBAAc;IACd,uBAAe;IACf,+BAAuB;CACN,CAAC"}

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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,23 @@
+"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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,23 @@
+"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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,14 @@
+import type { InferOutput } from "valibot";
+export declare const ENTRYPOINT_OPTION_SCHEMA: import("valibot").ObjectSchema<{
+    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>;
+}, undefined>;
+export type EntryPointOption = InferOutput<typeof ENTRYPOINT_OPTION_SCHEMA>;
+export declare const TAILWIND_OPTION_SCHEMA: import("valibot").ObjectSchema<{
+    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>;
+}, undefined>;
+export type TailwindConfigOption = InferOutput<typeof TAILWIND_OPTION_SCHEMA>;
+export declare const TSCONFIG_OPTION_SCHEMA: 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>;
+}, undefined>;
+export type TSConfigOption = InferOutput<typeof TSCONFIG_OPTION_SCHEMA>;
+//# sourceMappingURL=common.d.ts.map

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

@@ -0,0 +1 @@
+{"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"}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSCONFIG_OPTION_SCHEMA = exports.TAILWIND_OPTION_SCHEMA = exports.ENTRYPOINT_OPTION_SCHEMA = void 0;
+const valibot_1 = require("valibot");
+exports.ENTRYPOINT_OPTION_SCHEMA = (0, valibot_1.object)({
+    entryPoint: (0, valibot_1.optional)((0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.description)("The path to the css entry point of the project. If not specified, the plugin will fall back to the default tailwind classes.")))
+});
+exports.TAILWIND_OPTION_SCHEMA = (0, valibot_1.object)({
+    tailwindConfig: (0, valibot_1.optional)((0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.description)("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.")))
+});
+exports.TSCONFIG_OPTION_SCHEMA = (0, valibot_1.object)({
+    tsconfig: (0, valibot_1.optional)((0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.description)("The path to the tsconfig file. Is used to resolve path aliases in the tsconfig.")))
+});
+//# sourceMappingURL=common.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../src/options/schemas/common.ts"],"names":[],"mappings":";;;AAAA,qCAAsE;AAKzD,QAAA,wBAAwB,GAAG,IAAA,gBAAM,EAAC;IAC7C,UAAU,EAAE,IAAA,kBAAQ,EAClB,IAAA,cAAI,EACF,IAAA,gBAAM,GAAE,EACR,IAAA,qBAAW,EAAC,8HAA8H,CAAC,CAC5I,CACF;CACF,CAAC,CAAC;AAIU,QAAA,sBAAsB,GAAG,IAAA,gBAAM,EAAC;IAC3C,cAAc,EAAE,IAAA,kBAAQ,EACtB,IAAA,cAAI,EACF,IAAA,gBAAM,GAAE,EACR,IAAA,qBAAW,EAAC,kJAAkJ,CAAC,CAChK,CACF;CACF,CAAC,CAAC;AAIU,QAAA,sBAAsB,GAAG,IAAA,gBAAM,EAAC;IAC3C,QAAQ,EAAE,IAAA,kBAAQ,EAChB,IAAA,cAAI,EACF,IAAA,gBAAM,GAAE,EACR,IAAA,qBAAW,EAAC,iFAAiF,CAAC,CAC/F,CACF;CACF,CAAC,CAAC"}

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

@@ -0,0 +1,13 @@
+import { MatcherType } from "../../types/rule.js";
+export declare const STRING_MATCHER_SCHEMA: import("valibot").ObjectSchema<{
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+}, undefined>;
+export declare const OBJECT_KEY_MATCHER_SCHEMA: import("valibot").ObjectSchema<{
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<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>;
+export declare const OBJECT_VALUE_MATCHER_SCHEMA: import("valibot").ObjectSchema<{
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<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>;
+//# sourceMappingURL=matchers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchers.d.ts","sourceRoot":"","sources":["../../../../src/options/schemas/matchers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAK/D,eAAO,MAAM,qBAAqB;;aAKM,CAAC;AAEzC,eAAO,MAAM,yBAAyB;;;aASE,CAAC;AAEzC,eAAO,MAAM,2BAA2B;;;aASA,CAAC"}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OBJECT_VALUE_MATCHER_SCHEMA = exports.OBJECT_KEY_MATCHER_SCHEMA = exports.STRING_MATCHER_SCHEMA = void 0;
+const valibot_1 = require("valibot");
+const rule_js_1 = require("../../types/rule.js");
+exports.STRING_MATCHER_SCHEMA = (0, valibot_1.object)({
+    match: (0, valibot_1.pipe)((0, valibot_1.literal)(rule_js_1.MatcherType.String), (0, valibot_1.description)("Matcher type that will be applied."))
+});
+exports.OBJECT_KEY_MATCHER_SCHEMA = (0, valibot_1.object)({
+    match: (0, valibot_1.pipe)((0, valibot_1.literal)(rule_js_1.MatcherType.ObjectKey), (0, valibot_1.description)("Matcher type that will be applied.")),
+    pathPattern: (0, valibot_1.optional)((0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.description)("Regular expression that filters the object key and matches the content for further processing in a group.")))
+});
+exports.OBJECT_VALUE_MATCHER_SCHEMA = (0, valibot_1.object)({
+    match: (0, valibot_1.pipe)((0, valibot_1.literal)(rule_js_1.MatcherType.ObjectValue), (0, valibot_1.description)("Matcher type that will be applied.")),
+    pathPattern: (0, valibot_1.optional)((0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.description)("Regular expression that filters the object value and matches the content for further processing in a group.")))
+});
+//# sourceMappingURL=matchers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchers.js","sourceRoot":"","sources":["../../../../src/options/schemas/matchers.ts"],"names":[],"mappings":";;;AAAA,qCAA+E;AAE/E,8DAA+D;AAKlD,QAAA,qBAAqB,GAAG,IAAA,gBAAM,EAAC;IAC1C,KAAK,EAAE,IAAA,cAAI,EACT,IAAA,iBAAO,EAAC,qBAAW,CAAC,MAAM,CAAC,EAC3B,IAAA,qBAAW,EAAC,oCAAoC,CAAC,CAClD;CACF,CAAuC,CAAC;AAE5B,QAAA,yBAAyB,GAAG,IAAA,gBAAM,EAAC;IAC9C,KAAK,EAAE,IAAA,cAAI,EACT,IAAA,iBAAO,EAAC,qBAAW,CAAC,SAAS,CAAC,EAC9B,IAAA,qBAAW,EAAC,oCAAoC,CAAC,CAClD;IACD,WAAW,EAAE,IAAA,kBAAQ,EAAC,IAAA,cAAI,EACxB,IAAA,gBAAM,GAAE,EACR,IAAA,qBAAW,EAAC,2GAA2G,CAAC,CACzH,CAAC;CACH,CAAuC,CAAC;AAE5B,QAAA,2BAA2B,GAAG,IAAA,gBAAM,EAAC;IAChD,KAAK,EAAE,IAAA,cAAI,EACT,IAAA,iBAAO,EAAC,qBAAW,CAAC,WAAW,CAAC,EAChC,IAAA,qBAAW,EAAC,oCAAoC,CAAC,CAClD;IACD,WAAW,EAAE,IAAA,kBAAQ,EAAC,IAAA,cAAI,EACxB,IAAA,gBAAM,GAAE,EACR,IAAA,qBAAW,EAAC,6GAA6G,CAAC,CAC3H,CAAC;CACH,CAAuC,CAAC"}

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

@@ -0,0 +1,101 @@
+import type { InferOutput } from "valibot";
+declare const TAG_MATCHER_CONFIG: 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.">]>;
+export type TagMatchers = InferOutput<typeof TAG_MATCHER_CONFIG>;
+declare const TAG_NAME_CONFIG: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Template literal tag that should get linted.">]>;
+export type TagName = InferOutput<typeof TAG_NAME_CONFIG>;
+export declare const TAGS_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, "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.">]>;
+export type Tags = InferOutput<typeof TAGS_SCHEMA>;
+export declare const TAGS_OPTIONS_SCHEMA: import("valibot").ObjectSchema<{
+    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[]>;
+}, undefined>;
+export type TagsOptions = InferOutput<typeof TAGS_OPTIONS_SCHEMA>;
+export {};
+//# sourceMappingURL=tags.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../../../src/options/schemas/tags.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;gEAkBvB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEjE,QAAA,MAAM,eAAe,qLAGpB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,eAAe,CAAC,CAAC;AAE1D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAQvB,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAEQ,CAAC;AAEzC,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TAGS_OPTIONS_SCHEMA = exports.TAGS_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 TAG_MATCHER_CONFIG = (0, valibot_1.pipe)((0, valibot_1.tuple)([
+    (0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.description)("Template literal tag 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 TAG_NAME_CONFIG = (0, valibot_1.pipe)((0, valibot_1.string)(), (0, valibot_1.description)("Template literal tag that should get linted."));
+exports.TAGS_SCHEMA = (0, valibot_1.pipe)((0, valibot_1.array)((0, valibot_1.union)([
+    TAG_MATCHER_CONFIG,
+    TAG_NAME_CONFIG
+])), (0, valibot_1.description)("List of template literal tags that should get linted."));
+exports.TAGS_OPTIONS_SCHEMA = (0, valibot_1.object)({
+    tags: (0, valibot_1.optional)(exports.TAGS_SCHEMA, default_options_js_1.DEFAULT_TAG_NAMES)
+});
+//# sourceMappingURL=tags.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tags.js","sourceRoot":"","sources":["../../../../src/options/schemas/tags.ts"],"names":[],"mappings":";;;AAAA,qCASiB;AAEjB,sFAAkF;AAClF,gFAIwD;AAMxD,MAAM,kBAAkB,GAAG,IAAA,cAAI,EAC7B,IAAA,eAAK,EAAC;IACJ,IAAA,cAAI,EACF,IAAA,gBAAM,GAAE,EACR,IAAA,qBAAW,EAAC,gEAAgE,CAAC,CAC9E;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,eAAe,GAAG,IAAA,cAAI,EAC1B,IAAA,gBAAM,GAAE,EACR,IAAA,qBAAW,EAAC,8CAA8C,CAAC,CAC5D,CAAC;AAIW,QAAA,WAAW,GAAG,IAAA,cAAI,EAC7B,IAAA,eAAK,EACH,IAAA,eAAK,EAAC;IACJ,kBAAkB;IAClB,eAAe;CAChB,CAAC,CACH,EACD,IAAA,qBAAW,EAAC,uDAAuD,CAAC,CACrE,CAAC;AAIW,QAAA,mBAAmB,GAAG,IAAA,gBAAM,EAAC;IACxC,IAAI,EAAE,IAAA,kBAAQ,EAAC,mBAAW,EAAE,sCAAiB,CAAC;CAC/C,CAAuC,CAAC"}