@master/css-schema

export declare function flattenMasterCSSManifestVariables(  variables: MasterCSSManifestVariables | undefined): MasterCSSManifestVariableEntry[];

export declare function getMasterCSSManifestVariableName(  namespace: string,  variable: Pick<MasterCSSManifestVariable, 'key' | 'name'>): string;

export declare function groupMasterCSSManifestVariables(  variables: readonly MasterCSSManifestVariable[] | undefined): MasterCSSManifestVariables | undefined;

export declare function isMasterCSSRenderingMode(  value: unknown): value is MasterCSSRenderingMode;

declare const MASTER_CSS_DIAGNOSTIC_VERSION: 2;

declare const MASTER_CSS_RENDERING_MODES: readonly [    "runtime",    "static",    "pre-render",    "progressive"];

export interface MasterCSSDiagnostic {    readonly version: typeof MASTER_CSS_DIAGNOSTIC_VERSION;    readonly code: string;    readonly domain: MasterCSSDiagnosticDomain;    readonly phase?: 'match' | 'css-syntax' | 'css-value' | 'browser-support' | 'compiler';    readonly severity: MasterCSSDiagnosticSeverity;    readonly message: string;    readonly source?: string;    readonly range?: MasterCSSDiagnosticRange;    readonly notes?: readonly string[];    readonly help?: string;}

export type MasterCSSDiagnosticDomain = 'binding' | 'compiler' | 'engine' | 'integration' | 'language' | 'project' | 'runtime' | 'server' | 'tooling';

export interface MasterCSSDiagnosticPosition {    line: number;    character: number;}

export interface MasterCSSDiagnosticRange {    start: MasterCSSDiagnosticPosition;    end: MasterCSSDiagnosticPosition;}

export type MasterCSSDiagnosticSeverity = 'error' | 'warning' | 'information';

export declare class MasterCSSError extends Error {    readonly code: string;    readonly domain: MasterCSSDiagnosticDomain;    readonly diagnostics: readonly MasterCSSDiagnostic[];    readonly payload: MasterCSSErrorPayload;    constructor(payload: MasterCSSErrorPayload, options?: MasterCSSErrorOptions);    toJSON(): MasterCSSErrorPayload;}

export interface MasterCSSErrorOptions extends ErrorOptions {    diagnostics?: readonly MasterCSSDiagnostic[];}

export interface MasterCSSErrorPayload {    readonly code: string;    readonly domain: MasterCSSDiagnosticDomain;    readonly message: string;    readonly diagnostics?: readonly MasterCSSDiagnostic[];}

export interface MasterCSSIntegrationOptions {    enabled?: boolean;    mode?: MasterCSSRenderingMode;    pruneNativeCSS?: boolean;    runtime?: boolean | MasterCSSIntegrationRuntimeOptions;}

export interface MasterCSSIntegrationRuntimeOptions {    enabled?: boolean;    avoidFOUC?: boolean;}

export interface MasterCSSManifest {    /**     * MasterCSSManifest IR schema/codec version.     * This is not a legacy Config compatibility marker; engines must reject     * unsupported manifest versions instead of migrating authoring APIs at runtime.     */    version: 1;    languageVersion: 3;    modes?: MasterCSSManifestMode[];    settings?: MasterCSSManifestSettings;    variables?: MasterCSSManifestVariables;    animations?: MasterCSSManifestAnimations;    animationOptions?: MasterCSSManifestAnimationOptions;    variants?: MasterCSSManifestVariants;    conditions?: MasterCSSManifestConditions;    breakpointConditions?: MasterCSSManifestConditions;    containerConditions?: MasterCSSManifestConditions;    selectors?: MasterCSSManifestSelectors;    utilities?: MasterCSSManifestUtilities;    debug?: Record<string, unknown>;}

export type MasterCSSRenderingMode = typeof MASTER_CSS_RENDERING_MODES[number];

export declare function normalizeMasterCSSManifest(  manifest: MasterCSSManifest): MasterCSSManifest;

export declare function serializeMasterCSSManifest(  manifest: MasterCSSManifest): string;

export declare function flattenMasterCSSManifestVariables(  variables: MasterCSSManifestVariables | undefined): MasterCSSManifestVariableEntry[];

export declare function getMasterCSSManifestVariableName(  namespace: string,  variable: Pick<MasterCSSManifestVariable, 'key' | 'name'>): string;

export declare function groupMasterCSSManifestVariables(  variables: readonly MasterCSSManifestVariable[] | undefined): MasterCSSManifestVariables | undefined;

export interface MasterCSSManifest {    /**     * MasterCSSManifest IR schema/codec version.     * This is not a legacy Config compatibility marker; engines must reject     * unsupported manifest versions instead of migrating authoring APIs at runtime.     */    version: 1;    languageVersion: 3;    modes?: MasterCSSManifestMode[];    settings?: MasterCSSManifestSettings;    variables?: MasterCSSManifestVariables;    animations?: MasterCSSManifestAnimations;    animationOptions?: MasterCSSManifestAnimationOptions;    variants?: MasterCSSManifestVariants;    conditions?: MasterCSSManifestConditions;    breakpointConditions?: MasterCSSManifestConditions;    containerConditions?: MasterCSSManifestConditions;    selectors?: MasterCSSManifestSelectors;    utilities?: MasterCSSManifestUtilities;    debug?: Record<string, unknown>;}

export type MasterCSSManifestAnimationOptions = Record<string, {    static?: boolean;}>;

export type MasterCSSManifestAnimations<TDeclarations = MasterCSSManifestCSSDeclarations> = Record<string, MasterCSSManifestKeyframes<TDeclarations>>;

export interface MasterCSSManifestCondition {    id: MasterCSSManifestConditionIdentifier;    nodes: MasterCSSManifestConditionNode[];}

export interface MasterCSSManifestConditionBooleanNode {    raw?: string;    name: string;    type: 'boolean';}

export interface MasterCSSManifestConditionComparisonOperatorNode {    type: 'comparison';    raw?: string;    value: string;}

export interface MasterCSSManifestConditionGroupNode {    type?: 'group';    raw?: string;    children: MasterCSSManifestConditionNode[];}

export type MasterCSSManifestConditionIdentifier = 'container' | 'starting-style' | 'supports' | 'media' | 'layer';

export interface MasterCSSManifestConditionLogicalOperatorNode {    type: 'logical';    raw?: string;    value: string;}

export type MasterCSSManifestConditionNode = MasterCSSManifestConditionBooleanNode | MasterCSSManifestConditionValueNode | MasterCSSManifestConditionComparisonOperatorNode | MasterCSSManifestConditionLogicalOperatorNode | MasterCSSManifestConditionGroupNode;

export interface MasterCSSManifestConditionNumberNode {    raw?: string;    name?: string;    type: 'number';    value: number;    unit?: string;    operator?: string;}

export type MasterCSSManifestConditionOperatorNode = MasterCSSManifestConditionComparisonOperatorNode | MasterCSSManifestConditionLogicalOperatorNode;

export type MasterCSSManifestConditions = Record<string, MasterCSSManifestCondition>;

export interface MasterCSSManifestConditionStringNode {    raw?: string;    name?: string;    type: 'string';    value: string;}

export type MasterCSSManifestConditionValueNode = MasterCSSManifestConditionNumberNode | MasterCSSManifestConditionStringNode;

export type MasterCSSManifestCSSDeclarationPrimitive = string | number | null;

export type MasterCSSManifestCSSDeclarations = PropertiesHyphen | Record<string, MasterCSSManifestCSSDeclarationPrimitive | MasterCSSManifestCSSDeclarationPrimitive[]>;

export type MasterCSSManifestKeyframes<TDeclarations = MasterCSSManifestCSSDeclarations> = Record<'from' | 'to' | string, TDeclarations>;

export interface MasterCSSManifestMode {    name: string;    branches: {        selector: string;        conditions?: string[];    }[];}

export interface MasterCSSManifestSelectorCombinatorNode {    type: 'combinator';    raw?: string;    value: string;}

export interface MasterCSSManifestSelectorLiteralNode {    type?: 'attribute' | 'pseudo-class' | 'pseudo-element' | 'class' | 'universal' | 'id';    raw?: string;    value?: string;    children?: MasterCSSManifestSelectorNode[];}

export type MasterCSSManifestSelectorNode = MasterCSSManifestSelectorLiteralNode | MasterCSSManifestSelectorCombinatorNode | MasterCSSManifestSelectorSeparatorNode;

export type MasterCSSManifestSelectors = Record<string, MasterCSSManifestSelectorNode[]>;

export interface MasterCSSManifestSelectorSeparatorNode {    type: 'separator';    raw?: string;    value: string;}

export interface MasterCSSManifestSettings {    scope?: string;    important?: boolean;}

export type MasterCSSManifestUtilities = MasterCSSManifestUtility[];

export interface MasterCSSManifestUtility {    id: string;    name?: string;    type: UtilityType;    order?: number;    layer?: MasterCSSManifestUtilityLayerName;    key?: string;    subkey?: string;    keys?: string[];    aliasGroups?: string[];    namespaces?: string[];    implicitNamespace?: boolean;    separators?: string[];    conditions?: string[];    variableAliases?: MasterCSSManifestVariableAliasSet;    variableAliasRefs?: string[];    emit: MasterCSSManifestUtilityEmit;    matchers: MasterCSSManifestUtilityMatcher[];    debug?: Record<string, unknown>;}

export type MasterCSSManifestUtilityEmit = {    type: 'declarations';    declarations: string[];} | {    type: 'template';    declarations: MasterCSSManifestCSSDeclarations;} | {    type: 'property';    property: string;} | {    type: 'static';    rules: MasterCSSManifestUtilityRule[];};

export type MasterCSSManifestUtilityLayerName = 'base' | 'defaults' | 'components' | 'utilities';

export type MasterCSSManifestUtilityMatcher = {    type: 'static';    name: string;} | {    type: 'pattern';    prefix: string;    values: string[];    valueMap?: Record<string, string>;} | {    type: 'key';    keys: string[];} | {    type: 'token';    prefix: string;};

export interface MasterCSSManifestUtilityRule<TDeclarations = MasterCSSManifestCSSDeclarations> {    declarations: TDeclarations;    conditions?: string[];    selector?: string;}

export interface MasterCSSManifestVariable {    name?: string;    key: string;    namespace?: string;    type?: MasterCSSManifestVariableType;    value?: MasterCSSManifestVariableValue;    numeric?: MasterCSSManifestVariableNumericValue;    modes?: Record<string, {        type: MasterCSSManifestVariableType;        value: number | string;        numeric?: MasterCSSManifestVariableNumericValue;    }>;    dependencies?: string[];    mode?: string;    inline?: boolean;    static?: boolean;}

export type MasterCSSManifestVariableAlias = [    key: string,    name: string];

export type MasterCSSManifestVariableAliasSet = MasterCSSManifestVariableAlias[];

export type MasterCSSManifestVariableEntry = MasterCSSManifestVariable & {    name: string;    namespace?: string;    type: MasterCSSManifestVariableType;};

export interface MasterCSSManifestVariableNumericValue {    value: number;    unit?: string;}

export type MasterCSSManifestVariables = Record<string, MasterCSSManifestVariable[]>;

export type MasterCSSManifestVariableType = 'number' | 'string';

export type MasterCSSManifestVariableValue = number | string | false | (number | string)[];

export interface MasterCSSManifestVariant {    token: MasterCSSManifestVariantToken;    branches: MasterCSSManifestVariantBranch[];}

export interface MasterCSSManifestVariantBranch {    selector?: string;    selectorNodes?: MasterCSSManifestSelectorNode[];    conditions?: string[];    conditionNodes?: MasterCSSManifestCondition[];    layer?: MasterCSSManifestUtilityLayerName;}

export type MasterCSSManifestVariants = MasterCSSManifestVariant[];

export type MasterCSSManifestVariantToken = `:${string}` | `::${string}` | `@${string}`;

export declare function normalizeMasterCSSManifest(  manifest: MasterCSSManifest): MasterCSSManifest;

export declare function serializeMasterCSSManifest(  manifest: MasterCSSManifest): string;

export declare function createMasterCSSHydrationManifestScript(  hydrationManifest: MasterCSSHydrationManifest): string;

declare const MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE: "/_master-css/hydration/";

declare const MASTER_CSS_HYDRATION_MANIFEST_ATTR: "data-master-css-hydration-manifest";

declare const MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME: "master-css-hydration";

declare const MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID: "master-css-hydration-manifest";

export interface MasterCSSConditionRange {    readonly domain: string;    readonly feature: string;    readonly unit: string;    readonly lower: {        readonly value: number;        readonly inclusive: boolean;    } | null;    readonly upper: {        readonly value: number;        readonly inclusive: boolean;    } | null;}

export interface MasterCSSHydrationManifest {    readonly version: 1;    readonly languageVersion: 3;    readonly rules: readonly MasterCSSHydrationRule[];    readonly resourceOrder: readonly string[];}

export interface MasterCSSHydrationRule {    readonly className: string;    readonly key: string;    readonly layer: MasterCSSManifestUtilityLayerName;    readonly type: UtilityType;    readonly sortTier: number;    readonly priority: MasterCSSRulePriority;    readonly text: string;    readonly nodes?: readonly MasterCSSHydrationRuleNode[];    readonly selectorText?: string;    readonly variableNames?: readonly string[];    readonly animationNames?: readonly string[];}

export interface MasterCSSHydrationRuleNode {    readonly text: string;}

export interface MasterCSSRulePriority {    /** Token values sort before raw values within the same cascade tier. */    readonly valuePriority?: -1 | 0;    /** Parsed declaration identity, independent of public aliases. */    readonly sortKey?: string;    readonly features: readonly MasterCSSConditionRange[];    readonly conditions?: readonly string[];    readonly selector: number;}

export declare function serializeMasterCSSHydrationManifest(  hydrationManifest: MasterCSSHydrationManifest): string;

export declare function createCSSDirectiveSourceReference(  file: string | undefined,  range: CSSDirectiveSourceRange,  source?: string): CSSDirectiveSourceReference;

export type CSSDirectiveAnimationDefinitions = Record<string, Record<string, CSSDirectiveDeclarations>>;

export type CSSDirectiveAnimationOptions = Record<string, {    static?: boolean;}>;

export type CSSDirectiveConditionPathEntry = {    type: 'condition';    value: string;} | {    type: 'variant';    token: string;};

export type CSSDirectiveDeclarations = Record<string, string>;

export declare class CSSDirectiveError extends Error {    code: string;    source?: CSSDirectiveSourceReference;    related?: CSSDirectiveRelatedInformation[];    constructor(      code: string,      message: string,      source?: CSSDirectiveSourceReference,      related?: CSSDirectiveRelatedInformation[]    );}

export interface CSSDirectiveExtractionPolicy {    include: string[];    exclude: string[];    safelist: string[];    blocklist: (string | RegExp)[];    preserveNative: boolean;    pruneNative: boolean;}

export type CSSDirectiveLayerName = MasterCSSManifestUtilityLayerName;

export interface CSSDirectiveManifestInput {    variants?: CSSDirectiveVariantDefinitions;    variables?: CSSDirectiveVariableDefinition[];    utilities?: CSSDirectiveUtilityDefinition[];    scope?: string;    important?: boolean;    animations?: CSSDirectiveAnimationDefinitions;    animationOptions?: CSSDirectiveAnimationOptions;    modes?: MasterCSSManifestMode[];}

export interface CSSDirectiveReference {    source: string;    file?: string;}

export interface CSSDirectiveRelatedInformation {    message: string;    source?: CSSDirectiveSourceReference;}

export interface CSSDirectiveResult {    utilitySources?: CSSUtilitySource[];    nativeOutput?: CSSNativeOutput;    outputMappings?: CSSOutputMapping[];    /** Serialized source map v3 for the final CSS, when produced by the stylesheet host. */    sourceMap?: string;    nativeMappings?: CSSOutputMapping[];    generatedMappings?: CSSOutputMapping[];    manifestInput: CSSDirectiveManifestInput;    extractionPolicy: CSSDirectiveExtractionPolicy;    classNames: string[];    nativeClassNames: string[];    nativeCSS: string;    css: string;    generatedCSS: string;    warnings: string[];    dependencies: string[];    references?: CSSDirectiveReference[];    styleDefinitions?: CSSDirectiveStyleDefinition[];}

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

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

export interface CSSDirectiveSourceReference {    file?: string;    range: CSSDirectiveSourceRange;    loc?: {        start: CSSDirectiveSourceLocation;        end: CSSDirectiveSourceLocation;    };}

export type CSSDirectiveStyleDefinition = CSSDirectiveStyleNativeDefinition;

export interface CSSDirectiveStyleNativeDefinition {    type: 'native';    order: number;    selector: string;    declarations: CSSOrderedDeclaration[];    source?: CSSDirectiveSourceReference;    selectorSource?: CSSDirectiveSourceReference;    conditions?: string[];    conditionPath?: CSSDirectiveConditionPathEntry[];    layer?: CSSDirectiveLayerName;    name?: string;}

export interface CSSDirectiveUtilityDefinition {    name: string;    /** Complete ordered authoring body; retained until whole-definition replacement. */    body?: CSSDirectiveStyleDefinition[];    source?: CSSDirectiveSourceReference;    type?: 'static' | 'pattern' | 'dynamic' | 'token';    layer?: CSSDirectiveLayerName;    pattern?: CSSDirectiveUtilityPatternDefinition;    dynamic?: CSSDirectiveUtilityDynamicDefinition;    token?: CSSDirectiveUtilityTokenDefinition;    declarations?: CSSDirectiveDeclarations;    conditions?: string[];    conditionPath?: CSSDirectiveConditionPathEntry[];    rules?: CSSDirectiveUtilityRuleDefinition[];}

export interface CSSDirectiveUtilityDynamicDefinition {    key: string;}

export interface CSSDirectiveUtilityPatternDefinition {    prefix: string;    values: string[];    valueMap?: Record<string, string>;}

export interface CSSDirectiveUtilityRuleDefinition {    declarations: CSSDirectiveDeclarations;    conditions?: string[];    conditionPath?: CSSDirectiveConditionPathEntry[];    selector?: string;}

export interface CSSDirectiveUtilityTokenDefinition {    prefix: string;    variableAliasRefs: string[];}

export interface CSSDirectiveVariableDefinition {    name?: string;    value: CSSDirectiveVariableValue;    mode?: string;    inline?: boolean;    static?: boolean;    namespace?: string;    key?: string;}

export type CSSDirectiveVariableValue = number | string | false | (number | string)[];

export type CSSDirectiveVariantDefinitions = Pick<MasterCSSManifestVariant, 'token' | 'branches'>[];

export interface CSSNativeOutput {    css: string;    mappings: CSSOutputMapping[];    slots: {        start: number;        end: number;        marker: string;        definitions: CSSDirectiveStyleDefinition[];    }[];}

export interface CSSOrderedDeclaration {    property: string;    value: string;    source?: CSSDirectiveSourceReference;}

export interface CSSOutputMapping {    generatedStart: number;    generatedEnd?: number;    source: CSSDirectiveSourceReference;}

export interface CSSUtilitySource {    name: string;    identity: string;    replacedBy?: CSSDirectiveSourceReference;    source: CSSDirectiveSourceReference;}

export interface DefinedUtility {    id: string;    key?: string;    keys: string[];    matchers: {        key?: RegExp;        variable?: RegExp;        value?: RegExp;        arbitrary?: RegExp;    };    variables?: Map<string, Variable>;    order: number;    definition: MasterCSSManifestUtility;}

export type ExplicitUtilityLayerName = MasterCSSManifestUtilityLayerName;

export interface FunctionValueComponent {    text?: string;    token: string;    type: 'function';    name: string;    symbol: string;    children: ValueComponent[];    bypassTransform?: boolean;}

export interface MediaFeatureComponent {    type: string;    tokenType?: string;    operator?: string;    value: number;    unit: string;}

export interface MediaQuery {    token: string;    features: Record<string, MediaFeatureComponent>;    type?: string;}

export interface NumberValueComponent {    text?: string;    token: string;    type: 'number';    value: number;    unit?: string;}

export interface NumberVariable {    type: 'number';    value: number | string;    numeric?: MasterCSSManifestVariableNumericValue;}

export type ResolvedVariableValue = StringVariable | NumberVariable;

export interface SeparatorValueComponent {    text?: string;    token: string;    type: 'separator';    value: string;}

export interface StringValueComponent {    text?: string;    token: string;    type: 'string';    value: string;}

export interface StringVariable {    type: 'string';    value: string | number;}

export type ValueComponent = StringValueComponent | NumberValueComponent | FunctionValueComponent | VariableValueComponent | SeparatorValueComponent;

export type Variable = VariableCommon & {    type: ResolvedVariableValue['type'];    value?: ResolvedVariableValue['value'];    numeric?: MasterCSSManifestVariableNumericValue;};

export interface VariableValueComponent {    text?: string;    token: string;    type: 'variable';    name: string;    alpha?: number;    fallback?: string;    negative?: boolean;    variable?: Variable;}

declare const UtilityType: {    /**     * semantic utility classes     * @example block, inline     */    readonly Semantic: -2;    /**     * shorthand     * @example border, padding, margin     */    readonly Shorthand: -1;    /**     * normal     * @example grid-cols     */    readonly Normal: 0;};export type UtilityType = typeof UtilityType[keyof typeof UtilityType];

declare const MASTER_CSS_RUNTIME_STYLE_ID: "master-css";

export interface MasterCSSEmittedGlobals {    variables?: Record<string, number>;    animations?: Record<string, number>;}

export declare function isNativeCSSShorthandProperty(property: string): boolean;

export type Vendors = 'webkit' | 'moz' | 'ms' | 'o';

declare const MASTER_CSS_DIAGNOSTIC_VERSION: 2;

export interface MasterCSSDiagnostic {    readonly version: typeof MASTER_CSS_DIAGNOSTIC_VERSION;    readonly code: string;    readonly domain: MasterCSSDiagnosticDomain;    readonly phase?: 'match' | 'css-syntax' | 'css-value' | 'browser-support' | 'compiler';    readonly severity: MasterCSSDiagnosticSeverity;    readonly message: string;    readonly source?: string;    readonly range?: MasterCSSDiagnosticRange;    readonly notes?: readonly string[];    readonly help?: string;}

export type MasterCSSDiagnosticDomain = 'binding' | 'compiler' | 'engine' | 'integration' | 'language' | 'project' | 'runtime' | 'server' | 'tooling';

export interface MasterCSSDiagnosticPosition {    line: number;    character: number;}

export interface MasterCSSDiagnosticRange {    start: MasterCSSDiagnosticPosition;    end: MasterCSSDiagnosticPosition;}

export type MasterCSSDiagnosticSeverity = 'error' | 'warning' | 'information';

export declare class MasterCSSError extends Error {    readonly code: string;    readonly domain: MasterCSSDiagnosticDomain;    readonly diagnostics: readonly MasterCSSDiagnostic[];    readonly payload: MasterCSSErrorPayload;    constructor(payload: MasterCSSErrorPayload, options?: MasterCSSErrorOptions);    toJSON(): MasterCSSErrorPayload;}

export interface MasterCSSErrorOptions extends ErrorOptions {    diagnostics?: readonly MasterCSSDiagnostic[];}

export interface MasterCSSErrorPayload {    readonly code: string;    readonly domain: MasterCSSDiagnosticDomain;    readonly message: string;    readonly diagnostics?: readonly MasterCSSDiagnostic[];}

export declare function isMasterCSSRenderingMode(  value: unknown): value is MasterCSSRenderingMode;

declare const MASTER_CSS_RENDERING_MODES: readonly [    "runtime",    "static",    "pre-render",    "progressive"];

export interface MasterCSSIntegrationOptions {    enabled?: boolean;    mode?: MasterCSSRenderingMode;    pruneNativeCSS?: boolean;    runtime?: boolean | MasterCSSIntegrationRuntimeOptions;}

export interface MasterCSSIntegrationRuntimeOptions {    enabled?: boolean;    avoidFOUC?: boolean;}

export type MasterCSSRenderingMode = typeof MASTER_CSS_RENDERING_MODES[number];