oxlint-plugin-arch 0.11.0 → 0.12.0

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

@@ -0,0 +1,55 @@
+import type { OptionsPattern } from './options.types.ts';
+import type { SourceIndent } from './source.types.ts';
+import type { ESTree } from '@oxlint/plugins';
+export interface LayoutEdit {
+    range: [number, number];
+    text: string;
+}
+export interface LayoutCallArgumentsOptions {
+    min?: number;
+    indent?: number;
+}
+export interface LayoutCallArrayOptions {
+    callees?: string[];
+    min?: number;
+    indent?: SourceIndent;
+}
+export interface LayoutChainGroup {
+    min: number;
+    methods?: string[];
+    only?: string[];
+    root?: OptionsPattern;
+}
+export interface LayoutChainOptions {
+    groups: LayoutChainGroup[];
+    indent?: SourceIndent;
+}
+export interface LayoutChainCompiledGroup {
+    min: number;
+    methods?: Set<string>;
+    only?: Set<string>;
+    rootPatterns: RegExp[];
+}
+export interface LayoutChainLink {
+    member: ESTree.MemberExpression;
+    methodName: string | undefined;
+}
+export interface LayoutJsxAttributesOptions {
+    min?: number;
+    indent?: SourceIndent;
+}
+export interface LayoutObjectOptions {
+    min?: number;
+    scope?: LayoutObjectScope;
+    indent?: SourceIndent;
+}
+export type LayoutObjectScope = 'call-args' | 'all';
+export interface LayoutPaddingOptions {
+    min?: number;
+    multiline?: boolean;
+}
+export type LayoutPaddingKind = 'variable' | 'block' | 'control' | 'return' | 'other';
+export interface LayoutTernaryOptions {
+    max?: number;
+    indent?: number;
+}

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

@@ -0,0 +1,52 @@
+import type { DeclarationsKind } from './declarations.types.ts';
+import type { OptionsPattern } from './options.types.ts';
+export type NamingStemMode = 'before-first-dot' | 'full-basename';
+export interface NamingExportsStem {
+    stem?: NamingStemMode;
+    roles?: string[];
+    separators?: string[];
+    normalize?: 'remove-separators' | 'none';
+    singularize?: 'none' | 'trailing-s';
+}
+export interface NamingDeclarationsOptions extends NamingExportsStem {
+    kinds?: DeclarationsKind[];
+    pattern?: OptionsPattern;
+    flags?: string;
+    allow?: OptionsPattern;
+}
+interface NamingExportsBase {
+    scope?: 'exports' | 'functions' | 'declarations';
+    types?: boolean;
+    services?: boolean;
+    allow?: OptionsPattern;
+}
+export interface NamingExportsPrefixOptions extends NamingExportsBase, NamingExportsStem {
+    mode?: 'prefix';
+}
+export interface NamingExportsPatternOptions extends NamingExportsBase {
+    mode: 'pattern';
+    pattern: OptionsPattern;
+    flags?: string;
+}
+export interface NamingExportsTemplateOptions extends NamingExportsBase {
+    mode: 'template';
+    file: string;
+    export: string;
+    match?: 'all' | 'some';
+    placeholder?: string;
+    camelCase?: boolean;
+}
+export type NamingExportsOptions = NamingExportsPrefixOptions | NamingExportsPatternOptions | NamingExportsTemplateOptions;
+export interface NamingFileOptions {
+    pattern: OptionsPattern;
+    message: string;
+    flags?: string;
+    unique?: string;
+}
+export interface NamingFolderOptions {
+    singularize?: 'none' | 'trailing-s';
+    separators?: string[];
+    prefixes?: string[];
+    after?: string;
+}
+export {};

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

@@ -0,0 +1,4 @@
+import type { RuleOptionsSchema } from '@oxlint/plugins';
+export type OptionsPattern = string | string[];
+export type OptionsSchema = Exclude<RuleOptionsSchema, false | unknown[]>;
+export type OptionsSchemaProperties = NonNullable<OptionsSchema['properties']>;

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

@@ -1,181 +1,289 @@
 import type { OxlintConfig, OxlintOverride } from 'oxlint';
-export type PresetPolicy = boolean | ((current: OxlintOverride[]) => OxlintOverride[]);
-export type PresetPolicyName = 'typePlacement' | 'typeSafety' | 'serviceStructure' | 'fileLayout' | 'naming' | 'comments' | 'formatting' | 'statementLayout' | 'imports' | 'react' | 'effects' | 'memoization' | 'routes' | 'forms' | 'schemas' | 'boundaries' | 'tests' | 'trivialFunctions' | 'mutableState' | 'backend' | 'tailwind' | 'shadcn' | 'rpcClientOwnership';
-export type PresetRole = 'web' | 'server' | 'runner' | 'scripts' | 'packages';
-export type PresetFolderLayout = 'flat' | 'domain';
-export type PresetFramework = 'tanstack-start' | 'next';
-export interface PresetArchitectureEntry {
-    role: PresetRole;
-    layout?: Record<string, PresetFolderLayout>;
-    /** Web roots only: selects the route and runtime-boundary policies. */
-    framework?: PresetFramework;
-    /** Web, server and runner roots only: the source folder inside the root; `src` when omitted, `.` for the root itself. */
-    sourceDir?: string;
-}
-export type PresetArchitecture = Record<string, PresetRole | PresetArchitectureEntry>;
-export interface PresetResolvedRoot {
-    role: PresetRole;
-    layout: Record<string, PresetFolderLayout>;
-    framework?: PresetFramework;
-    sourceDir?: string;
+export type PresetLevel = 'error' | 'warn';
+export type PresetSwitch = boolean | 'warn';
+export type PresetLayoutMode = 'flat' | 'domain';
+export type PresetOperations = 'flat' | 'folders';
+export interface PresetLayoutOptions {
+    services?: PresetLayoutMode | false;
+    hooks?: PresetLayoutMode | false;
+    components?: PresetLayoutMode | false;
+    suffixes?: string[];
+    strict?: boolean;
+    operations?: PresetOperations;
+    service?: string[];
 }
-export interface PresetFolderScope {
-    path: string;
-    folder: string;
-    mode: PresetFolderLayout;
+export interface PresetLimitsOptions {
+    lines?: number;
+    types?: number;
+    complexity?: number;
 }
-export interface PresetOptions {
-    root?: string;
-    /** Default framework for web roots that do not set their own; `tanstack-start` when omitted. */
-    framework?: PresetFramework;
-    architecture?: PresetArchitecture;
-    severity?: 'error' | 'warn';
-    /** Per-rule levels applied after `severity`, for rules the preset enables. */
-    ruleSeverities?: Record<string, 'error' | 'warn' | 'off'>;
-    formatting?: PresetFormattingOptions;
-    limits?: PresetLimitsOptions;
-    modules?: PresetModulesOptions;
-    imports?: PresetImportsOptions;
-    orpc?: PresetOrpcOptions;
-    sql?: PresetSqlOptions;
-    forms?: PresetFormsOptions;
-    react?: PresetReactOptions;
-    tests?: PresetTestsOptions;
-    policies?: PresetPolicyOptions;
-    ignorePatterns?: string[];
-    ruleExclusions?: Record<string, string[]>;
-    cliFiles?: string[];
-    tanstackStart?: PresetTanstackStartOptions;
-    next?: PresetNextOptions;
-    tailwind?: false | PresetTailwindOptions;
-    shadcn?: false | PresetShadcnOptions;
-}
-export interface PresetPolicyOptions extends Partial<Record<PresetPolicyName, PresetPolicy>> {
-}
-export interface PresetFormattingOptions {
-    semi?: 'always' | 'never';
+export interface PresetStyleOptions {
     quotes?: 'single' | 'double';
+    semicolons?: boolean;
+    multiline?: boolean;
+    padding?: boolean;
+    dashes?: boolean;
 }
-export interface PresetLimitsOptions {
-    maxFileLines?: number;
-    /** `max-lines` for `*.types.ts` files; defaults to 1000. */
-    maxTypeFileLines?: number;
-    maxFunctionComplexity?: number;
-}
-export interface PresetModulesOptions {
-    customFileRoles?: string[];
-    migrationFiles?: string[];
-    /** Type files allowed outside `types/`; they follow the backend `types/` contract. */
-    colocatedTypeFiles?: string[];
+export interface PresetBasicsOptions {
+    trivial?: boolean;
+    state?: boolean;
+    switch?: boolean;
+    negation?: boolean;
 }
-export interface PresetTestsOptions {
-    profile?: 'standard' | 'fixtures';
-    additionalTestFunctions?: string[];
-    additionalAssertionFunctions?: string[];
-    /** Test-double APIs banned in test files; `modules` (module mocking only) when omitted. */
-    mocking?: PresetTestMockingPreset | PresetTestMockingOptions;
-}
-export type PresetTestMockingPreset = 'modules' | 'strict';
-export interface PresetTestMockingApi {
-    api: string;
-    message?: string;
+export interface PresetNamingOptions {
+    files?: boolean | string;
+    exports?: boolean | string;
+    folders?: boolean;
+    unique?: string;
 }
-export interface PresetTestMockingException {
-    files: string[];
-    /** API patterns allowed in these files; `*` allows every API. */
-    apis: string[];
+export interface PresetCommentsOptions {
+    directives?: boolean;
 }
-export interface PresetTestMockingOptions {
-    preset?: PresetTestMockingPreset;
-    /** API patterns added to the preset list, such as `vi.*` or `jest.spyOn`. */
-    deny?: Array<string | PresetTestMockingApi>;
-    /** Per-file exceptions, added after the preset's own. */
-    allow?: PresetTestMockingException[];
+export interface PresetTypesOptions {
+    placement?: boolean;
+    safety?: boolean;
+    colocated?: string[];
 }
 export interface PresetImportsOptions {
-    backendEntryPoints?: string[];
+    sort?: boolean;
+    boundaries?: boolean;
     aliases?: Record<string, string>;
-    internalSortPatterns?: string[];
+    internal?: string[];
 }
-export interface PresetOrpcOptions {
-    publicProcedureFiles?: string[];
-    outputSchemaComposers?: string[];
-    clientOwnerFile?: string;
+export interface PresetMockingApi {
+    api: string;
+    message?: string;
 }
-export interface PresetSqlOptions {
-    likeSanitizers?: string[];
+export interface PresetMockingException {
+    files: string[];
+    apis: string[];
 }
-export interface PresetFormsOptions {
-    schemaResolver?: string;
+export type PresetMockingPreset = 'modules' | 'strict';
+export interface PresetMockingOptions {
+    preset?: PresetMockingPreset;
+    deny?: (string | PresetMockingApi)[];
+    allow?: PresetMockingException[];
+}
+export interface PresetTestsOptions {
+    assertions?: string[];
+    functions?: string[];
+    mocking?: PresetMockingPreset | PresetMockingOptions;
+    titles?: boolean;
+    fixtures?: boolean;
 }
 export interface PresetReactOptions {
+    a11y?: boolean;
+    effects?: boolean;
+    memo?: boolean;
+    props?: boolean;
+    perf?: boolean;
     compiler?: boolean;
-    componentProps?: boolean;
 }
-export interface PresetTanstackStartOptions {
-    additionalServerOnlyImports?: string[];
-    additionalClientOnlyImports?: string[];
-    computedImportAllowedFiles?: string[];
+export interface PresetFrameworkOptions {
+    server?: string[];
+    client?: string[];
+    dynamic?: string[];
 }
-export interface PresetNextOptions {
-    additionalServerOnlyImports?: string[];
-    additionalClientOnlyImports?: string[];
-    computedImportAllowedFiles?: string[];
+export interface PresetExpoOptions {
+    server?: string[];
 }
 export interface PresetTailwindOptions {
-    cssEntryPoint?: string;
-    cssEntryPointsByRoot?: Record<string, string>;
-    rootFontSize?: number;
+    css?: string;
+    rem?: number;
 }
 export interface PresetShadcnOptions {
-    /** The components.json `ui` alias: a workspace package name or a tsconfig `paths` alias. It also sets the UI kit files. */
     ui?: string;
-    /** Import sources treated as components, like the components.json `components` alias. */
     components?: string[];
 }
+export interface PresetRegistryOptions {
+    file?: string;
+    skip?: string[];
+    object?: string;
+}
+export interface PresetBackendOptions {
+    exports?: string[];
+    registry?: false | string | PresetRegistryOptions;
+    writes?: string[];
+}
+export interface PresetDenyOptions {
+    imports?: Record<string, string | false>;
+    calls?: Record<string, string | false>;
+}
+export interface PresetExternalsOptions {
+    packages?: string[];
+}
+export interface PresetOrpcOptions {
+    public?: string[];
+    composers?: string[];
+    client?: string;
+}
+export interface PresetFormsOptions {
+    resolver?: string;
+}
+export interface PresetSqlOptions {
+    sanitizers?: string[];
+}
+export interface PresetGroups {
+    layout?: PresetSwitch | PresetLayoutOptions;
+    limits?: PresetSwitch | PresetLimitsOptions;
+    style?: PresetSwitch | PresetStyleOptions;
+    basics?: PresetSwitch | PresetBasicsOptions;
+    naming?: PresetSwitch | PresetNamingOptions;
+    comments?: PresetSwitch | PresetCommentsOptions;
+    types?: PresetSwitch | PresetTypesOptions;
+    imports?: PresetSwitch | PresetImportsOptions;
+    tests?: PresetSwitch | PresetTestsOptions;
+    react?: PresetSwitch | PresetReactOptions;
+    tanstack?: PresetSwitch | PresetFrameworkOptions;
+    next?: PresetSwitch | PresetFrameworkOptions;
+    expo?: PresetSwitch | PresetExpoOptions;
+    tailwind?: PresetSwitch | PresetTailwindOptions;
+    shadcn?: PresetSwitch | PresetShadcnOptions;
+    kit?: boolean;
+    backend?: PresetSwitch | PresetBackendOptions;
+    orpc?: PresetSwitch | PresetOrpcOptions;
+    schemas?: PresetSwitch;
+    forms?: PresetSwitch | PresetFormsOptions;
+    sql?: PresetSwitch | PresetSqlOptions;
+    console?: boolean;
+    deny?: PresetSwitch | PresetDenyOptions;
+    externals?: PresetSwitch | PresetExternalsOptions;
+}
+export type PresetGroupName = keyof PresetGroups;
+export interface PresetFolder extends PresetGroups {
+    severity?: PresetLevel;
+    source?: string;
+    rules?: PresetRules;
+}
+export type PresetFolders = Record<string, boolean | PresetFolder>;
+export interface PresetConfig {
+    root?: string;
+    folders?: PresetFolders;
+    detect?: boolean;
+}
+export type PresetRecipe = PresetGroups;
 export type PresetRules = NonNullable<OxlintConfig['rules']>;
-export type PresetPolicies = Partial<Record<PresetPolicyName, OxlintOverride[]>>;
-export interface PresetManifest {
-    name?: string;
+export type PresetJsPlugins = NonNullable<OxlintConfig['jsPlugins']>;
+export type PresetSettings = NonNullable<OxlintConfig['settings']>;
+export interface PresetResolvedGroups {
+    layout: PresetLayoutOptions & Required<Pick<PresetLayoutOptions, 'suffixes' | 'strict' | 'operations' | 'service'>>;
+    limits: Required<PresetLimitsOptions>;
+    style: Required<PresetStyleOptions>;
+    basics: Required<PresetBasicsOptions>;
+    naming: Required<Omit<PresetNamingOptions, 'unique'>> & Pick<PresetNamingOptions, 'unique'>;
+    comments: Required<PresetCommentsOptions>;
+    types: Required<PresetTypesOptions>;
+    imports: Omit<Required<PresetImportsOptions>, 'internal'> & Pick<PresetImportsOptions, 'internal'>;
+    tests: Required<PresetTestsOptions>;
+    react: Required<Pick<PresetReactOptions, 'a11y' | 'effects' | 'props' | 'compiler'>> & Pick<PresetReactOptions, 'memo' | 'perf'>;
+    tanstack: Required<PresetFrameworkOptions>;
+    next: Required<PresetFrameworkOptions>;
+    expo: Required<PresetExpoOptions>;
+    tailwind: Pick<PresetTailwindOptions, 'css'> & {
+        rem: number;
+    };
+    shadcn: Required<PresetShadcnOptions>;
+    kit: PresetEmptyOptions;
+    backend: PresetBackendOptions & Required<Pick<PresetBackendOptions, 'writes'>>;
+    orpc: PresetOrpcOptions;
+    schemas: PresetEmptyOptions;
+    forms: Required<PresetFormsOptions>;
+    sql: Required<PresetSqlOptions>;
+    console: PresetEmptyOptions;
+    deny: {
+        imports: Record<string, string>;
+        calls: Record<string, string>;
+    };
+    externals: Required<PresetExternalsOptions>;
+}
+export interface PresetEmptyOptions {
+    empty?: never;
+}
+export type PresetGroupSettings<K extends PresetGroupName> = PresetResolvedGroups[K] & {
+    level: PresetLevel;
+};
+export type PresetEffective = {
+    [K in PresetGroupName]?: PresetGroupSettings<K> | null;
+};
+export type PresetGroupDefaults = {
+    [K in PresetGroupName]: PresetGroupSettings<K>;
+};
+export type PresetKind = 'web' | 'backend' | 'library' | 'console';
+export type PresetFramework = 'tanstack' | 'next' | 'expo';
+export type PresetKindGroup = PresetFramework | 'backend' | 'console';
+export interface PresetScope {
+    key: string;
+    parent: PresetScope | null;
+    depth: number;
+    folder: PresetFolder;
+    effective: PresetEffective;
+}
+export interface PresetUnit {
+    key: string;
+    scope: PresetScope;
+    kind: PresetKind;
+    framework?: PresetFramework;
+    source: string;
+    layout: Record<string, PresetLayoutMode>;
+}
+export interface PresetLayoutScope {
+    path: string;
+    folder: string;
+    mode: PresetLayoutMode;
+}
+export interface PresetRuntimeOptions {
+    web: string[];
+    backend: string[];
+    aliases: Record<string, string>;
+    backendPackages: string[];
+    server: string[];
+    client: string[];
+    dynamic: string[];
+    rpc?: string[];
 }
 export interface PresetImportRestriction {
     group: string[];
     message: string;
 }
-export interface PresetContext {
-    options: PresetOptions;
-    architecture: Record<string, PresetResolvedRoot>;
-    folders: PresetFolderScope[];
+export interface PresetManifest {
+    name?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    workspaces?: string[] | {
+        packages?: string[];
+    };
+    imports?: Record<string, unknown>;
+    exports?: unknown;
+}
+export interface PresetProject {
+    root: string;
+    scopes: PresetScope[];
+    units: PresetUnit[];
+    suffixes: string[];
+    colocated: string[];
+    orpc: Required<PresetOrpcOptions>;
+    layouts: PresetLayoutScope[];
     rpcClients: string[];
+    operations: string[];
     packages: string[];
     scripts: string[];
-    root: string;
-    level: 'error' | 'warn';
-    css: Record<string, string>;
-    baseImports: PresetImportRestriction[];
     web: string[];
-    /** Web `src` roots per framework. */
     tanstackWeb: string[];
     nextWeb: string[];
+    expoWeb: string[];
     backend: string[];
-    /** Server and runner architecture roots, without their source folder. */
     backendRoots: string[];
-    /** Source folders of packages roots: `src` of a package, or of each package in a folder of packages. */
     packageSources: string[];
-    /** Backend and package source folders, whose services follow the backend contract. */
     serviceRoots: string[];
     app: string[];
     appFiles: string[];
     webFiles: string[];
-    /** Web files plus React code in packages: `.tsx` files and the `components` and `hooks` folders. */
     reactFiles: string[];
     backendFiles: string[];
     services: string[];
     utilities: string[];
     types: string[];
-    /** UI kit folders resolved from `shadcn.ui`. */
     uiRoots: string[];
-    /** UI kit folders inside a web source. */
     webUiRoots: string[];
     ui: string[];
     generated: string[];
@@ -184,6 +292,11 @@ export interface PresetContext {
     components: string[];
     hooks: string[];
     publicEntrypoints: string[];
+    baseImports: PresetImportRestriction[];
+    css: Record<string, string>;
+    ignores: string[];
 }
-export type PresetJsPlugins = NonNullable<OxlintConfig['jsPlugins']>;
-export type PresetSettings = NonNullable<OxlintConfig['settings']>;
+export type PresetBuilder<K extends PresetGroupName> = (project: PresetProject, settings: PresetGroupSettings<K>, scope: PresetScope) => OxlintOverride[];
+export type PresetBuilders = {
+    [K in PresetGroupName]?: PresetBuilder<K>;
+};

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

@@ -0,0 +1,14 @@
+import type { AstFunction } from './ast.types.ts';
+import type { DeclarationsCandidate } from './declarations.types.ts';
+import type { ESTree } from '@oxlint/plugins';
+export interface ReactPropsOptions {
+    prefix?: boolean;
+}
+export interface ReactPropsComponent {
+    candidate: DeclarationsCandidate;
+    index: number;
+}
+export interface ReactPropsTarget {
+    fn: AstFunction;
+    typeArgument?: ESTree.TSType;
+}

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

@@ -0,0 +1,20 @@
+export interface SchemasElementOptions {
+    namespaces: string[];
+    methods: string[];
+    structural: string[];
+    scalars: boolean;
+}
+export interface SchemasLocalOptions {
+    packages: string[];
+    namespaces: string[];
+    allow?: string[];
+    patterns?: string[];
+    message?: string;
+    importMessage?: string;
+    constructionMessage?: string;
+}
+export interface SchemasRederiveOptions {
+    from: string[];
+    namespaces?: string[];
+    operators?: string[];
+}

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

@@ -0,0 +1 @@
+export type SourceIndent = number | 'tab';

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

@@ -0,0 +1,39 @@
+import type { AstFunction } from './ast.types.ts';
+import type { OptionsPattern } from './options.types.ts';
+import type { ESTree } from '@oxlint/plugins';
+export interface TestsModifiersOptions {
+    functions?: string[];
+}
+export interface TestsAssertionsOptions extends TestsModifiersOptions {
+    assertions?: string[];
+}
+export interface TestsAssertionsRegistration {
+    call: ESTree.CallExpression;
+    callback: AstFunction;
+    table?: ESTree.Expression;
+}
+export interface TestsAssertionsRow {
+    bindings: Map<ESTree.Node, AstFunction>;
+    callbacks: AstFunction[];
+}
+export interface TestsAssertionsState {
+    tests: string[];
+    patterns: RegExp[];
+    assertionRoots: Set<string>;
+    functions: Map<ESTree.Node, AstFunction>;
+    values: Map<ESTree.Node, ESTree.Expression>;
+    aliases: Map<ESTree.Node, string>;
+    shadowed: Set<ESTree.Node>;
+    calls: ESTree.CallExpression[];
+    allowed: Set<AstFunction>;
+}
+export interface TestsTitlesOptions {
+    callees: string[];
+    deny?: OptionsPattern;
+    require?: OptionsPattern;
+    flags?: string;
+}
+export interface TestsTitlesPattern {
+    regex: RegExp;
+    pattern: string;
+}

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

@@ -0,0 +1,20 @@
+import type { OptionsPattern } from './options.types.ts';
+import type { ESTree } from '@oxlint/plugins';
+export interface TypesDeclarationsOptions {
+    allow?: OptionsPattern;
+}
+export type TypesDeclarationNode = ESTree.TSTypeAliasDeclaration | ESTree.TSInterfaceDeclaration;
+export interface TypesImportedBinding {
+    name: string;
+    source: string;
+}
+export interface TypesInlineOptions {
+    parameters?: boolean;
+    returns?: boolean;
+    functions?: boolean;
+    min?: number;
+}
+export interface TypesNamespaceImportOptions {
+    max: number;
+    names: Record<string, string>;
+}

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

@@ -0,0 +1,19 @@
+import type { AstFunction } from '../types/ast.types.ts';
+import type { ESTree } from '@oxlint/plugins';
+export declare function astVisit(node: unknown, ancestors: ESTree.Node[], callback: (node: ESTree.Node, ancestors: ESTree.Node[]) => void): void;
+export declare function astMatchesCallee(name: string | undefined, callees: readonly string[], modifiers: ReadonlySet<string>): boolean;
+export declare function astIsTypeOnlyImport(node: ESTree.ImportDeclaration): boolean;
+export declare function astStaticString(node: ESTree.Node): string | undefined;
+export declare function astContainsJsx(node: unknown): boolean;
+export declare function astNearestFunction(ancestors: readonly ESTree.Node[]): AstFunction | undefined;
+export declare function astReturnExpressions(node: AstFunction): ESTree.Expression[];
+export declare function astSingleExpression(node: AstFunction): ESTree.Expression | null;
+export declare function astUnwrap(expression: ESTree.Expression): ESTree.Expression;
+export declare function astIsForwarder(node: AstFunction, expression: ESTree.Expression): boolean;
+export declare function astModuleName(node: ESTree.ModuleExportName): string;
+export declare function astBindings(pattern: ESTree.BindingPattern | ESTree.BindingRestElement): ESTree.BindingIdentifier[];
+export declare function astDeclaration(statement: ESTree.Program['body'][number]): ESTree.ArrayExpression | ESTree.ArrowFunctionExpression | ESTree.AssignmentExpression | ESTree.AwaitExpression | ESTree.BigIntLiteral | ESTree.BinaryExpression | ESTree.BlockStatement | ESTree.BooleanLiteral | ESTree.BreakStatement | ESTree.CallExpression | ESTree.ChainExpression | ESTree.Class | ESTree.ComputedMemberExpression | ESTree.ConditionalExpression | ESTree.ContinueStatement | ESTree.DebuggerStatement | ESTree.DoWhileStatement | ESTree.EmptyStatement | ESTree.ExportAllDeclaration | ESTree.ExpressionStatement | ESTree.ForInStatement | ESTree.ForOfStatement | ESTree.ForStatement | ESTree.Function | ESTree.IdentifierReference | ESTree.IfStatement | ESTree.ImportDeclaration | ESTree.ImportExpression | ESTree.JSXElement | ESTree.JSXFragment | ESTree.LabeledStatement | ESTree.LogicalExpression | ESTree.MetaProperty | ESTree.NewExpression | ESTree.NullLiteral | ESTree.NumericLiteral | ESTree.ObjectExpression | ESTree.ParenthesizedExpression | ESTree.PrivateFieldExpression | ESTree.PrivateInExpression | ESTree.RegExpLiteral | ESTree.ReturnStatement | ESTree.SequenceExpression | ESTree.StaticMemberExpression | ESTree.StringLiteral | ESTree.Super | ESTree.SwitchStatement | ESTree.TSAsExpression | ESTree.TSEnumDeclaration | ESTree.TSExportAssignment | ESTree.TSGlobalDeclaration | ESTree.TSImportEqualsDeclaration | ESTree.TSInstantiationExpression | ESTree.TSInterfaceDeclaration | ESTree.TSModuleDeclaration | ESTree.TSNamespaceExportDeclaration | ESTree.TSNonNullExpression | ESTree.TSSatisfiesExpression | ESTree.TSTypeAliasDeclaration | ESTree.TSTypeAssertion | ESTree.TaggedTemplateExpression | ESTree.TemplateLiteral | ESTree.ThisExpression | ESTree.ThrowStatement | ESTree.TryStatement | ESTree.UnaryExpression | ESTree.UpdateExpression | ESTree.V8IntrinsicExpression | ESTree.VariableDeclaration | ESTree.WhileStatement | ESTree.WithStatement | ESTree.YieldExpression | null;
+export declare function astMemberName(node: ESTree.MemberExpression): string | undefined;
+export declare function astDottedName(node: ESTree.Node): string | undefined;
+export declare function astCallName(node: ESTree.CallExpression): string | undefined;
+export declare function astSelectorRule(selector: string, message: string): import("@oxlint/plugins").Rule;