eslint-plugin-better-tailwindcss 4.3.2 → 4.4.0

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

@@ -10,6 +10,25 @@ export declare const SELECTOR_SCHEMA: import("valibot").UnionSchema<[import("val
     }, 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
     }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
         type: MatcherType.String;
     } | {
@@ -18,6 +37,17 @@ export declare const SELECTOR_SCHEMA: import("valibot").UnionSchema<[import("val
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | 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<{
@@ -31,6 +61,25 @@ export declare const SELECTOR_SCHEMA: import("valibot").UnionSchema<[import("val
     }, 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
     }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
         type: MatcherType.String;
     } | {
@@ -39,9 +88,22 @@ export declare const SELECTOR_SCHEMA: import("valibot").UnionSchema<[import("val
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | 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>;
+    readonly targetArgument: 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 argument target for call arguments: index, first, last, or all.">]>;
+    readonly targetCall: 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.">]>;
 }, 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.">]>;
@@ -53,6 +115,25 @@ export declare const SELECTOR_SCHEMA: import("valibot").UnionSchema<[import("val
     }, 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
     }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
         type: MatcherType.String;
     } | {
@@ -61,10 +142,23 @@ export declare const SELECTOR_SCHEMA: import("valibot").UnionSchema<[import("val
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | 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 targetArgument: 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 argument target for call arguments: index, first, last, or all.">]>;
+    readonly targetCall: 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.">]>;
+}, undefined>], undefined>, import("valibot").UnionSchema<[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.">]>;
@@ -74,6 +168,25 @@ export declare const SELECTOR_SCHEMA: import("valibot").UnionSchema<[import("val
     }, 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
     }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
         type: MatcherType.String;
     } | {
@@ -82,9 +195,72 @@ export declare const SELECTOR_SCHEMA: import("valibot").UnionSchema<[import("val
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | 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 tag 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "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;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
+    })[] | 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 tag paths that should be linted.">]>;
+}, undefined>], 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.">]>;
@@ -94,6 +270,25 @@ export declare const SELECTOR_SCHEMA: import("valibot").UnionSchema<[import("val
     }, 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
     }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
         type: MatcherType.String;
     } | {
@@ -102,6 +297,17 @@ export declare const SELECTOR_SCHEMA: import("valibot").UnionSchema<[import("val
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | 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>;
@@ -116,6 +322,25 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     }, 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
     }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
         type: MatcherType.String;
     } | {
@@ -124,6 +349,17 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | 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<{
@@ -137,6 +373,25 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     }, 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
     }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
         type: MatcherType.String;
     } | {
@@ -145,9 +400,22 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | 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>;
+    readonly targetArgument: 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 argument target for call arguments: index, first, last, or all.">]>;
+    readonly targetCall: 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.">]>;
 }, 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.">]>;
@@ -159,6 +427,25 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     }, 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
     }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
         type: MatcherType.String;
     } | {
@@ -167,10 +454,23 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | 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 targetArgument: 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 argument target for call arguments: index, first, last, or all.">]>;
+    readonly targetCall: 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.">]>;
+}, undefined>], undefined>, import("valibot").UnionSchema<[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.">]>;
@@ -180,6 +480,25 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     }, 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
     }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
         type: MatcherType.String;
     } | {
@@ -188,9 +507,72 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | 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 tag 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "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;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
+    })[] | 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 tag paths that should be linted.">]>;
+}, undefined>], 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.">]>;
@@ -200,6 +582,25 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     }, 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>, import("valibot").StrictObjectSchema<{
+        readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+        readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
     }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
         type: MatcherType.String;
     } | {
@@ -208,6 +609,17 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | 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<({
@@ -221,9 +633,22 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | undefined;
     name: string;
     path?: string | undefined;
+    targetArgument?: number | "all" | "first" | "last" | undefined;
+    targetCall?: number | "all" | "first" | "last" | undefined;
 } | {
     callTarget?: number | "all" | "first" | "last" | undefined;
     kind: SelectorKind.Callee;
@@ -235,11 +660,24 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | undefined;
     name?: string | undefined;
     path: string;
+    targetArgument?: number | "all" | "first" | "last" | undefined;
+    targetCall?: number | "all" | "first" | "last" | undefined;
 } | {
-    kind: SelectorKind.Attribute;
+    kind: SelectorKind.Tag;
     match?: ({
         type: MatcherType.String;
     } | {
@@ -248,8 +686,20 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | undefined;
     name: string;
+    path?: string | undefined;
 } | {
     kind: SelectorKind.Tag;
     match?: ({
@@ -260,6 +710,41 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
+    })[] | 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;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | undefined;
     name: string;
 } | {
@@ -272,6 +757,17 @@ export declare const SELECTORS_SCHEMA: import("valibot").SchemaWithPipe<readonly
     } | {
         path?: string | undefined;
         type: MatcherType.ObjectValue;
+    } | {
+        match: ({
+            type: MatcherType.String;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectKey;
+        } | {
+            path?: string | undefined;
+            type: MatcherType.ObjectValue;
+        })[];
+        type: MatcherType.AnonymousFunctionReturn;
     })[] | undefined;
     name: string;
 })[], "Flat list of selectors that should get linted.">]>;
@@ -287,6 +783,25 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         }, 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>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
         }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
             type: MatcherType.String;
         } | {
@@ -295,6 +810,17 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         } | {
             path?: string | undefined;
             type: MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
         })[] | 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<{
@@ -308,6 +834,25 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         }, 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>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
         }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
             type: MatcherType.String;
         } | {
@@ -316,9 +861,22 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         } | {
             path?: string | undefined;
             type: MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
         })[] | 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>;
+        readonly targetArgument: 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 argument target for call arguments: index, first, last, or all.">]>;
+        readonly targetCall: 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.">]>;
     }, 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.">]>;
@@ -330,6 +888,25 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         }, 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>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
         }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
             type: MatcherType.String;
         } | {
@@ -338,10 +915,23 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         } | {
             path?: string | undefined;
             type: MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
         })[] | 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 targetArgument: 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 argument target for call arguments: index, first, last, or all.">]>;
+        readonly targetCall: 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.">]>;
+    }, undefined>], undefined>, import("valibot").UnionSchema<[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.">]>;
@@ -351,6 +941,25 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         }, 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>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
         }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
             type: MatcherType.String;
         } | {
@@ -359,9 +968,72 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         } | {
             path?: string | undefined;
             type: MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
         })[] | 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 tag 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>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "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;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
+        })[] | 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 tag paths that should be linted.">]>;
+    }, undefined>], 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.">]>;
@@ -371,6 +1043,25 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         }, 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>, import("valibot").StrictObjectSchema<{
+            readonly match: import("valibot").SchemaWithPipe<readonly [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>, import("valibot").DescriptionAction<({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[], "List of nested matchers that target the return value of anonymous functions.">]>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<MatcherType.AnonymousFunctionReturn, undefined>, import("valibot").DescriptionAction<MatcherType.AnonymousFunctionReturn, "Matcher type that will be applied.">]>;
         }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
             type: MatcherType.String;
         } | {
@@ -379,6 +1070,17 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         } | {
             path?: string | undefined;
             type: MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
         })[] | 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<({
@@ -392,9 +1094,22 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         } | {
             path?: string | undefined;
             type: MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
         })[] | undefined;
         name: string;
         path?: string | undefined;
+        targetArgument?: number | "all" | "first" | "last" | undefined;
+        targetCall?: number | "all" | "first" | "last" | undefined;
     } | {
         callTarget?: number | "all" | "first" | "last" | undefined;
         kind: SelectorKind.Callee;
@@ -406,11 +1121,24 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         } | {
             path?: string | undefined;
             type: MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
         })[] | undefined;
         name?: string | undefined;
         path: string;
+        targetArgument?: number | "all" | "first" | "last" | undefined;
+        targetCall?: number | "all" | "first" | "last" | undefined;
     } | {
-        kind: SelectorKind.Attribute;
+        kind: SelectorKind.Tag;
         match?: ({
             type: MatcherType.String;
         } | {
@@ -419,8 +1147,20 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         } | {
             path?: string | undefined;
             type: MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
         })[] | undefined;
         name: string;
+        path?: string | undefined;
     } | {
         kind: SelectorKind.Tag;
         match?: ({
@@ -431,6 +1171,41 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         } | {
             path?: string | undefined;
             type: MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
+        })[] | 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;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
         })[] | undefined;
         name: string;
     } | {
@@ -443,6 +1218,17 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
         } | {
             path?: string | undefined;
             type: MatcherType.ObjectValue;
+        } | {
+            match: ({
+                type: MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: MatcherType.ObjectValue;
+            })[];
+            type: MatcherType.AnonymousFunctionReturn;
         })[] | undefined;
         name: string;
     })[], "Flat list of selectors that should get linted.">]>, ({
@@ -464,6 +1250,21 @@ export declare const SELECTORS_OPTION_SCHEMA: import("valibot").StrictObjectSche
             type: MatcherType.ObjectValue;
         }[];
         name: string;
+    } | {
+        kind: SelectorKind.Tag;
+        path: string;
+    } | {
+        kind: SelectorKind.Callee;
+        match: ({
+            type: MatcherType.String;
+            match?: never;
+        } | {
+            match: {
+                type: MatcherType.String;
+            }[];
+            type: MatcherType.AnonymousFunctionReturn;
+        })[];
+        path: string;
     } | {
         kind: SelectorKind.Attribute;
         name: string;