@master/css 2.0.0-rc.68 → 2.0.0-rc.69

package/dist/config/rules.d.ts

@@ -1,1476 +1,1485 @@
-import type { SyntaxRule } from '../syntax-rule';
+import SyntaxRuleType from '../syntax-rule-type';
 declare const rules: {
-    group: {
-        matcher: RegExp;
-        type: -2;
-        analyze(this: SyntaxRule, className: string): [string, string];
-        declare(this: SyntaxRule, value: string): any;
-    };
-    variable: {
-        matcher: RegExp;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            [x: string]: string;
-        };
-    };
     'font-size': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
+        aliasGroups: string[];
+        kind: "number";
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'font-weight': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'font-family': {
-        ambiguousKeys: string[];
-        type: -1;
-    };
-    'font-smoothing': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
-        declare(this: SyntaxRule, value: string): {
-            '-webkit-font-smoothing': "auto";
-            '-moz-osx-font-smoothing': "auto";
-            'font-smooth'?: undefined;
-        } | {
-            '-webkit-font-smoothing': "antialiased";
-            '-moz-osx-font-smoothing': "grayscale";
-            'font-smooth'?: undefined;
-        } | {
-            'font-smooth': string;
-            '-webkit-font-smoothing'?: undefined;
-            '-moz-osx-font-smoothing'?: undefined;
-        };
+        aliasGroups: string[];
+        type: SyntaxRuleType.Native;
+    };
+    'font-smooth': {
+        type: SyntaxRuleType.Native;
     };
     'font-style': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
         unit: string;
     };
     'font-variant-numeric': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'font-variant': {
-        ambiguousKeys: string[];
-        type: -3;
+        aliasGroups: string[];
+        type: SyntaxRuleType.NativeShorthand;
     };
     font: {
         subkey: string;
-        type: -3;
-        variables: string[];
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
     };
     'font-feature-settings': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     color: {
         key: string;
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'margin-left': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'margin-right': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'margin-top': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'margin-bottom': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'margin-x': {
         key: string;
         subkey: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'margin-left': string;
-            'margin-right': string;
-        };
-        variables: string[];
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("margin-left" | "margin-right")[];
+        namespaces: string[];
     };
     'margin-y': {
         key: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'margin-top': string;
-            'margin-bottom': string;
-        };
-        variables: string[];
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("margin-top" | "margin-bottom")[];
+        namespaces: string[];
     };
     margin: {
         key: string;
         unit: string;
-        type: -3;
-        variables: string[];
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
     };
     'margin-inline-start': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'margin-inline-end': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'margin-inline': {
         key: string;
         unit: string;
-        type: -3;
-        variables: string[];
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
     };
     'padding-left': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'padding-right': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'padding-top': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'padding-bottom': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'padding-x': {
         key: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'padding-left': string;
-            'padding-right': string;
-        };
-        variables: string[];
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("padding-left" | "padding-right")[];
+        namespaces: string[];
     };
     'padding-y': {
         key: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'padding-top': string;
-            'padding-bottom': string;
-        };
-        variables: string[];
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("padding-bottom" | "padding-top")[];
+        namespaces: string[];
     };
     padding: {
         key: string;
         unit: string;
-        type: -3;
-        variables: string[];
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
     };
     'padding-inline-start': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'padding-inline-end': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'padding-inline': {
         key: string;
         unit: string;
-        type: -3;
-        variables: string[];
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
     };
     'flex-basis': {
-        ambiguousKeys: string[];
+        aliasGroups: string[];
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'flex-wrap': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'flex-grow': {
-        ambiguousKeys: string[];
-        type: -1;
+        aliasGroups: string[];
+        type: SyntaxRuleType.Native;
     };
     'flex-shrink': {
-        ambiguousKeys: string[];
-        type: -1;
+        aliasGroups: string[];
+        type: SyntaxRuleType.Native;
     };
     'flex-direction': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     flex: {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     display: {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     width: {
         key: string;
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     height: {
         key: string;
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'min-width': {
         key: string;
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'min-height': {
         key: string;
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     size: {
-        type: -2;
+        type: SyntaxRuleType.Shorthand;
         unit: string;
-        declare(this: SyntaxRule, _value: string, valueComponents: import("..").ValueComponent[]): {
-            width: string | undefined;
-            height: string | undefined;
-        };
+        declarer: ["pair", string[]];
     };
     'min-size': {
         key: string;
-        type: -2;
+        type: SyntaxRuleType.Shorthand;
         unit: string;
-        declare(this: SyntaxRule, _value: string, valueComponents: import("..").ValueComponent[]): {
-            'min-width': string | undefined;
-            'min-height': string | undefined;
-        };
+        declarer: ["pair", string[]];
     };
     'max-size': {
         key: string;
-        type: -2;
+        type: SyntaxRuleType.Shorthand;
         unit: string;
-        declare(this: SyntaxRule, _value: string, valueComponents: import("..").ValueComponent[]): {
-            'max-width': string | undefined;
-            'max-height': string | undefined;
-        };
+        declarer: ["pair", string[]];
     };
     'box-sizing': {
-        ambiguousKeys: string[];
-        type: -1;
+        aliasGroups: string[];
+        type: SyntaxRuleType.Native;
     };
     'box-decoration-break': {
         key: string;
-        type: -1;
-        declare(this: SyntaxRule, value: string): any;
+        type: SyntaxRuleType.Native;
+        declarations: ("box-decoration-break" | "-webkit-box-decoration-break")[];
     };
     container: {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'container-name': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'container-type': {
-        type: -1;
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
+        type: SyntaxRuleType.Native;
+        aliasGroups: string[];
+        values: string[];
     };
     contain: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     content: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'counter-increment': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'counter-reset': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'letter-spacing': {
         key: string;
         subkey: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
     };
     'line-height': {
         key: string;
         subkey: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'object-fit': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'object-position': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'text-align': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'text-decoration-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
-        variables: string[];
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'text-decoration-style': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'text-decoration-thickness': {
-        ambiguousKeys: string[];
-        ambiguousValues: (string | RegExp)[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        kind: "number";
+        type: SyntaxRuleType.Native;
         unit: string;
     };
     'text-decoration-line': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'text-decoration': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        unit: string;
-        type: -3;
-        variables: string[];
-        declare(this: SyntaxRule, value: string): {
-            '-webkit-text-decoration': string;
-            'text-decoration': string;
-        };
+        aliasGroups: string[];
+        values: string[];
+        unit: string;
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
+        declarations: ("-webkit-text-decoration" | "text-decoration")[];
     };
     'text-underline-offset': {
-        ambiguousKeys: string[];
+        aliasGroups: string[];
         unit: string;
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'text-underline-position': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'text-overflow': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'text-orientation': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'text-transform': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'text-rendering': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'text-wrap': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -3;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.NativeShorthand;
     };
     'text-indent': {
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'vertical-align': {
         key: string;
         subkey: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     columns: {
         key: string;
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'overflow-wrap': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'white-space': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     top: {
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     bottom: {
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     left: {
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     right: {
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     inset: {
         unit: string;
-        type: -3;
-        variables: string[];
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
     };
     'max-height': {
         key: string;
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'max-width': {
         key: string;
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     opacity: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     visibility: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     clear: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     float: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     isolation: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'overflow-x': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'overflow-y': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     overflow: {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'overscroll-behavior-x': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'overscroll-behavior-y': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'overscroll-behavior': {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'z-index': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     position: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     cursor: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'pointer-events': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     resize: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'touch-action': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'word-break': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'word-spacing': {
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
     };
     hyphens: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'user-drag': {
-        type: -1;
-        declare(this: SyntaxRule, value: string): any;
+        type: SyntaxRuleType.Native;
+        declarations: ("-webkit-user-drag" | "user-drag")[];
     };
     'user-select': {
-        type: -1;
-        declare(this: SyntaxRule, value: string): any;
+        type: SyntaxRuleType.Native;
+        declarations: ("user-select" | "-webkit-user-select")[];
     };
     'text-shadow': {
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'text-size': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
+        aliasGroups: string[];
+        kind: "number";
         unit: string;
-        declare(this: SyntaxRule, value: string): {
-            'font-size': string;
-            'line-height': `calc(${string} + 0.875em)`;
+        declarations: {
+            'font-size': undefined;
+            'line-height': (string | undefined)[];
+            'letter-spacing': (string | undefined)[];
         };
-        type: -2;
+        type: SyntaxRuleType.Shorthand;
+        namespaces: string[];
     };
     'text-fill-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
-        variables: string[];
-        declare(this: SyntaxRule, value: string): {
-            '-webkit-text-fill-color': string;
-        };
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
+        declarations: "-webkit-text-fill-color"[];
     };
     'text-stroke-width': {
-        ambiguousKeys: string[];
-        ambiguousValues: (string | RegExp)[];
+        aliasGroups: string[];
+        values: string[];
+        kind: "number";
         unit: string;
-        type: -1;
-        declare(this: SyntaxRule, value: string): {
-            '-webkit-text-stroke-width': string;
-        };
+        type: SyntaxRuleType.Native;
+        declarations: "-webkit-text-stroke-width"[];
     };
     'text-stroke-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
-        declare(this: SyntaxRule, value: string): {
-            '-webkit-text-stroke-color': string;
-        };
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.Native;
+        declarations: "-webkit-text-stroke-color"[];
+        namespaces: string[];
     };
     'text-stroke': {
         unit: string;
-        type: -1;
-        declare(this: SyntaxRule, value: string): {
-            '-webkit-text-stroke': string;
-        };
+        type: SyntaxRuleType.Native;
+        declarations: "-webkit-text-stroke"[];
     };
     'text-truncate': {
         subkey: string;
-        declare(this: SyntaxRule, value: string): {
+        declarations: {
             display: "-webkit-box";
             '-webkit-box-orient': "vertical";
-            '-webkit-line-clamp': string;
+            '-webkit-line-clamp': undefined;
             overflow: "hidden";
             'overflow-wrap': "break-word";
             'text-overflow': "ellipsis";
         };
-        type: -2;
+        type: SyntaxRuleType.Shorthand;
     };
     'box-shadow': {
         key: string;
         subkey: string;
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'table-layout': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'transform-box': {
-        ambiguousKeys: string[];
-        type: -1;
+        aliasGroups: string[];
+        type: SyntaxRuleType.Native;
     };
     'transform-style': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'transform-origin': {
-        ambiguousKeys: string[];
-        ambiguousValues: (string | RegExp)[];
+        aliasGroups: string[];
+        values: string[];
+        kind: "number";
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     transform: {
-        matcher: RegExp;
-        type: -1;
-        analyze(this: SyntaxRule, className: string): [string];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
+    };
+    'translate()': {
+        declarations: "transform"[];
+        unit: string;
+        namespaces: string[];
+    };
+    'translateX()': {
+        declarations: "transform"[];
+        unit: string;
+        namespaces: string[];
+    };
+    'translateY()': {
+        declarations: "transform"[];
+        unit: string;
+        namespaces: string[];
+    };
+    'translateZ()': {
+        declarations: "transform"[];
+        unit: string;
+        namespaces: string[];
+    };
+    'translate3d()': {
+        declarations: "transform"[];
         unit: string;
-        variables: string[];
+        namespaces: string[];
+    };
+    'scale()': {
+        declarations: "transform"[];
+    };
+    'scaleX()': {
+        declarations: "transform"[];
+    };
+    'scaleY()': {
+        declarations: "transform"[];
+    };
+    'scaleZ()': {
+        declarations: "transform"[];
+    };
+    'scale3d()': {
+        declarations: "transform"[];
+    };
+    'rotate()': {
+        declarations: "transform"[];
+    };
+    'rotateX()': {
+        declarations: "transform"[];
+    };
+    'rotateY()': {
+        declarations: "transform"[];
+    };
+    'rotateZ()': {
+        declarations: "transform"[];
+    };
+    'rotate3d()': {
+        declarations: "transform"[];
+    };
+    'perspective()': {
+        declarations: "transform"[];
+    };
+    'matrix()': {
+        declarations: "transform"[];
+    };
+    'matrix3d()': {
+        declarations: "transform"[];
     };
     'transition-property': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'transition-timing-function': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'transition-duration': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
     };
     'transition-delay': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
     };
     transition: {
         sign: string;
-        analyze(this: SyntaxRule, className: string): [string];
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'animation-delay': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
     };
     'animation-direction': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'animation-duration': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
     };
     'animation-fill-mode': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'animation-iteration-count': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'animation-name': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         includeAnimations: true;
     };
     'animation-play-state': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'animation-timing-function': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     animation: {
         sign: string;
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
         includeAnimations: true;
-        analyze(this: SyntaxRule, className: string): [string];
     };
     'border-collapse': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'border-spacing': {
         unit: string;
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'border-top-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
-        variables: string[];
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'border-bottom-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
-        variables: string[];
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'border-left-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
-        variables: string[];
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'border-right-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
-        variables: string[];
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'border-x-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -2;
-        variables: string[];
-        declare(this: SyntaxRule, value: string): {
-            'border-left-color': string;
-            'border-right-color': string;
-        };
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.Shorthand;
+        namespaces: string[];
+        declarations: ("border-left-color" | "border-right-color")[];
     };
     'border-y-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -2;
-        variables: string[];
-        declare(this: SyntaxRule, value: string): {
-            'border-top-color': string;
-            'border-bottom-color': string;
-        };
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.Shorthand;
+        namespaces: string[];
+        declarations: ("border-bottom-color" | "border-top-color")[];
     };
     'border-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -3;
-        variables: string[];
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
     };
     'border-top-left-radius': {
         key: string;
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'border-top-right-radius': {
         key: string;
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'border-bottom-left-radius': {
         key: string;
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'border-bottom-right-radius': {
         key: string;
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'border-top-radius': {
         key: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'border-top-left-radius': string;
-            'border-top-right-radius': string;
-        };
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("border-top-left-radius" | "border-top-right-radius")[];
+        namespaces: string[];
     };
     'border-bottom-radius': {
         key: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'border-bottom-left-radius': string;
-            'border-bottom-right-radius': string;
-        };
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("border-bottom-left-radius" | "border-bottom-right-radius")[];
+        namespaces: string[];
     };
     'border-left-radius': {
         key: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'border-top-left-radius': string;
-            'border-bottom-left-radius': string;
-        };
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("border-bottom-left-radius" | "border-top-left-radius")[];
+        namespaces: string[];
     };
     'border-right-radius': {
         key: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'border-top-right-radius': string;
-            'border-bottom-right-radius': string;
-        };
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("border-bottom-right-radius" | "border-top-right-radius")[];
+        namespaces: string[];
     };
     'border-radius': {
         key: string;
         unit: string;
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'border-top-style': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'border-bottom-style': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'border-left-style': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'border-right-style': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'border-x-style': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -2;
-        declare(this: SyntaxRule, value: string): any;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("border-left-style" | "border-right-style")[];
     };
     'border-y-style': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -2;
-        declare(this: SyntaxRule, value: string): any;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("border-bottom-style" | "border-top-style")[];
     };
     'border-style': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -3;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.NativeShorthand;
     };
     'border-top-width': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
+        aliasGroups: string[];
+        kind: "number";
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'border-bottom-width': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
+        aliasGroups: string[];
+        kind: "number";
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'border-left-width': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
+        aliasGroups: string[];
+        kind: "number";
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'border-right-width': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
+        aliasGroups: string[];
+        kind: "number";
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'border-x-width': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
+        aliasGroups: string[];
+        kind: "number";
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'border-left-width': string;
-            'border-right-width': string;
-        };
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("border-left-width" | "border-right-width")[];
     };
     'border-y-width': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
+        aliasGroups: string[];
+        kind: "number";
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'border-top-width': string;
-            'border-bottom-width': string;
-        };
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("border-bottom-width" | "border-top-width")[];
     };
     'border-width': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
+        aliasGroups: string[];
+        kind: "number";
         unit: string;
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'border-image-repeat': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'border-image-slice': {
-        ambiguousKeys: string[];
-        type: -1;
+        aliasGroups: string[];
+        type: SyntaxRuleType.Native;
     };
     'border-image-source': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
+        aliasGroups: string[];
+        kind: "image";
+        type: SyntaxRuleType.Native;
     };
     'border-image-width': {
-        ambiguousKeys: string[];
-        ambiguousValues: (string | RegExp)[];
+        aliasGroups: string[];
+        values: string[];
+        kind: "number";
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'border-image-outset': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
+        aliasGroups: string[];
+        kind: "number";
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'border-image': {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'border-top': {
         key: string;
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
         unit: string;
-        transformValueComponents: ((this: SyntaxRule, valueComponents: import("..").ValueComponent[]) => import("..").ValueComponent[]) | undefined;
-        variables: string[];
+        transformer: "auto-fill-solid";
+        namespaces: string[];
     };
     'border-bottom': {
         key: string;
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
         unit: string;
-        transformValueComponents: ((this: SyntaxRule, valueComponents: import("..").ValueComponent[]) => import("..").ValueComponent[]) | undefined;
-        variables: string[];
+        transformer: "auto-fill-solid";
+        namespaces: string[];
     };
     'border-left': {
         key: string;
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
         unit: string;
-        transformValueComponents: ((this: SyntaxRule, valueComponents: import("..").ValueComponent[]) => import("..").ValueComponent[]) | undefined;
-        variables: string[];
+        transformer: "auto-fill-solid";
+        namespaces: string[];
     };
     'border-right': {
         key: string;
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
         unit: string;
-        transformValueComponents: ((this: SyntaxRule, valueComponents: import("..").ValueComponent[]) => import("..").ValueComponent[]) | undefined;
-        variables: string[];
+        transformer: "auto-fill-solid";
+        namespaces: string[];
     };
     'border-x': {
         key: string;
         unit: string;
-        type: -2;
-        transformValueComponents: ((this: SyntaxRule, valueComponents: import("..").ValueComponent[]) => import("..").ValueComponent[]) | undefined;
-        variables: string[];
-        declare(this: SyntaxRule, value: string): {
-            'border-left': string;
-            'border-right': string;
-        };
+        type: SyntaxRuleType.Shorthand;
+        transformer: "auto-fill-solid";
+        namespaces: string[];
+        declarations: ("border-left" | "border-right")[];
     };
     'border-y': {
         key: string;
         unit: string;
-        type: -2;
-        transformValueComponents: ((this: SyntaxRule, valueComponents: import("..").ValueComponent[]) => import("..").ValueComponent[]) | undefined;
-        variables: string[];
-        declare(this: SyntaxRule, value: string): {
-            'border-top': string;
-            'border-bottom': string;
-        };
+        type: SyntaxRuleType.Shorthand;
+        transformer: "auto-fill-solid";
+        namespaces: string[];
+        declarations: ("border-bottom" | "border-top")[];
     };
     border: {
         key: string;
         unit: string;
-        type: -3;
-        transformValueComponents: ((this: SyntaxRule, valueComponents: import("..").ValueComponent[]) => import("..").ValueComponent[]) | undefined;
-        variables: string[];
+        type: SyntaxRuleType.NativeShorthand;
+        transformer: "auto-fill-solid";
+        namespaces: string[];
     };
     'background-attachment': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'background-blend-mode': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'background-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'background-clip': {
         key: string;
-        type: -1;
-        declare(this: SyntaxRule, value: string): {
-            '-webkit-background-clip': string;
-            'background-clip': string;
-        };
+        type: SyntaxRuleType.Native;
     };
     'background-origin': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'background-position': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
         unit: string;
     };
     'background-repeat': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'background-size': {
-        ambiguousKeys: string[];
-        ambiguousValues: (string | RegExp)[];
+        aliasGroups: string[];
+        values: string[];
+        kind: "number";
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'background-image': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
+        aliasGroups: string[];
+        kind: "image";
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     background: {
         key: string;
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
     };
-    gradient: {
-        matcher: RegExp;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'background-image': string;
+    'gradient()': {
+        declarations: {
+            'background-image': (string | undefined)[];
         };
+        namespaces: string[];
     };
     'mix-blend-mode': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'backdrop-filter': {
         key: string;
-        type: -1;
-        declare(this: SyntaxRule, value: string): {
-            '-webkit-backdrop-filter': string;
-            'backdrop-filter': string;
-        };
+        type: SyntaxRuleType.Native;
+        declarations: ("backdrop-filter" | "-webkit-backdrop-filter")[];
+        namespaces: string[];
     };
     filter: {
-        matcher: RegExp;
-        type: -1;
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
+    };
+    'blur()': {
+        declarations: "filter"[];
+    };
+    'brightness()': {
+        declarations: "filter"[];
+    };
+    'contrast()': {
+        declarations: "filter"[];
+    };
+    'drop-shadow()': {
+        declarations: "filter"[];
+        namespaces: string[];
+    };
+    'grayscale()': {
+        declarations: "filter"[];
+    };
+    'hue-rotate()': {
+        declarations: "filter"[];
+    };
+    'invert()': {
+        declarations: "filter"[];
+    };
+    'opacity()': {
+        declarations: "filter"[];
+    };
+    'saturate()': {
+        declarations: "filter"[];
+    };
+    'sepia()': {
+        declarations: "filter"[];
     };
     fill: {
-        type: -1;
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'stroke-dasharray': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'stroke-dashoffset': {
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'stroke-width': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
+        aliasGroups: string[];
+        kind: "number";
+        type: SyntaxRuleType.Native;
     };
     stroke: {
-        type: -1;
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     x: {
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     y: {
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     cx: {
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     cy: {
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     rx: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     ry: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'grid-column-start': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'grid-column-end': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'grid-column-span': {
         key: string;
-        type: -2;
-        transformValue(this: SyntaxRule, value: string): string;
-        declare(this: SyntaxRule, value: string): {
-            'grid-column': string;
+        type: SyntaxRuleType.Shorthand;
+        declarations: {
+            'grid-column': (string | undefined)[];
         };
     };
     'grid-column': {
         key: string;
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'grid-columns': {
         key: string;
-        declare(this: SyntaxRule, value: string): {
+        declarations: {
             display: "grid";
-            'grid-template-columns': string;
+            'grid-template-columns': (string | undefined)[];
         };
-        type: -2;
+        type: SyntaxRuleType.Shorthand;
     };
     'grid-row-start': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'grid-row-end': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'grid-row-span': {
-        type: -2;
-        transformValue(this: SyntaxRule, value: string): string;
-        declare(this: SyntaxRule, value: string): {
-            'grid-row': string;
+        type: SyntaxRuleType.Shorthand;
+        declarations: {
+            'grid-row': (string | undefined)[];
         };
     };
     'grid-row': {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'grid-rows': {
-        declare(this: SyntaxRule, value: string): {
+        declarations: {
             display: "grid";
             'grid-auto-flow': "column";
-            'grid-template-rows': string;
+            'grid-template-rows': (string | undefined)[];
         };
-        type: -2;
+        type: SyntaxRuleType.Shorthand;
     };
     'grid-auto-columns': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'grid-auto-flow': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'grid-auto-rows': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'grid-template-areas': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'grid-template-columns': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
     };
     'grid-template-rows': {
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
     };
     'grid-template': {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'grid-area': {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     grid: {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'column-gap': {
         key: string;
         unit: string;
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'row-gap': {
         key: string;
         unit: string;
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     gap: {
         unit: string;
-        type: -3;
-        variables: string[];
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
     };
     order: {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'break-inside': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'break-before': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'break-after': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'aspect-ratio': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'column-span': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'align-content': {
         subkey: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'align-items': {
         subkey: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'align-self': {
         subkey: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'justify-content': {
         subkey: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'justify-items': {
         subkey: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'justify-self': {
         subkey: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'place-content': {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'place-items': {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'place-self': {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'list-style-position': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'list-style-type': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'list-style-image': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
+        aliasGroups: string[];
+        kind: "image";
+        type: SyntaxRuleType.Native;
     };
     'list-style': {
-        type: -3;
+        type: SyntaxRuleType.NativeShorthand;
     };
     'outline-color': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
-        variables: string[];
+        aliasGroups: string[];
+        kind: "color";
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'outline-offset': {
         unit: string;
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'outline-style': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'outline-width': {
-        ambiguousKeys: string[];
-        ambiguousValues: (string | RegExp)[];
+        aliasGroups: string[];
+        values: string[];
+        kind: "number";
         unit: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     outline: {
         unit: string;
-        type: -3;
-        variables: string[];
-        transformValueComponents: ((this: SyntaxRule, valueComponents: import("..").ValueComponent[]) => import("..").ValueComponent[]) | undefined;
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
+        transformer: "auto-fill-solid";
     };
     'accent-color': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     appearance: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'caret-color': {
         key: string;
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'scroll-behavior': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'scroll-margin-left': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'scroll-margin-right': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'scroll-margin-top': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'scroll-margin-bottom': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'scroll-margin-x': {
         key: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'scroll-margin-left': string;
-            'scroll-margin-right': string;
-        };
-        variables: string[];
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("scroll-margin-left" | "scroll-margin-right")[];
+        namespaces: string[];
     };
     'scroll-margin-y': {
         key: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'scroll-margin-top': string;
-            'scroll-margin-bottom': string;
-        };
-        variables: string[];
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("scroll-margin-bottom" | "scroll-margin-top")[];
+        namespaces: string[];
     };
     'scroll-margin': {
         key: string;
         unit: string;
-        type: -3;
-        variables: string[];
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
     };
     'scroll-padding-left': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'scroll-padding-right': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'scroll-padding-top': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'scroll-padding-bottom': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
         unit: string;
-        variables: string[];
+        namespaces: string[];
     };
     'scroll-padding-x': {
         key: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'scroll-padding-left': string;
-            'scroll-padding-right': string;
-        };
-        variables: string[];
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("scroll-padding-left" | "scroll-padding-right")[];
+        namespaces: string[];
     };
     'scroll-padding-y': {
         key: string;
         unit: string;
-        type: -2;
-        declare(this: SyntaxRule, value: string): {
-            'scroll-padding-top': string;
-            'scroll-padding-bottom': string;
-        };
-        variables: string[];
+        type: SyntaxRuleType.Shorthand;
+        declarations: ("scroll-padding-bottom" | "scroll-padding-top")[];
+        namespaces: string[];
     };
     'scroll-padding': {
         key: string;
         unit: string;
-        type: -3;
-        variables: string[];
+        type: SyntaxRuleType.NativeShorthand;
+        namespaces: string[];
     };
     'scroll-snap-align': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'scroll-snap-stop': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'scroll-snap-type': {
-        ambiguousKeys: string[];
-        ambiguousValues: string[];
-        type: -1;
+        aliasGroups: string[];
+        values: string[];
+        type: SyntaxRuleType.Native;
     };
     'will-change': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'writing-mode': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     direction: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'shape-outside': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
-        type: -1;
+        key: string;
+        type: SyntaxRuleType.Native;
     };
     'shape-margin': {
-        ambiguousKeys: string[];
-        ambiguousValues: RegExp[];
+        kind: "number";
         unit: string;
-        type: -1;
-        variables: string[];
+        type: SyntaxRuleType.Native;
+        namespaces: string[];
     };
     'shape-image-threshold': {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'clip-path': {
         key: string;
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     quotes: {
-        type: -1;
+        type: SyntaxRuleType.Native;
     };
     'mask-image': {
-        type: -1;
-        declare(this: SyntaxRule, value: string): {
-            '-webkit-mask-image': string;
-            'mask-image': string;
-        };
+        type: SyntaxRuleType.Native;
+        declarations: ("mask-image" | "-webkit-mask-image")[];
+    };
+    group: {
+        matcher: string;
+        type: SyntaxRuleType.Shorthand;
+        declarer: "core.group";
+    };
+    variable: {
+        matcher: string;
+        type: SyntaxRuleType.Shorthand;
+        declarer: "core.variable";
     };
 };
 export default rules;