@master/css-tooling

export declare function createToolingSession(  options: MasterCSSToolingSessionOptions): Promise<MasterCSSToolingSession>;

export interface MasterCSSDocumentAnalysis {    readonly version: 4;    readonly classPositions: readonly MasterCSSLanguageClassPosition[];    readonly diagnostics: readonly import('@master/css-binding/tooling').MasterCSSDiagnostic[];    readonly semanticTokens: readonly SemanticTokenItem[];    readonly semanticTokenData: readonly number[];}

export interface MasterCSSDocumentAnalysisRequest {    readonly source: string;    readonly languageId: string;    readonly hostRanges?: readonly MasterCSSLanguageClassListContext[];    readonly settings?: Readonly<{        classAttributes?: readonly string[];        classFunctions?: readonly string[];        classDeclarations?: readonly string[];    }>;}

export interface MasterCSSFormatDirectivesRequest {    readonly source: string;    readonly range?: Readonly<{        start: number;        end: number;    }>;    readonly styleRanges?: readonly Readonly<{        start: number;        end: number;    }>[];}

export interface MasterCSSFormatDirectivesResult {    readonly version: 4;    readonly edits: readonly Readonly<{        range: Readonly<{            start: number;            end: number;        }>;        text: string;    }>[];}

export interface MasterCSSLanguageClassListContext {    readonly start: number;    readonly end: number;    readonly unescape?: readonly string[];}

export interface MasterCSSLanguageClassPosition {    readonly range: Readonly<{        start: number;        end: number;    }>;    readonly contextRange: Readonly<{        start: number;        end: number;    }>;    readonly raw: string;    readonly token: string;}

export interface MasterCSSToolingSessionOptions {    readonly manifest: MasterCSSManifest;    /** Explicit native class registrations; suppresses retired-utility advice only. */    readonly nativeClassNames?: readonly string[];    readonly binding?: MasterCSSBinding;}

export declare function createToolingSessionSync(  options: {    readonly manifest: MasterCSSManifest;    /** Explicit native class registrations; suppresses retired-utility advice only. */    readonly nativeClassNames?: readonly string[];}): MasterCSSToolingSession;

declare const CSS_SYNTAX_CHECK: Readonly<{    name: "@eslint/css-tree";    version: string;    phase: "css-syntax";    scope: "selectors-queries-declarations";}>;

declare const CSS_VALUE_CHECK: Readonly<{    name: "@eslint/css-tree";    version: string;    phase: "css-value";    scope: "expanded-declarations-and-known-math-grammar-and-static-types-v1";}>;

export declare function cssSyntaxStatus(text: string): MasterCSSSyntaxStatus;

export declare function cssValueStatus(  property: string,  value: string): MasterCSSValueStatus;

export declare function getToolingBindingInfo(): import("~/packages/binding/dist").MasterCSSBindingInfo;

export declare function validateRuleDeclarations(  text: string): DeclarationValidation[];

declare const builtinKeyAliases: MasterCSSBuiltinKeyAliases;

declare const builtinTokenNamespaces: MasterCSSBuiltinTokenNamespaces;

export type MasterCSSBuiltinKeyAliases = Readonly<Record<string, string>>;

export interface MasterCSSBuiltinTokenNamespace {    readonly properties: readonly string[];    readonly variableAliasRefs: readonly string[];}

export type MasterCSSBuiltinTokenNamespaces = readonly MasterCSSBuiltinTokenNamespace[];

export declare function analyzeClassList(  request: MasterCSSClassListAnalysisRequest,  options: {    readonly manifest: MasterCSSManifest;    readonly binding?: MasterCSSBinding;}): Promise<MasterCSSClassListAnalysis>;

export interface MasterCSSClassListAnalysis {    readonly version: 1;    readonly classLists: readonly (readonly MasterCSSClassListItem[])[];    readonly cssSources: readonly MasterCSSCSSAnalysis[];    readonly escapedIdentifiers: readonly string[];}

export interface MasterCSSClassListAnalysisRequest {    readonly classLists?: readonly MasterCSSClassListInput[];    readonly cssSources?: readonly string[];    readonly escapeIdentifiers?: readonly string[];}

export interface MasterCSSClassListInput {    readonly source: string;    readonly unescape?: readonly string[];}

export interface MasterCSSClassListItem {    readonly range: MasterCSSSourceRange;    readonly raw: string;    readonly token: string;}

export interface MasterCSSCSSAnalysis {    readonly directives: readonly MasterCSSCSSDirectiveAnalysis[];    readonly imports: readonly MasterCSSCSSImportAnalysis[];}

export interface MasterCSSCSSDirectiveAnalysis {    readonly name: string;    readonly range: MasterCSSSourceRange;    readonly preludeRange: MasterCSSSourceRange;    readonly hasBlock: boolean;    readonly quotedStrings: number;}

export interface MasterCSSCSSImportAnalysis {    readonly range: MasterCSSSourceRange;    readonly statement: string;    readonly source?: string;}

export interface MasterCSSSourceRange {    readonly start: number;    readonly end: number;}

export declare function analyzeClassListSync(  request: MasterCSSClassListAnalysisRequest,  options: {    readonly manifest: MasterCSSManifest;}): MasterCSSClassListAnalysis;

export declare function extractSource(  request: MasterCSSSourceExtractionRequest,  options: {    readonly manifest: MasterCSSManifest;    readonly binding?: MasterCSSBinding;}): Promise<MasterCSSSourceExtraction>;

export interface MasterCSSDecodedHTMLAttribute {    readonly value: string;    readonly spans: readonly {        readonly range: {            readonly start: number;            readonly end: number;        };        readonly sourceRange: {            readonly start: number;            readonly end: number;        };    }[];}

export interface MasterCSSExtractedSource {    readonly source: string;    readonly candidates: readonly string[];    readonly occurrences: readonly import('@master/css-binding/tooling').MasterCSSSourceOccurrence[];    readonly diagnostics: readonly import('@master/css-binding/tooling').MasterCSSDiagnostic[];}

export interface MasterCSSSourceExtraction {    readonly version: 2;    readonly files: readonly MasterCSSExtractedSource[];}

export interface MasterCSSSourceExtractionInput {    readonly source: string;    readonly content: string;    readonly owner?: string;    readonly kind?: MasterCSSSourceKind;}

export interface MasterCSSSourceExtractionRequest {    readonly files: readonly MasterCSSSourceExtractionInput[];}

export type MasterCSSSourceKind = 'auto' | 'raw' | 'oxc' | 'html' | 'astro' | 'markdown' | 'mdx';

export declare function extractSourceSync(  request: MasterCSSSourceExtractionRequest,  options: {    readonly manifest: MasterCSSManifest;}): MasterCSSSourceExtraction;

export declare function createScanner(  options: MasterCSSScannerOptions,  cwd?: string): Promise<MasterCSSScanner>;

declare const defaultScannerOptions: Readonly<MasterCSSScannerConfiguration>;

export interface MasterCSSScannerConfiguration {    verbose?: number;    path?: string;    /** Actual bundler output directories, always excluded from source input. */    outputDirectories?: readonly string[];    exclude?: readonly string[];    safelist?: readonly string[];    blocklist?: readonly (string | RegExp)[];}

export interface MasterCSSScannerOptions extends MasterCSSScannerConfiguration, MasterCSSBindingLoadOptions {    manifest: MasterCSSManifest;}

export interface MasterCSSScannerSourceResult {    readonly changed: boolean;    readonly sourceChanged: boolean;    /** All candidates extracted from this input, including previously scanned classes. */    readonly candidates: readonly string[];}

export type ScannerSourceInput = MasterCSSScannerSourceInput;

export type ScannerSourceOptions = MasterCSSScannerSourceOptions;

export declare class SourcePolicy {    readonly projectDir: string;    readonly options: SourcePolicyOptions;    readonly dependencies: Set<string>;    readonly root: string;    constructor(projectDir: string, options?: SourcePolicyOptions);    accepts(source: string, explicit?: boolean): boolean;}

export interface SourcePolicyOptions {    readonly exclude?: readonly string[];    readonly outputDirectories?: readonly string[];}

declare const CSS_SYNTAX_CHECK: Readonly<{    name: "@eslint/css-tree";    version: string;    phase: "css-syntax";    scope: "selectors-queries-declarations";}>;

declare const CSS_VALUE_CHECK: Readonly<{    name: "@eslint/css-tree";    version: string;    phase: "css-value";    scope: "expanded-declarations-and-known-math-grammar-and-static-types-v1";}>;

export declare function cssSyntaxStatus(text: string): MasterCSSSyntaxStatus;

export declare function cssValueStatus(  property: string,  value: string): MasterCSSValueStatus;

export interface DeclarationValidation {    readonly property: string;    readonly value: string;    readonly atRule?: string;    readonly status: MasterCSSValueStatus;    readonly range?: {        readonly start: number;        readonly end: number;    };}

export interface MasterCSSClassValidation {    readonly className: string;    readonly matchStatus: BindingBatch['classes'][number]['matchStatus'];    readonly declarations: readonly import('../value-validation').DeclarationValidation[];    readonly checks: readonly {        readonly name: string;        readonly version: string;        readonly scope: string;        readonly phase: import('@master/css-binding/tooling').MasterCSSDiagnostic['phase'];    }[];    readonly cssSyntaxStatus: BindingBatch['classes'][number]['cssSyntaxStatus'];    readonly cssValueStatus: BindingBatch['classes'][number]['cssValueStatus'];    readonly browserSupport: BindingBatch['classes'][number]['browserSupport'];    readonly rules: readonly MasterCSSHydrationRule[];    readonly diagnostics?: readonly import('@master/css-binding/tooling').MasterCSSDiagnostic[];}

export interface MasterCSSClassValidationResult {    readonly version: 3;    readonly classes: readonly MasterCSSClassValidation[];}

export declare function validateClassNames(classNames: readonly string[], options: {    readonly manifest: MasterCSSManifest;    readonly binding?: MasterCSSBinding;}): Promise<MasterCSSClassValidationResult>;

export declare function validateRuleDeclarations(  text: string): DeclarationValidation[];

export declare function validateClassNamesSync(  classNames: readonly string[],  options: {    readonly manifest: MasterCSSManifest;}): import("./contracts").MasterCSSClassValidationResult;

export interface CanonicalClassNameOptions {    preferStaticUtilities?: boolean;    preferPropertyAliases?: boolean;    preferCompositionUtilities?: boolean;    preferConditionOrder?: boolean;}

export declare function createMasterCSSLintDiagnostics(  diagnostics: readonly MasterCSSLintDiagnosticInput[],  severity?: MasterCSSLintDiagnosticSeverity): readonly MasterCSSLintDiagnostic[];

declare const defaultCanonicalClassNameOptions: Readonly<Required<CanonicalClassNameOptions>>;

declare const defaultClassLintSettings: Readonly<{    classAttributes: readonly string[];    classFunctions: readonly string[];    classDeclarations: readonly string[];    ignoredKeys: readonly string[];}>;

declare const defaultMasterCSSLintRules: Readonly<Record<MasterCSSLintRuleId, boolean>>;

export declare function fixMasterCSSContent(  options: MasterCSSFixContentOptions): string;

export declare function lintClassNames(classNames: readonly string[], options: {    readonly manifest: MasterCSSManifest;    readonly binding?: MasterCSSBinding;}): Promise<MasterCSSLintAnalysis>;

export declare function lintMasterCSSContent(  options: MasterCSSLintContentOptions): MasterCSSLintFileResult;

export interface MasterCSSCanonicalClassesReportOptions extends MasterCSSLintReportOptions, CanonicalClassNameOptions {}

export interface MasterCSSClassListEditOptions {    unescape?: string | false;}

export interface MasterCSSClassListLintReportOptions extends MasterCSSInvalidClassesReportOptions, RawValuePolicyOptions, CanonicalClassNameOptions {    rules?: Partial<Record<MasterCSSLintRuleId, boolean>>;    severities?: Partial<Record<MasterCSSLintRuleId, MasterCSSLintDiagnosticSeverity>>;}

export type MasterCSSFixContentOptions = MasterCSSLintContentOptions;

export interface MasterCSSInvalidClassesReportOptions extends MasterCSSLintReportOptions {    disallowUnknownClass?: boolean;}

export interface MasterCSSLintAnalysis {    readonly version: 2;    readonly sortedClassNames: readonly string[];    readonly conflicts: readonly MasterCSSLintClassConflict[];    readonly partialConflicts: readonly MasterCSSLintPartialClassConflict[];}

export interface MasterCSSLintCanonicalClassGroupSuggestion {    readonly classNames: readonly string[];    readonly recommended: string;}

export interface MasterCSSLintCanonicalClassSuggestion {    readonly className: string;    readonly recommended: string;}

export interface MasterCSSLintClassConflict {    readonly className: string;    readonly conflicts: readonly string[];}

export interface MasterCSSLintClassListAnalysis {    readonly version: 2;    readonly analysis: MasterCSSLintAnalysis;    readonly diagnostics: readonly MasterCSSLintDiagnosticInput[];    readonly sortEdit?: MasterCSSLintEdit;    readonly conflictEdit?: MasterCSSLintEdit;    readonly conflictRange?: Readonly<{        start: number;        end: number;    }>;}

export interface MasterCSSLintClassListOptions {    readonly disallowUnknownClass?: boolean;    readonly rawValuePolicy?: RawValuePolicyOptions;    readonly canonicalOptions?: CanonicalClassNameOptions;}

export interface MasterCSSLintContentOptions {    content: string;    filePath: string;    rules?: Partial<Record<MasterCSSLintRuleId, boolean>>;    ruleOptions?: MasterCSSLintContentRuleOptions;    severities?: Partial<Record<MasterCSSLintRuleId, MasterCSSLintDiagnosticSeverity>>;    lintSession: Pick<MasterCSSToolingSession, 'analyzeLintClassList' | 'analyzeLintDocument' | 'tokenizeClassList'>;}

export interface MasterCSSLintContentRuleOptions {    'no-invalid-classes'?: MasterCSSInvalidClassesReportOptions;    'prefer-canonical-classes'?: MasterCSSCanonicalClassesReportOptions;    'no-unapproved-raw-values'?: MasterCSSUnapprovedRawValueClassesReportOptions;}

export interface MasterCSSLintDiagnostic {    ruleId: MasterCSSLintRuleId;    code: string;    message: string;    severity: MasterCSSLintDiagnosticSeverity;    range: MasterCSSLintRange;    data?: MasterCSSLintDiagnosticData;    fix?: MasterCSSLintFix;}

export type MasterCSSLintDiagnosticData = Record<string, string | number | boolean | string[] | null | undefined>;

export interface MasterCSSLintDiagnosticInput {    readonly ruleId: MasterCSSLintRuleId;    readonly code: string;    readonly message: string;    readonly range: Readonly<{        start: number;        end: number;    }>;    readonly data?: MasterCSSLintDiagnosticData;    readonly fix?: MasterCSSLintEdit;}

export type MasterCSSLintDiagnosticSeverity = 'error' | 'warning';

export type MasterCSSLintDiagnosticSourceKind = 'class-attribute' | 'class-expression' | 'manifest';

export interface MasterCSSLintDocumentAnalysis {    readonly diagnostics: readonly import('@master/css-binding/tooling').MasterCSSDiagnostic[];    readonly classPositions: readonly Readonly<{        range: Readonly<{            start: number;            end: number;        }>;        contextRange: Readonly<{            start: number;            end: number;        }>;        raw: string;        token: string;    }>[];}

export interface MasterCSSLintEdit {    readonly range: Readonly<{        start: number;        end: number;    }>;    readonly text: string;    readonly scope: 'class-list';}

export interface MasterCSSLintFileResult {    filePath: string;    languageId: string;    sourceKind: MasterCSSLintFileSourceKind;    diagnostics: MasterCSSLintSourceDiagnostic[];}

export type MasterCSSLintFileSourceKind = 'source' | 'stylesheet' | 'manifest';

export interface MasterCSSLintFix {    range: MasterCSSLintRange;    text: string;    scope?: 'class-list' | 'directive';}

export interface MasterCSSLintPartialClassConflict {    readonly className: string;    readonly replacement: string;    readonly conflict: string;}

export interface MasterCSSLintRange {    start: number;    end: number;}

export interface MasterCSSLintRawValueCandidate {    readonly className: string;    readonly key: string;    readonly segments: readonly string[];    readonly properties: readonly string[];}

export interface MasterCSSLintReport {    diagnostics: MasterCSSLintDiagnostic[];}

export interface MasterCSSLintReportOptions extends MasterCSSClassListEditOptions {    severity?: MasterCSSLintDiagnosticSeverity;}

export type MasterCSSLintRuleId = 'sort-classes' | 'no-invalid-classes' | 'no-conflicting-classes' | 'prefer-canonical-classes' | 'no-unapproved-raw-values';

declare const masterCSSLintRuleIds: readonly MasterCSSLintRuleId[];

export interface MasterCSSLintSourceDiagnostic {    ruleId?: MasterCSSLintRuleId | 'manifest';    code: string;    severity: MasterCSSLintDiagnosticSeverity;    message: string;    range: MasterCSSLintRange;    loc: MasterCSSLintSourceLocationRange;    source: 'Master CSS';    sourceKind: MasterCSSLintDiagnosticSourceKind;    data?: MasterCSSLintDiagnosticData;    fixes?: MasterCSSLintSourceFix[];}

export interface MasterCSSLintSourceFix {    kind: MasterCSSLintSourceFixKind;    safety: MasterCSSLintSourceFixSafety;    range: MasterCSSLintRange;    text: string;    description: string;    requiresFormatting: boolean;}

export type MasterCSSLintSourceFixKind = 'class-list';

export type MasterCSSLintSourceFixSafety = 'safe';

export interface MasterCSSLintSourceLocation {    line: number;    column: number;}

export interface MasterCSSLintSourceLocationRange {    start: MasterCSSLintSourceLocation;    end: MasterCSSLintSourceLocation;}

export interface MasterCSSLintSummary {    files: number;    diagnostics: number;    errors: number;    warnings: number;    fixable: number;    safeFixes: number;}

export interface MasterCSSLintToken {    readonly range: Readonly<{        start: number;        end: number;    }>;    readonly raw: string;    readonly token: string;}

export interface MasterCSSUnapprovedRawValueClassesReportOptions extends MasterCSSLintReportOptions, RawValuePolicyOptions {}

export interface RawValuePolicyOptions {    allowRawValues?: boolean;    allowProperties?: readonly string[];    allowedPatterns?: readonly string[];}

export declare function resolveMasterCSSLintRules(  option: string | undefined): Record<MasterCSSLintRuleId, boolean>;

export declare function summarizeMasterCSSLintFiles(  files: MasterCSSLintFileResult[]): MasterCSSLintSummary;

export declare function lintClassNamesSync(classNames: readonly string[], options: {    readonly manifest: MasterCSSManifest;}): import("./analysis").MasterCSSLintAnalysis;

export declare function analyzeDocument(  request: MasterCSSDocumentAnalysisRequest,  options: {    readonly manifest: MasterCSSManifest;    readonly binding?: MasterCSSBinding;}): Promise<MasterCSSDocumentAnalysis>;

declare const AT_SIGN: "@";

declare const AT_TRIGGER_CHARACTER: "@";

declare const CLASS_ATTRIBUTES: string[];

declare const CLASS_DECLARATIONS: string[];

declare const CLASS_FUNCTIONS: string[];

export declare function createLanguageSession(options: {    readonly manifest: MasterCSSManifest;    readonly binding?: MasterCSSBinding;}): Promise<LanguageSession>;

declare const DECLARATION_SEPARATOR_TRIGGER_CHARACTER: ";";

declare const DELIMITER_SIGN: "|";

export declare function formatDirectives(  request: MasterCSSFormatDirectivesRequest,  options: {    readonly manifest: MasterCSSManifest;    readonly binding?: MasterCSSBinding;}): Promise<MasterCSSFormatDirectivesResult>;

export declare function getMasterCSSSemanticTokenScopeKeys(  type: SemanticTokenType,  modifiers?: SemanticTokenModifier[]): ("string" | "number" | "function" | "type" | "property" | "class" | "enumMember" | "variable" | "keyword" | "modifier" | "operator" | "class.component" | "class.declaration" | "class.selector" | "enumMember.directive" | "enumMember.query" | "enumMember.unit" | "property.directive" | "property.query" | "variable.directive" | "variable.selector" | "number.query" | "string.quoted" | "keyword.directive" | "keyword.query" | "modifier.directive" | "modifier.pseudoClass" | "modifier.pseudoElement" | "operator.directive" | "operator.blockBrace" | "operator.declarationSeparator" | "operator.declarationTerminator" | "operator.directiveTerminator" | "operator.functionPunctuation" | "operator.important" | "operator.pseudoClass" | "operator.pseudoClassDelimiter" | "operator.pseudoElement" | "operator.pseudoElementDelimiter" | "operator.query" | "operator.queryOperator" | "operator.queryPunctuation" | "operator.selector" | "operator.selectorCombinator" | "operator.selectorPunctuation" | "operator.unit" | "operator.valueOperator" | "operator.valueSeparator" | "type.selector")[];

declare const GROUP_TRIGGER_CHARACTER: "{";

export type HighlightTokenRole = 'block.brace' | 'declaration.property' | 'declaration.separator' | 'declaration.terminator' | 'query.keyword' | 'selector.combinator' | 'selector.pseudoClass.delimiter' | 'selector.pseudoClass.name' | 'selector.pseudoElement.delimiter' | 'selector.pseudoElement.name' | 'selector.punctuation' | 'selector.type' | 'utility.component' | 'utility.semantic' | 'value.important' | 'value.function' | 'value.function.punctuation' | 'value.keyword' | 'value.number' | 'value.operator' | 'value.separator' | 'value.string' | 'value.unit' | 'value.variable';

export declare function inspectClassName(className: string, options: {    readonly manifest: MasterCSSManifest;    readonly binding?: MasterCSSBinding;    readonly mode?: string;}): Promise<import("./contracts").MasterCSSLanguageInspection>;

declare const INVOKED_TRIGGER_CHARACTERS: string[];