eslint-plugin-better-tailwindcss 4.1.1 → 4.3.0

package/lib/options/schemas/selectors.d.ts

@@ -0,0 +1,488 @@
+import { MatcherType, SelectorKind } from "../../types/rule.js";
+import type { InferOutput } from "valibot";
+export declare const SELECTOR_SCHEMA: import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+    readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Attribute, undefined>, import("valibot").DescriptionAction<SelectorKind.Attribute, "Selector kind that determines where matching is applied.">]>;
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+    }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined, "Optional list of matchers that will be applied.">]>;
+    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+}, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+    readonly callTarget: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional call target for curried callees: index, first, last, or all.">]>;
+    readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Callee, undefined>, import("valibot").DescriptionAction<SelectorKind.Callee, "Selector kind that determines where matching is applied.">]>;
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+    }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined, "Optional list of matchers that will be applied.">]>;
+    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+    readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for callee paths that should be linted.">]>, undefined>;
+}, undefined>, import("valibot").StrictObjectSchema<{
+    readonly callTarget: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional call target for curried callees: index, first, last, or all.">]>;
+    readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Callee, undefined>, import("valibot").DescriptionAction<SelectorKind.Callee, "Selector kind that determines where matching is applied.">]>;
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+    }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined, "Optional list of matchers that will be applied.">]>;
+    readonly name: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>, undefined>;
+    readonly path: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for callee paths that should be linted.">]>;
+}, undefined>], undefined>, import("valibot").StrictObjectSchema<{
+    readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Tag, undefined>, import("valibot").DescriptionAction<SelectorKind.Tag, "Selector kind that determines where matching is applied.">]>;
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+    }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined, "Optional list of matchers that will be applied.">]>;
+    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+}, undefined>, import("valibot").StrictObjectSchema<{
+    readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Variable, undefined>, import("valibot").DescriptionAction<SelectorKind.Variable, "Selector kind that determines where matching is applied.">]>;
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+    }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined, "Optional list of matchers that will be applied.">]>;
+    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+}, undefined>], undefined>;
+export type Selector = InferOutput<typeof SELECTOR_SCHEMA>;
+export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+    readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Attribute, undefined>, import("valibot").DescriptionAction<SelectorKind.Attribute, "Selector kind that determines where matching is applied.">]>;
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+    }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined, "Optional list of matchers that will be applied.">]>;
+    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+}, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+    readonly callTarget: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional call target for curried callees: index, first, last, or all.">]>;
+    readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Callee, undefined>, import("valibot").DescriptionAction<SelectorKind.Callee, "Selector kind that determines where matching is applied.">]>;
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+    }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined, "Optional list of matchers that will be applied.">]>;
+    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+    readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for callee paths that should be linted.">]>, undefined>;
+}, undefined>, import("valibot").StrictObjectSchema<{
+    readonly callTarget: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional call target for curried callees: index, first, last, or all.">]>;
+    readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Callee, undefined>, import("valibot").DescriptionAction<SelectorKind.Callee, "Selector kind that determines where matching is applied.">]>;
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+    }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined, "Optional list of matchers that will be applied.">]>;
+    readonly name: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>, undefined>;
+    readonly path: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for callee paths that should be linted.">]>;
+}, undefined>], undefined>, import("valibot").StrictObjectSchema<{
+    readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Tag, undefined>, import("valibot").DescriptionAction<SelectorKind.Tag, "Selector kind that determines where matching is applied.">]>;
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+    }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined, "Optional list of matchers that will be applied.">]>;
+    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+}, undefined>, import("valibot").StrictObjectSchema<{
+    readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Variable, undefined>, import("valibot").DescriptionAction<SelectorKind.Variable, "Selector kind that determines where matching is applied.">]>;
+    readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly path: 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>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+    }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined, "Optional list of matchers that will be applied.">]>;
+    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+}, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+    callTarget?: number | "all" | "first" | "last" | undefined;
+    kind: SelectorKind.Callee;
+    match?: ({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined;
+    name: string;
+    path?: string | undefined;
+} | {
+    callTarget?: number | "all" | "first" | "last" | undefined;
+    kind: SelectorKind.Callee;
+    match?: ({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined;
+    name?: string | undefined;
+    path: string;
+} | {
+    kind: SelectorKind.Attribute;
+    match?: ({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined;
+    name: string;
+} | {
+    kind: SelectorKind.Tag;
+    match?: ({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined;
+    name: string;
+} | {
+    kind: SelectorKind.Variable;
+    match?: ({
+        type: MatcherType.String;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectKey;
+    } | {
+        path?: string | undefined;
+        type: MatcherType.ObjectValue;
+    })[] | undefined;
+    name: string;
+})[], "Flat list of selectors that should get linted.">]>;
+export type Selectors = InferOutput<typeof SELECTORS_SCHEMA>;
+export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSchema<{
+    readonly selectors: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Attribute, undefined>, import("valibot").DescriptionAction<SelectorKind.Attribute, "Selector kind that determines where matching is applied.">]>;
+        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: 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>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: 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>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[] | undefined, "Optional list of matchers that will be applied.">]>;
+        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+    }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly callTarget: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional call target for curried callees: index, first, last, or all.">]>;
+        readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Callee, undefined>, import("valibot").DescriptionAction<SelectorKind.Callee, "Selector kind that determines where matching is applied.">]>;
+        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: 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>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: 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>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[] | undefined, "Optional list of matchers that will be applied.">]>;
+        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+        readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for callee paths that should be linted.">]>, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly callTarget: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional call target for curried callees: index, first, last, or all.">]>;
+        readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Callee, undefined>, import("valibot").DescriptionAction<SelectorKind.Callee, "Selector kind that determines where matching is applied.">]>;
+        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: 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>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: 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>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[] | undefined, "Optional list of matchers that will be applied.">]>;
+        readonly name: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>, undefined>;
+        readonly path: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for callee paths that should be linted.">]>;
+    }, undefined>], undefined>, import("valibot").StrictObjectSchema<{
+        readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Tag, undefined>, import("valibot").DescriptionAction<SelectorKind.Tag, "Selector kind that determines where matching is applied.">]>;
+        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: 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>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: 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>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[] | undefined, "Optional list of matchers that will be applied.">]>;
+        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<SelectorKind.Variable, undefined>, import("valibot").DescriptionAction<SelectorKind.Variable, "Selector kind that determines where matching is applied.">]>;
+        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.String, undefined>, import("valibot").DescriptionAction<MatcherType.String, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: 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>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: 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>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[] | undefined, "Optional list of matchers that will be applied.">]>;
+        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+    }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+        callTarget?: number | "all" | "first" | "last" | undefined;
+        kind: SelectorKind.Callee;
+        match?: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[] | undefined;
+        name: string;
+        path?: string | undefined;
+    } | {
+        callTarget?: number | "all" | "first" | "last" | undefined;
+        kind: SelectorKind.Callee;
+        match?: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[] | undefined;
+        name?: string | undefined;
+        path: string;
+    } | {
+        kind: SelectorKind.Attribute;
+        match?: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[] | undefined;
+        name: string;
+    } | {
+        kind: SelectorKind.Tag;
+        match?: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[] | undefined;
+        name: string;
+    } | {
+        kind: SelectorKind.Variable;
+        match?: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[] | undefined;
+        name: string;
+    })[], "Flat list of selectors that should get linted.">]>, ({
+        kind: SelectorKind.Callee;
+        match: {
+            type: MatcherType.String;
+        }[];
+        name: string;
+    } | {
+        kind: SelectorKind.Callee;
+        match: {
+            type: MatcherType.ObjectKey;
+        }[];
+        name: string;
+    } | {
+        kind: SelectorKind.Callee;
+        match: {
+            path: string;
+            type: MatcherType.ObjectValue;
+        }[];
+        name: string;
+    } | {
+        kind: SelectorKind.Attribute;
+        name: string;
+        match?: never;
+    } | {
+        kind: SelectorKind.Attribute;
+        match: ({
+            type: MatcherType.String;
+        } | {
+            type: MatcherType.ObjectKey;
+        })[];
+        name: string;
+    } | {
+        kind: SelectorKind.Variable;
+        match: {
+            type: MatcherType.String;
+        }[];
+        name: string;
+    })[]>;
+}, undefined>;
+export type SelectorsOptions = InferOutput<typeof SELECTORS_OPTION_SCHEMA>;
+//# sourceMappingURL=selectors.d.ts.map

package/lib/options/schemas/selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../src/options/schemas/selectors.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAE7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAqH3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAK1B,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,eAAe,CAAC,CAAC;AAE3D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAG5B,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE7D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAElC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/lib/options/schemas/selectors.js

@@ -0,0 +1,69 @@
+import { array, description, literal, number, optional, pipe, strictObject, string, union } from "valibot";
+import { DEFAULT_SELECTORS } from "../default-options.js";
+import { MatcherType, SelectorKind } from "../../types/rule.js";
+const STRING_SELECTOR_MATCHER_SCHEMA = strictObject({
+    type: pipe(literal(MatcherType.String), description("Matcher type that will be applied."))
+});
+const OBJECT_KEY_SELECTOR_MATCHER_SCHEMA = strictObject({
+    path: optional(pipe(string(), description("Regular expression that filters the object key and matches the content for further processing in a group."))),
+    type: pipe(literal(MatcherType.ObjectKey), description("Matcher type that will be applied."))
+});
+const OBJECT_VALUE_SELECTOR_MATCHER_SCHEMA = strictObject({
+    path: optional(pipe(string(), description("Regular expression that filters the object value and matches the content for further processing in a group."))),
+    type: pipe(literal(MatcherType.ObjectValue), description("Matcher type that will be applied."))
+});
+const SELECTOR_MATCH_SCHEMA = pipe(optional(array(union([
+    STRING_SELECTOR_MATCHER_SCHEMA,
+    OBJECT_KEY_SELECTOR_MATCHER_SCHEMA,
+    OBJECT_VALUE_SELECTOR_MATCHER_SCHEMA
+]))), description("Optional list of matchers that will be applied."));
+const SELECTOR_NAME_SCHEMA = pipe(string(), description("Regular expression for names that should be linted."));
+const CALLEE_SELECTOR_PATH_SCHEMA = pipe(string(), description("Regular expression for callee paths that should be linted."));
+const CALLEE_SELECTOR_CALL_TARGET_SCHEMA = pipe(optional(union([
+    literal("all"),
+    literal("first"),
+    literal("last"),
+    number()
+])), description("Optional call target for curried callees: index, first, last, or all."));
+const ATTRIBUTE_SELECTOR_SCHEMA = strictObject({
+    kind: pipe(literal(SelectorKind.Attribute), description("Selector kind that determines where matching is applied.")),
+    match: SELECTOR_MATCH_SCHEMA,
+    name: SELECTOR_NAME_SCHEMA
+});
+const CALLEE_SELECTOR_SCHEMA = union([
+    strictObject({
+        callTarget: CALLEE_SELECTOR_CALL_TARGET_SCHEMA,
+        kind: pipe(literal(SelectorKind.Callee), description("Selector kind that determines where matching is applied.")),
+        match: SELECTOR_MATCH_SCHEMA,
+        name: SELECTOR_NAME_SCHEMA,
+        path: optional(CALLEE_SELECTOR_PATH_SCHEMA)
+    }),
+    strictObject({
+        callTarget: CALLEE_SELECTOR_CALL_TARGET_SCHEMA,
+        kind: pipe(literal(SelectorKind.Callee), description("Selector kind that determines where matching is applied.")),
+        match: SELECTOR_MATCH_SCHEMA,
+        name: optional(SELECTOR_NAME_SCHEMA),
+        path: CALLEE_SELECTOR_PATH_SCHEMA
+    })
+]);
+const TAG_SELECTOR_SCHEMA = strictObject({
+    kind: pipe(literal(SelectorKind.Tag), description("Selector kind that determines where matching is applied.")),
+    match: SELECTOR_MATCH_SCHEMA,
+    name: SELECTOR_NAME_SCHEMA
+});
+const VARIABLE_SELECTOR_SCHEMA = strictObject({
+    kind: pipe(literal(SelectorKind.Variable), description("Selector kind that determines where matching is applied.")),
+    match: SELECTOR_MATCH_SCHEMA,
+    name: SELECTOR_NAME_SCHEMA
+});
+export const SELECTOR_SCHEMA = union([
+    ATTRIBUTE_SELECTOR_SCHEMA,
+    CALLEE_SELECTOR_SCHEMA,
+    TAG_SELECTOR_SCHEMA,
+    VARIABLE_SELECTOR_SCHEMA
+]);
+export const SELECTORS_SCHEMA = pipe(array(SELECTOR_SCHEMA), description("Flat list of selectors that should get linted."));
+export const SELECTORS_OPTION_SCHEMA = strictObject({
+    selectors: optional(SELECTORS_SCHEMA, DEFAULT_SELECTORS)
+});
+//# sourceMappingURL=selectors.js.map

package/lib/options/schemas/selectors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.js","sourceRoot":"","sources":["../../../src/options/schemas/selectors.ts"],"names":[],"mappings":"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"}

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

@@ -94,7 +94,7 @@ export declare const TAGS_OPTIONS_SCHEMA: import("valibot").StrictObjectSchema<{
     } | {
         match: import("../../types/rule.js").MatcherType.ObjectValue;
         pathPattern?: string | undefined;
-    })[]])[], "List of template literal tags that should get linted.">]>, never[]>;
+    })[]])[], "List of template literal tags that should get linted.">]>, undefined>;
 }, undefined>;
 export type TagsOptions = InferOutput<typeof TAGS_OPTIONS_SCHEMA>;
 export {};