oxlint-plugin-arch 0.13.0 → 0.13.2

package/dist/preset/preset.utils.d.ts

@@ -11,6 +11,7 @@ export declare function presetSeverity(rules: PresetTypes.PresetRules, level: Pr
 export declare function presetPackageName(root: string, directory: string): string | undefined;
 export declare function presetIntersect(glob: string, scope: string): string[];
 export declare function presetGlobEscape(path: string): string;
+export declare function presetFileOverlaps(root: string, build: (pattern: string, folder: PresetTypes.PresetFolder) => PresetTypes.PresetFileKey, keys: PresetTypes.PresetFileKey[]): PresetTypes.PresetFileKey[];
 export declare function presetAliases(root: string, aliases: Record<string, string> | undefined): Record<string, string>;
 export declare function presetRuntime(project: PresetTypes.PresetProject, settings: Required<PresetTypes.PresetFrameworkOptions>, framework: PresetTypes.PresetFramework, rule: string): OxlintOverride[];
 export declare function presetManifest(root: string, directory: string): PresetTypes.PresetManifest;
@@ -20,3 +21,4 @@ export declare function presetIsFile(path: string): boolean;
 export declare function presetSource(root: string, directory: string, configured?: string): string;
 export declare function presetFilled(conventions: PresetTypes.PresetFolders, exists: (path: string) => boolean): PresetTypes.PresetFolders;
 export declare function presetMerge(base: boolean | PresetTypes.PresetFolder | undefined, top: boolean | PresetTypes.PresetFolder): boolean | PresetTypes.PresetFolder;
+export declare function presetNames(inherited: string[], entries: unknown, option: string): string[];

package/dist/rules/code/code-inside.d.ts

@@ -0,0 +1 @@
+export declare const codeInside: import("@oxlint/plugins").Rule;

package/dist/rules/effect/effect-layer-keys.d.ts

@@ -0,0 +1 @@
+export declare const effectLayerKeys: import("@oxlint/plugins").Rule;

package/dist/rules/effect/effect-service-params.d.ts

@@ -0,0 +1 @@
+export declare const effectServiceParams: import("@oxlint/plugins").Rule;

package/dist/rules/effect/effect-yield-name.d.ts

@@ -0,0 +1 @@
+export declare const effectYieldName: import("@oxlint/plugins").Rule;

package/dist/rules/effect/effect-yields-first.d.ts

@@ -0,0 +1 @@
+export declare const effectYieldsFirst: import("@oxlint/plugins").Rule;

package/dist/rules/files/files-siblings.d.ts

@@ -0,0 +1 @@
+export declare const filesSiblings: import("@oxlint/plugins").Rule;

package/dist/rules/files/files-top-level.d.ts

@@ -0,0 +1 @@
+export declare const filesTopLevel: import("@oxlint/plugins").Rule;

package/dist/rules/layout/layout-type-arguments.d.ts

@@ -0,0 +1 @@
+export declare const layoutTypeArguments: import("@oxlint/plugins").Rule;

package/dist/rules/naming/naming-imports.d.ts

@@ -0,0 +1 @@
+export declare const namingImports: import("@oxlint/plugins").Rule;

package/dist/rules/naming/naming-keys.d.ts

@@ -0,0 +1 @@
+export declare const namingKeys: import("@oxlint/plugins").Rule;

package/dist/rules/naming/naming-labels.d.ts

@@ -0,0 +1 @@
+export declare const namingLabels: import("@oxlint/plugins").Rule;

package/dist/rules/naming/naming-pairs.d.ts

@@ -0,0 +1 @@
+export declare const namingPairs: import("@oxlint/plugins").Rule;

package/dist/types/boundaries.types.d.ts

@@ -6,13 +6,27 @@ export interface BoundariesOptions {
     roles?: string[];
     surfaces?: string[];
     services?: string[];
-    portable?: boolean;
+    portable?: boolean | string;
+    conventions?: BoundariesConventions;
     backendPackages: string[];
     appPackages: string[];
     aliases: Record<string, string>;
     entrypoints: string[];
     uiPackages?: string[];
 }
+export interface BoundariesConventions {
+    services?: string;
+    registry?: string;
+    types?: string;
+    lib?: string;
+    contracts?: string[];
+    implementations?: string[];
+    implementationFolders?: string[];
+    operations?: string[];
+    operationFolders?: string[];
+    domainFiles?: string[];
+    clients?: string[];
+}
 export interface BoundariesImport {
     options: BoundariesOptions;
     file: string;
@@ -25,7 +39,18 @@ export interface BoundariesImport {
     web?: string;
     backendImport: boolean;
 }
+export interface BoundariesRuntimeConventions {
+    server?: string[];
+    rsc?: string[];
+    actions?: string[];
+    client?: string[];
+    clientOnly?: string[];
+    hooks?: string[];
+    shared?: string[];
+    lib?: string;
+}
 export interface BoundariesNextOptions extends Partial<Pick<BoundariesOptions, 'web' | 'backend' | 'aliases' | 'backendPackages'>> {
+    conventions?: BoundariesRuntimeConventions;
     server?: string[];
     client?: string[];
     dynamic?: string[];
@@ -74,7 +99,14 @@ export interface BoundariesRpcDatabaseOptions {
     message?: string;
     methods?: string[];
 }
+export interface BoundariesDenyOnly {
+    imports?: string | string[];
+    calls?: string | string[];
+    in: string | string[];
+    message?: string;
+}
 export interface BoundariesDenyOptions {
     imports?: Record<string, string>;
     calls?: Record<string, string>;
+    only?: BoundariesDenyOnly[];
 }

package/dist/types/code.types.d.ts

@@ -69,6 +69,7 @@ export interface CodeTrivialFunctionsGuardState {
 export interface CodeInlineOptions {
     max?: number;
     nesting?: number;
+    callbacks?: boolean;
     allow?: OptionsPattern;
     keep?: OptionsPattern;
     services?: string[];
@@ -88,3 +89,14 @@ export interface CodeTracedOptions {
     skip?: OptionsPattern;
     message?: string;
 }
+export interface CodeInsideEntry {
+    callee: OptionsPattern;
+    calls: Record<string, string>;
+}
+export interface CodeInsideOptions {
+    inside: CodeInsideEntry[];
+}
+export interface CodeInsideCompiled {
+    callees: RegExp[];
+    calls: [RegExp, string][];
+}

package/dist/types/comments.types.d.ts

@@ -4,6 +4,7 @@ export interface CommentsOptions {
     allow?: string[];
     jsdoc?: boolean;
     members?: 'off' | 'also' | 'only';
+    steps?: boolean;
 }
 export interface CommentsLines {
     starts: number[];

package/dist/types/dillon-anti-slop.types.d.ts

@@ -53,3 +53,9 @@ export interface DillonAntiSlopConstBinding {
     readonly declarator: ESTree.VariableDeclarator;
     readonly init: ESTree.Expression;
 }
+export interface DillonAntiSlopSymbolNamesOptions {
+    terms?: string[];
+}
+export interface DillonAntiSlopSafetyCommentOptions {
+    comment?: string;
+}

package/dist/types/effect.types.d.ts

@@ -22,6 +22,7 @@ export interface EffectLayerFileOptions {
     layer?: string;
     make?: string;
     prefix?: string;
+    suffix?: string;
     builders?: string[];
     layers?: OptionsPattern;
     services?: OptionsPattern;
@@ -39,8 +40,28 @@ export interface EffectSchemaFirstDerived {
 export interface EffectSchemaFirstOptions {
     member?: string;
     keep?: OptionsPattern;
+    allow?: OptionsPattern;
     runtime?: string[];
     rows?: EffectSchemaFirstRows;
     order?: (EffectSchemaFirstSection | EffectSchemaFirstSection[])[];
     derived?: EffectSchemaFirstDerived;
 }
+export interface EffectYieldNameOptions {
+    names?: Record<string, string | string[]>;
+    allow?: OptionsPattern;
+}
+export interface EffectLayerKeysOptions {
+    service: string;
+    callees?: string[];
+    declaration?: string;
+}
+export interface EffectLayerKeysFrame {
+    open: string;
+    key?: string;
+    members: number;
+}
+export interface EffectServiceParamsOptions {
+    name?: OptionsPattern;
+    allow?: OptionsPattern;
+    declaration?: string;
+}

package/dist/types/files.types.d.ts

@@ -1,4 +1,4 @@
-import type { NamingExportsStem, NamingStemMode } from './naming.types.ts';
+import type { NamingCaptureOptions } from './naming.types.ts';
 import type { OptionsPattern } from './options.types.ts';
 import type { ESTree } from '@oxlint/plugins';
 export interface FilesComponentsOnlyOptions {
@@ -24,8 +24,7 @@ export interface FilesDomainConstantsOptions {
     roles?: string[];
     file?: string;
 }
-export interface FilesExportsOptions extends Pick<NamingExportsStem, 'roles' | 'separators' | 'singularize'> {
-    stem?: NamingStemMode | 'folder';
+export interface FilesExportsOptions extends NamingCaptureOptions {
     names?: string[];
     patterns?: string[];
     types?: boolean;
@@ -89,3 +88,34 @@ export interface FilesExternalsManifest {
     dependencies?: Record<string, string>;
     optionalDependencies?: Record<string, string>;
 }
+export type FilesTopLevelKind = 'import' | 'export' | 'reexport' | 'default' | 'type' | 'interface' | 'enum' | 'class' | 'namespace' | 'const' | 'let' | 'var' | 'function' | 'function-const' | 'call' | 'statement';
+export interface FilesTopLevelEntry {
+    kind: FilesTopLevelKind | FilesTopLevelKind[];
+    names?: OptionsPattern;
+    from?: OptionsPattern;
+    exported?: boolean;
+    message?: string;
+}
+export interface FilesTopLevelOptions extends NamingCaptureOptions {
+    allow?: (string | FilesTopLevelEntry)[];
+    deny?: (string | FilesTopLevelEntry)[];
+    message?: string;
+}
+export interface FilesTopLevelItem {
+    kind: FilesTopLevelKind;
+    name: string;
+    from: string;
+    exported: boolean;
+    node: ESTree.Node;
+}
+export interface FilesTopLevelMatcher {
+    kinds: FilesTopLevelKind[];
+    names: RegExp[] | null;
+    from: RegExp[] | null;
+    exported?: boolean;
+    message: string;
+}
+export interface FilesSiblingsOptions {
+    require: OptionsPattern;
+    message?: string;
+}

package/dist/types/layout.types.d.ts

@@ -9,6 +9,10 @@ export interface LayoutCallArgumentsOptions {
     min?: number;
     indent?: SourceIndent;
     split?: boolean;
+    pipe?: {
+        min: number;
+        methods?: string[];
+    };
     hug?: {
         max: number;
     };
@@ -55,6 +59,10 @@ export interface LayoutObjectOptions {
     min?: number;
     scope?: LayoutObjectScope;
     indent?: SourceIndent;
+    params?: boolean;
+    nested?: boolean;
+    siblings?: boolean;
+    inner?: number;
     join?: {
         max: number;
         keep?: string[];
@@ -66,6 +74,13 @@ export interface LayoutPaddingOptions {
     multiline?: boolean;
 }
 export type LayoutPaddingKind = 'variable' | 'block' | 'control' | 'return' | 'other';
+export interface LayoutPipeOptions {
+    methods?: string[];
+}
+export interface LayoutTypeArgumentsOptions {
+    min?: number;
+    indent?: SourceIndent;
+}
 export interface LayoutTernaryOptions {
     max?: number;
     indent?: SourceIndent;
@@ -79,6 +94,7 @@ export interface LayoutItemsOptions {
 }
 export interface LayoutCallDepthOptions {
     max?: number;
+    callbacks?: boolean;
 }
 export interface LayoutArrowBodyOptions {
     max?: number;

package/dist/types/naming.types.d.ts

@@ -1,12 +1,19 @@
 import type { DeclarationsKind } from './declarations.types.ts';
 import type { OptionsPattern } from './options.types.ts';
 export type NamingStemMode = 'before-first-dot' | 'full-basename';
+export type NamingPrefixSource = 'file' | 'folder' | 'parent';
 export interface NamingExportsStem {
     stem?: NamingStemMode;
     roles?: string[];
     separators?: string[];
     normalize?: 'remove-separators' | 'none';
     singularize?: 'none' | 'trailing-s';
+    prefix?: NamingPrefixSource[];
+}
+export interface NamingCaptureOptions extends Pick<NamingExportsStem, 'roles' | 'separators' | 'singularize'> {
+    stem?: NamingStemMode | 'folder';
+    file?: string;
+    placeholder?: string;
 }
 export interface NamingDeclarationsOptions extends NamingExportsStem {
     kinds?: DeclarationsKind[];
@@ -31,17 +38,19 @@ export interface NamingExportsPatternOptions extends NamingExportsBase {
 export interface NamingExportsTemplateOptions extends NamingExportsBase {
     mode: 'template';
     file: string;
-    export: string;
+    export: string | string[];
     match?: 'all' | 'some';
     placeholder?: string;
     camelCase?: boolean;
 }
 export type NamingExportsOptions = NamingExportsPrefixOptions | NamingExportsPatternOptions | NamingExportsTemplateOptions;
 export interface NamingFileOptions {
-    pattern: OptionsPattern;
+    pattern?: OptionsPattern;
     message: string;
     flags?: string;
     unique?: string;
+    template?: OptionsPattern;
+    placeholder?: string;
 }
 export interface NamingFolderOptions {
     singularize?: 'none' | 'trailing-s';
@@ -49,4 +58,67 @@ export interface NamingFolderOptions {
     prefixes?: string[];
     after?: string;
 }
+export interface NamingTypesOptions {
+    pattern?: OptionsPattern;
+    message?: string;
+}
+export interface NamingDeclarationsCheck {
+    kinds: Set<DeclarationsKind> | null;
+    allowed: RegExp[];
+    expected: RegExp[];
+    prefixes: string[];
+    label: string;
+    normalize: NamingExportsStem['normalize'];
+}
+export interface NamingImportsEntry {
+    source: string;
+    name: string | string[];
+    namespace?: boolean;
+    placeholder?: string;
+}
+export interface NamingImportsOptions {
+    imports: NamingImportsEntry[];
+}
+export interface NamingImportsCompiled {
+    pattern: RegExp;
+    names: string[];
+    namespace: boolean;
+}
+export interface NamingLabelsEntry {
+    callee: OptionsPattern;
+    property?: string;
+    name?: OptionsPattern;
+    pattern?: OptionsPattern;
+    drop?: OptionsPattern;
+    loose?: boolean;
+    within?: OptionsPattern;
+}
+export interface NamingLabelsOptions {
+    labels: NamingLabelsEntry[];
+}
+export interface NamingLabelsCompiled {
+    callees: RegExp[];
+    entry: NamingLabelsEntry;
+    drop: RegExp[];
+    patterns: string[];
+    within: RegExp[];
+}
+export interface NamingKeysOptions {
+    callees?: string[];
+    exports?: OptionsPattern;
+    name?: OptionsPattern;
+    keys?: OptionsPattern;
+    inline?: boolean;
+    delegate?: boolean;
+    allow?: OptionsPattern;
+    singularize?: 'none' | 'trailing-s';
+}
+export interface NamingPairsEntry {
+    methods: [string, string];
+    strip?: OptionsPattern;
+    allow?: OptionsPattern;
+}
+export interface NamingPairsOptions {
+    pairs: NamingPairsEntry[];
+}
 export {};

package/dist/types/preset.types.d.ts

@@ -1,3 +1,5 @@
+import type { BoundariesDenyOnly } from './boundaries.types.ts';
+import type { FilesTopLevelEntry, FilesTopLevelOptions } from './files.types.ts';
 import type { OptionsPattern } from './options.types.ts';
 import type * as EffectTsgo from '@effect/tsgo/oxlint-presets';
 import type * as EffectLinteffect from '@opsydyn/oxlint-effect';
@@ -38,6 +40,7 @@ export interface PresetNamingOptions {
     exports?: boolean | string;
     folders?: boolean;
     unique?: string;
+    imports?: Record<string, string | string[] | false>;
 }
 export interface PresetCommentsOptions {
     directives?: boolean;
@@ -110,6 +113,15 @@ export interface PresetBackendOptions {
 export interface PresetDenyOptions {
     imports?: Record<string, string | false>;
     calls?: Record<string, string | false>;
+    only?: PresetDenyOnly[];
+}
+export interface PresetDenyOnly extends BoundariesDenyOnly {
+    each?: string;
+}
+export type PresetSet = string[] | Record<string, string>;
+export type PresetSetValue = string | number | boolean | null | undefined | PresetSetValue[] | PresetSetObject;
+export interface PresetSetObject {
+    [key: string]: PresetSetValue;
 }
 export interface PresetOrpcOptions {
     public?: string[];
@@ -121,6 +133,12 @@ export interface PresetEffectOptions {
     exports?: OptionsPattern;
     skip?: OptionsPattern;
     entries?: string[];
+    files?: string[];
+    strict?: boolean;
+}
+export interface PresetEffectContract {
+    name: string;
+    source: string;
 }
 export interface PresetEffectStyle {
     rules: PresetRules;
@@ -155,6 +173,7 @@ export interface PresetGroups {
     effect?: PresetSwitch | PresetEffectOptions;
     console?: boolean;
     deny?: PresetSwitch | PresetDenyOptions;
+    top?: PresetSwitch | FilesTopLevelOptions | (string | FilesTopLevelEntry)[];
     externals?: PresetSwitch;
 }
 export type PresetGroupName = keyof PresetGroups;
@@ -170,6 +189,7 @@ export interface PresetConfig {
     root?: string;
     folders?: PresetFolders;
     detect?: boolean;
+    sets?: Record<string, PresetSet>;
 }
 export type PresetRecipe = PresetGroups & Partial<Record<symbol, string>>;
 export type PresetRules = NonNullable<OxlintConfig['rules']>;
@@ -204,11 +224,17 @@ export interface PresetResolvedGroups {
         code: boolean;
         width: number;
         entries: string[];
+        files: string[];
+        strict: boolean;
     };
     console: PresetEmptyOptions;
     deny: {
         imports: Record<string, string | false>;
         calls: Record<string, string | false>;
+        only: BoundariesDenyOnly[];
+    };
+    top: {
+        [K in keyof Required<FilesTopLevelOptions>]: FilesTopLevelOptions[K] | undefined;
     };
     externals: PresetEmptyOptions;
 }

package/dist/types/react.types.d.ts

@@ -17,3 +17,16 @@ export interface ReactPropsTarget {
     fn: AstFunction;
     typeArgument?: ESTree.TSType;
 }
+export interface ReactDynamicClassesOptions {
+    attributes?: string[];
+    message?: string;
+}
+export interface ReactEmptyEffectOptions {
+    hooks?: string[];
+    message?: string;
+}
+export interface ReactMemoOptions {
+    names?: string[];
+    sources?: string[];
+    message?: string;
+}

package/dist/types/types.types.d.ts

@@ -30,3 +30,7 @@ export interface TypesDuplicateOptions {
     structs?: string[];
     min?: number;
 }
+export interface TypesLocalAliasOptions {
+    allow?: OptionsPattern;
+    message?: string;
+}

package/dist/utils/ast.utils.d.ts

@@ -20,6 +20,5 @@ export declare function astSelectorRule(selector: string, message: string): impo
 export declare function astIsOneLine(node: ESTree.Node): boolean;
 export declare function astIsInlineFunction(node: ESTree.Node): node is AstFunction;
 export declare function astIsCall(node: ESTree.Node): node is AstCall;
-export declare function astIsPipe(node: AstCall): boolean;
 export declare function astSome(value: unknown, test: (node: ESTree.Node) => boolean, enter?: (node: ESTree.Node) => boolean): boolean;
-export declare function astCallDepth(value: unknown): number;
+export declare function astCallDepth(value: unknown, callbacks?: boolean): number;

package/dist/utils/boundaries.utils.d.ts

@@ -1,5 +1,10 @@
-import type { BoundariesOptions } from '../types/boundaries.types.ts';
+import type { BoundariesOptions, BoundariesRuntimeConventions } from '../types/boundaries.types.ts';
 import type * as PluginsTypes from '@oxlint/plugins';
+export declare function boundariesConventionsFor(options: {
+    conventions?: BoundariesRuntimeConventions;
+}): Required<BoundariesRuntimeConventions>;
+export declare function boundariesHasSuffix(suffixes: readonly string[], path: string, optionalExtension?: boolean): boolean;
+export declare function boundariesIsClientOnly(conventions: Required<BoundariesRuntimeConventions>, target: string): boolean;
 export declare const boundariesServerGlobals: string[];
 export declare const boundariesBrowserGlobals: string[];
 export declare const boundariesRuntimeProperties: {
@@ -63,6 +68,65 @@ export declare const boundariesRuntimeProperties: {
             type: string;
         };
     };
+    conventions: {
+        type: string;
+        additionalProperties: boolean;
+        properties: {
+            server: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            rsc: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            actions: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            client: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            clientOnly: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            hooks: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            shared: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            lib: {
+                type: string;
+                minLength: number;
+            };
+        };
+    };
 };
 export declare const boundariesServerPackages: string[];
 export declare const boundariesRuntimeMessages: {
@@ -75,11 +139,15 @@ export declare function boundariesExportVisitors(check: (node: PluginsTypes.ESTr
 };
 export declare function boundariesLiteralSource(node: PluginsTypes.ESTree.ImportExpression): string | undefined;
 export declare function boundariesReport(context: PluginsTypes.Context, node: PluginsTypes.ESTree.Node, source: string, reason: string): void;
-export declare function boundariesImportExpression(context: PluginsTypes.Context, node: PluginsTypes.ESTree.ImportExpression, allowComputed: boolean, check: (source: string) => void): void;
-export declare function boundariesIsSharedFile(options: Pick<BoundariesOptions, 'web'>, file: string): boolean;
+export declare function boundariesRuntimeImportVisitors(context: PluginsTypes.Context, check: (node: PluginsTypes.ESTree.Node, source: string, typeOnly: boolean, reExport: boolean) => void, allowComputed: () => boolean): {
+    ExportNamedDeclaration(node: PluginsTypes.ESTree.ExportNamedDeclaration): void;
+    ExportAllDeclaration(node: PluginsTypes.ESTree.ExportAllDeclaration): void;
+    ImportExpression(node: PluginsTypes.ESTree.ImportExpression): void;
+};
+export declare function boundariesIsSharedFile(options: Pick<BoundariesOptions, 'web'>, conventions: Required<BoundariesRuntimeConventions>, file: string): boolean;
 export declare function boundariesDeclaredVariable(start: PluginsTypes.Scope | null, name: string): PluginsTypes.Variable | null;
 export declare function boundariesMatchesImport(prefixes: string[] | undefined, source: string): boolean;
 export declare function boundariesIsBackendImport(options: Pick<BoundariesOptions, 'backend' | 'backendPackages'>, target: string, source: string): boolean;
 export declare function boundariesIsServerPlatformImport(source: string, packages: readonly string[]): boolean;
 export declare function boundariesMemberName(node: PluginsTypes.ESTree.Node | null | undefined): string | null;
-export declare function boundariesResolveTarget(options: Pick<BoundariesOptions, 'web' | 'backend' | 'aliases'>, file: string, source: string): string;
+export declare function boundariesResolveTarget(options: Pick<BoundariesOptions, 'web' | 'backend' | 'aliases'>, file: string, source: string, services?: string): string;

package/dist/utils/naming.utils.d.ts

@@ -1,4 +1,4 @@
-import type { NamingExportsStem, NamingStemMode } from '../types/naming.types.ts';
+import type { NamingCaptureOptions, NamingExportsStem, NamingStemMode } from '../types/naming.types.ts';
 import type { OptionsSchemaProperties } from '../types/options.types.ts';
 export declare const namingStemModes: readonly NamingStemMode[];
 export declare const namingStemSchemaProperties: OptionsSchemaProperties;
@@ -8,4 +8,7 @@ export declare function namingCamelCase(value: string): string;
 export declare function namingNormalized(value: string, normalize: 'remove-separators' | 'none'): string;
 export declare function namingFileStem(basename: string, mode?: NamingStemMode, trailingRoles?: readonly string[], roleSeparators?: readonly string[]): string;
 export declare function namingFilePrefixesFor(filename: string, options: NamingExportsStem): string[];
+export declare function namingTemplatePattern(template: string, placeholder?: string): RegExp | null;
+export declare function namingCaptures(filename: string, options?: NamingCaptureOptions): Record<string, string> | null;
+export declare function namingExpand(template: string, captures: Record<string, string>, camelCase: boolean, escape?: (value: string) => string): string;
 export declare function namingHasFilePrefix(name: string, prefixes: readonly string[], normalize: NamingExportsStem['normalize']): boolean;

package/dist/utils/options.utils.d.ts

@@ -9,3 +9,5 @@ export declare function optionsPatternsTest(patterns: RegExp[], value: string):
 export declare function optionsGlob(pattern: string): RegExp;
 export declare function optionsPatternLabel(pattern: OptionsPattern | undefined): string;
 export declare function optionsAssertMockingApis(patterns: string[]): void;
+export declare function optionsEscape(value: string): string;
+export declare function optionsWildcards(names: OptionsPattern | undefined): RegExp[];