@roblawn/devtool-runtime 0.1.0-alpha.0

package/dist/schema/LayoutDefinitionMeta.d.ts

@@ -0,0 +1,54 @@
+import type { BindingEditorPolicy } from './LayoutBindingEditorPolicyMetadata.js';
+import type { BindingEditorSection } from './LayoutBindingEditorSectionMetadata.js';
+import type { LayoutFieldUiMeta } from './LayoutFieldUiMetadata.js';
+export type LayoutFieldAuthoringNumberValue = {
+    kind: 'number';
+    min?: number;
+    max?: number;
+    step?: number;
+};
+export type LayoutFieldAuthoringMeta = {
+    sourceKind: 'coreToken';
+    ops: string[];
+    surface: 'css' | 'responsive';
+} | {
+    sourceKind: 'declaredToken';
+    designOp?: string;
+    tokenFamily?: string;
+} | {
+    sourceKind: 'enum';
+} | {
+    sourceKind: 'boolean';
+} | {
+    sourceKind: 'valueBoolean';
+} | {
+    sourceKind: 'valueString';
+} | {
+    sourceKind: 'valueNumber';
+    designOp?: string;
+    tokenFamily?: string;
+    surface?: 'css' | 'responsive';
+    authoringValue?: LayoutFieldAuthoringNumberValue;
+} | {
+    sourceKind: 'valueEnum';
+    designOp?: string;
+    tokenFamily?: string;
+} | {
+    sourceKind: 'wrapper';
+} | {
+    sourceKind: 'style';
+};
+export type LayoutFieldDefinitionMeta = {
+    ui?: LayoutFieldUiMeta;
+    authoring?: LayoutFieldAuthoringMeta;
+};
+export type LayoutBindingDefinitionMeta = {
+    editorPolicy?: BindingEditorPolicy;
+    editorSection?: BindingEditorSection;
+    collapsible?: boolean;
+    collapsed?: boolean;
+};
+export type LayoutDefinitionMeta = {
+    binding?: LayoutBindingDefinitionMeta;
+    fields?: Record<string, LayoutFieldDefinitionMeta>;
+};

package/dist/schema/LayoutDefinitionMeta.js

@@ -0,0 +1 @@
+export {};

package/dist/schema/LayoutFieldIntentMetadata.d.ts

@@ -0,0 +1,22 @@
+import type { AuthoringEffectKind } from '../authoring/index.js';
+import type { z } from 'zod';
+export type LayoutFieldIntentSourceKind = 'coreToken' | 'declaredToken' | 'enum' | 'boolean' | 'valueBoolean' | 'valueString' | 'valueNumber' | 'valueEnum' | 'wrapper' | 'style';
+export type LayoutFieldIntent = {
+    sourceKind: LayoutFieldIntentSourceKind;
+    ops?: string[];
+    tokenFamily?: string;
+    designOp?: string;
+    surface?: 'css' | 'responsive';
+    effectKinds?: AuthoringEffectKind[];
+    authoringValue?: {
+        kind: 'number';
+        min?: number;
+        max?: number;
+        step?: number;
+    };
+};
+export type LayoutFieldIntentMap = Record<string, LayoutFieldIntent>;
+export declare function annotateLayoutFieldIntent<TSchema extends z.ZodTypeAny>(schema: TSchema, intent: LayoutFieldIntent): TSchema;
+export declare function annotateLayoutFieldIntents<TSchema extends z.ZodTypeAny>(schema: TSchema, intents: LayoutFieldIntentMap): TSchema;
+export declare function getLayoutFieldIntent(schema: unknown): LayoutFieldIntent | null;
+export declare function getLayoutFieldIntents(schema: unknown): LayoutFieldIntentMap | null;

package/dist/schema/LayoutFieldIntentMetadata.js

@@ -0,0 +1,38 @@
+const LAYOUT_FIELD_INTENT_META_KEY = Symbol.for('devtool-runtime:layout-field-intent');
+const LAYOUT_FIELD_INTENT_MAP_META_KEY = Symbol.for('devtool-runtime:layout-field-intent-map');
+export function annotateLayoutFieldIntent(schema, intent) {
+    const maybeDef = schema._def;
+    if (maybeDef) {
+        maybeDef[LAYOUT_FIELD_INTENT_META_KEY] = intent;
+    }
+    return schema;
+}
+export function annotateLayoutFieldIntents(schema, intents) {
+    const maybeDef = schema._def;
+    if (maybeDef) {
+        maybeDef[LAYOUT_FIELD_INTENT_MAP_META_KEY] = intents;
+    }
+    return schema;
+}
+export function getLayoutFieldIntent(schema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const def = schema._def;
+    if (!def)
+        return null;
+    const intent = def[LAYOUT_FIELD_INTENT_META_KEY];
+    if (!intent || typeof intent !== 'object')
+        return null;
+    return intent;
+}
+export function getLayoutFieldIntents(schema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const def = schema._def;
+    if (!def)
+        return null;
+    const intents = def[LAYOUT_FIELD_INTENT_MAP_META_KEY];
+    if (!intents || typeof intents !== 'object')
+        return null;
+    return intents;
+}

package/dist/schema/LayoutFieldUiMetadata.d.ts

@@ -0,0 +1,30 @@
+import type { z } from 'zod';
+import type { BindingEditorSectionKey } from './LayoutBindingEditorSectionMetadata.js';
+export type LayoutFieldUiPrimitive = string | number | boolean;
+export type LayoutFieldUiCondition = {
+    field: string;
+    operator: 'truthy';
+} | {
+    field: string;
+    operator: 'falsy';
+} | {
+    field: string;
+    operator: 'equals';
+    value: LayoutFieldUiPrimitive;
+} | {
+    field: string;
+    operator: 'notEquals';
+    value: LayoutFieldUiPrimitive;
+} | {
+    field: string;
+    operator: 'in';
+    value: LayoutFieldUiPrimitive[];
+};
+export type LayoutFieldUiMeta = {
+    label?: string;
+    description?: string;
+    dependsOn?: LayoutFieldUiCondition[];
+    section?: BindingEditorSectionKey;
+};
+export declare function annotateLayoutFieldUiMeta<TSchema extends z.ZodTypeAny>(schema: TSchema, uiMeta: LayoutFieldUiMeta): TSchema;
+export declare function getLayoutFieldUiMeta(schema: unknown): LayoutFieldUiMeta | null;

package/dist/schema/LayoutFieldUiMetadata.js

@@ -0,0 +1,19 @@
+const LAYOUT_FIELD_UI_META_KEY = Symbol.for('devtool-runtime:layout-field-ui-meta');
+export function annotateLayoutFieldUiMeta(schema, uiMeta) {
+    const maybeDef = schema._def;
+    if (maybeDef) {
+        maybeDef[LAYOUT_FIELD_UI_META_KEY] = uiMeta;
+    }
+    return schema;
+}
+export function getLayoutFieldUiMeta(schema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const def = schema._def;
+    if (!def)
+        return null;
+    const uiMeta = def[LAYOUT_FIELD_UI_META_KEY];
+    if (!uiMeta || typeof uiMeta !== 'object')
+        return null;
+    return uiMeta;
+}

package/dist/schema/LayoutSchema.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import type { LayoutDefinitionMeta } from './LayoutDefinitionMeta.js';
+export type LayoutClassOutput = string | string[];
+export type OneArgResolver<TProps> = (layout: TProps) => LayoutClassOutput;
+export type LayoutResolvers<TProps> = Record<string, OneArgResolver<TProps>>;
+export type LayoutValue = boolean | number | string;
+export type OneArgValueResolver<TProps, TValue extends LayoutValue = LayoutValue> = (layout: TProps) => TValue;
+export type LayoutValues<TProps> = Record<string, OneArgValueResolver<TProps, LayoutValue>>;
+export type InferLayoutProps<T> = T extends {
+    __propsBrand?: infer P;
+} ? P : never;
+type ResolveAllResult<TResolvers extends Record<string, unknown>> = {
+    [K in keyof TResolvers]: string[];
+};
+type ResolveValuesResult<TValues extends Record<string, (...args: any[]) => unknown>> = {
+    [K in keyof TValues]: ReturnType<TValues[K]>;
+};
+export declare function defineLayout<TSchema extends z.ZodTypeAny, TResolvers extends LayoutResolvers<z.infer<TSchema>>, TValues extends LayoutValues<z.infer<TSchema>>>(config: {
+    schema: TSchema;
+    resolvers: TResolvers;
+    values?: TValues;
+    meta?: LayoutDefinitionMeta;
+}): {
+    schema: TSchema;
+    resolve: TResolvers;
+    resolveAll: (layout: z.infer<TSchema>) => ResolveAllResult<TResolvers>;
+    check: (layout: z.infer<TSchema>, opts?: {
+        strict?: boolean;
+    }) => {
+        issues: string[];
+        byKey: ResolveAllResult<TResolvers>;
+    };
+    values: TValues;
+    resolveValues: (layout: z.infer<TSchema>) => ResolveValuesResult<TValues>;
+    meta?: LayoutDefinitionMeta;
+    __propsBrand: z.infer<TSchema>;
+};
+export { useWrapper, getWrapperMeta, useStyle, getStyleMeta } from './LayoutVariantBindings.js';
+export type { LayoutDefinitionMeta } from './LayoutDefinitionMeta.js';

package/dist/schema/LayoutSchema.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export function defineLayout(config) {
+    const { schema, resolvers, values, meta } = config;
+    function toArray(v) {
+        return (Array.isArray(v) ? v : [v]).map((s) => s.trim()).filter(Boolean);
+    }
+    function resolveAll(layout) {
+        const out = {};
+        for (const key in resolvers) {
+            const fn = resolvers[key];
+            out[key] = toArray(fn(layout));
+        }
+        return out;
+    }
+    function resolveValues(layout) {
+        if (!values) {
+            return {};
+        }
+        const out = {};
+        for (const key in values) {
+            const fn = values[key];
+            out[key] = fn(layout);
+        }
+        return out;
+    }
+    function check(layout, opts) {
+        const { strict = false } = opts ?? {};
+        const byKey = resolveAll(layout);
+        const issues = [];
+        for (const key in byKey) {
+            for (const cls of byKey[key]) {
+                if (strict && cls === '') {
+                    issues.push(`Resolver "${String(key)}" produced an empty class (strict mode).`);
+                }
+                if (/\s{2,}/.test(cls)) {
+                    issues.push(`Resolver "${String(key)}" produced extra whitespace: "${cls}"`);
+                }
+            }
+        }
+        return { issues, byKey };
+    }
+    return {
+        schema,
+        resolve: resolvers,
+        resolveAll,
+        check,
+        values: (values ?? {}),
+        resolveValues,
+        ...(meta ? { meta } : {}),
+        __propsBrand: null,
+    };
+}
+export { useWrapper, getWrapperMeta, useStyle, getStyleMeta } from './LayoutVariantBindings.js';

package/dist/schema/LayoutVariantBindings.d.ts

@@ -0,0 +1,55 @@
+import { z, type ZodObject, type ZodRawShape, type ZodTypeAny } from 'zod';
+import { type BindingEditorPolicy } from './LayoutBindingEditorPolicyMetadata.js';
+import { type BindingEditorSection } from './LayoutBindingEditorSectionMetadata.js';
+import type { LayoutDefinitionMeta } from './LayoutDefinitionMeta.js';
+export interface WrapperMeta<TPropsSchema extends ZodTypeAny = ZodTypeAny> {
+    name: string;
+    propsSchema: TPropsSchema;
+    layoutMeta?: LayoutDefinitionMeta;
+    editorPolicy?: BindingEditorPolicy;
+    editorSection?: BindingEditorSection;
+    collapsible?: boolean;
+    collapsed?: boolean;
+}
+export interface StyleMeta<TPropsSchema extends ZodTypeAny = ZodTypeAny> {
+    name: string;
+    propsSchema: TPropsSchema;
+    layoutMeta?: LayoutDefinitionMeta;
+    editorPolicy?: BindingEditorPolicy;
+    editorSection?: BindingEditorSection;
+    collapsible?: boolean;
+    collapsed?: boolean;
+}
+type LayoutDefinitionLike<TSchema extends ZodTypeAny> = {
+    schema: TSchema;
+    meta?: LayoutDefinitionMeta;
+};
+export type WrapperBindingSchema<TName extends string, TShape extends ZodRawShape> = z.ZodUnion<[
+    z.ZodObject<{
+        kind: z.ZodLiteral<'wrapper'>;
+        name: z.ZodLiteral<TName>;
+        props: ZodObject<TShape>;
+    }>,
+    z.ZodObject<{
+        kind: z.ZodLiteral<'wrapper'>;
+        name: z.ZodLiteral<TName>;
+        variant: z.ZodString;
+    }>
+]>;
+export type StyleBindingSchema<TName extends string, TSchema extends ZodTypeAny> = z.ZodUnion<[
+    z.ZodObject<{
+        kind: z.ZodLiteral<'style'>;
+        name: z.ZodLiteral<TName>;
+        props: TSchema;
+    }>,
+    z.ZodObject<{
+        kind: z.ZodLiteral<'style'>;
+        name: z.ZodLiteral<TName>;
+        variant: z.ZodString;
+    }>
+]>;
+export declare function useWrapper<TName extends string, TShape extends ZodRawShape>(wrapperName: TName, propsSchemaOrDefinition: ZodObject<TShape> | LayoutDefinitionLike<ZodObject<TShape>>): WrapperBindingSchema<TName, TShape>;
+export declare function useStyle<TName extends string, TSchema extends ZodTypeAny>(styleName: TName, stylePropsSchemaOrDefinition: TSchema | LayoutDefinitionLike<TSchema>): StyleBindingSchema<TName, TSchema>;
+export declare function getWrapperMeta(schema: unknown): WrapperMeta | null;
+export declare function getStyleMeta(schema: unknown): StyleMeta | null;
+export {};

package/dist/schema/LayoutVariantBindings.js

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+import { getBindingEditorPolicy } from './LayoutBindingEditorPolicyMetadata.js';
+import { getBindingEditorSection } from './LayoutBindingEditorSectionMetadata.js';
+const WRAPPER_META_KEY = Symbol.for('devtool-runtime:wrapper');
+const STYLE_META_KEY = Symbol.for('devtool-runtime:style');
+export function useWrapper(wrapperName, propsSchemaOrDefinition) {
+    let definition = null;
+    let propsSchema;
+    if (isLayoutDefinitionLike(propsSchemaOrDefinition)) {
+        definition = propsSchemaOrDefinition;
+        propsSchema = definition.schema;
+    }
+    else {
+        propsSchema = propsSchemaOrDefinition;
+    }
+    if (!/^[A-Za-z0-9_-]+$/.test(wrapperName)) {
+        throw new Error(`[useWrapper] Invalid wrapper name: "${wrapperName}"`);
+    }
+    const localBinding = z.object({
+        kind: z.literal('wrapper'),
+        name: z.literal(wrapperName),
+        props: propsSchema,
+    });
+    const variantBinding = z.object({
+        kind: z.literal('wrapper'),
+        name: z.literal(wrapperName),
+        variant: z.string(),
+    });
+    const bindingSchema = z.union([localBinding, variantBinding]);
+    const editorPolicy = definition?.meta?.binding?.editorPolicy ?? getBindingEditorPolicy(propsSchema) ?? undefined;
+    const editorSection = definition?.meta?.binding?.editorSection ?? getBindingEditorSection(propsSchema) ?? undefined;
+    const collapsible = definition?.meta?.binding?.collapsible;
+    const collapsed = collapsible === true ? definition?.meta?.binding?.collapsed : undefined;
+    const maybeDef = bindingSchema._def;
+    if (maybeDef) {
+        maybeDef[WRAPPER_META_KEY] = {
+            name: wrapperName,
+            propsSchema,
+            ...(definition?.meta ? { layoutMeta: definition.meta } : {}),
+            ...(editorPolicy ? { editorPolicy } : {}),
+            ...(editorSection ? { editorSection } : {}),
+            ...(collapsible !== undefined ? { collapsible } : {}),
+            ...(collapsed !== undefined ? { collapsed } : {}),
+        };
+    }
+    return bindingSchema;
+}
+export function useStyle(styleName, stylePropsSchemaOrDefinition) {
+    let definition = null;
+    let stylePropsSchema;
+    if (isLayoutDefinitionLike(stylePropsSchemaOrDefinition)) {
+        definition = stylePropsSchemaOrDefinition;
+        stylePropsSchema = definition.schema;
+    }
+    else {
+        stylePropsSchema = stylePropsSchemaOrDefinition;
+    }
+    const localBinding = z.object({
+        kind: z.literal('style'),
+        name: z.literal(styleName),
+        props: stylePropsSchema,
+    });
+    const variantBinding = z.object({
+        kind: z.literal('style'),
+        name: z.literal(styleName),
+        variant: z.string(),
+    });
+    const bindingSchema = z.union([localBinding, variantBinding]);
+    const editorPolicy = definition?.meta?.binding?.editorPolicy ?? getBindingEditorPolicy(stylePropsSchema) ?? undefined;
+    const editorSection = definition?.meta?.binding?.editorSection ?? getBindingEditorSection(stylePropsSchema) ?? undefined;
+    const collapsible = definition?.meta?.binding?.collapsible;
+    const collapsed = collapsible === true ? definition?.meta?.binding?.collapsed : undefined;
+    const maybeDef = bindingSchema._def;
+    if (maybeDef) {
+        maybeDef[STYLE_META_KEY] = {
+            name: styleName,
+            propsSchema: stylePropsSchema,
+            ...(definition?.meta ? { layoutMeta: definition.meta } : {}),
+            ...(editorPolicy ? { editorPolicy } : {}),
+            ...(editorSection ? { editorSection } : {}),
+            ...(collapsible !== undefined ? { collapsible } : {}),
+            ...(collapsed !== undefined ? { collapsed } : {}),
+        };
+    }
+    return bindingSchema;
+}
+export function getWrapperMeta(schema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const def = schema._def;
+    if (!def)
+        return null;
+    const meta = def[WRAPPER_META_KEY];
+    return meta ?? null;
+}
+export function getStyleMeta(schema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const def = schema._def;
+    if (!def)
+        return null;
+    const meta = def[STYLE_META_KEY];
+    return meta ?? null;
+}
+function isLayoutDefinitionLike(value) {
+    return typeof value === 'object' && value !== null && 'schema' in value;
+}

package/dist/schema/SlotSchema.d.ts

@@ -0,0 +1,10 @@
+export type SlotConfig = {
+    description?: string;
+    useTabs?: boolean;
+    order?: number;
+};
+export type SlotsSpec = Record<string, SlotConfig>;
+export declare function defineLayoutSlots<const S extends SlotsSpec>(spec: S): S;
+export type ToVueSlots<S extends SlotsSpec> = {
+    [K in keyof S]?: (props: {}) => unknown;
+};

package/dist/schema/SlotSchema.js

@@ -0,0 +1,3 @@
+export function defineLayoutSlots(spec) {
+    return spec;
+}

package/dist/schema/StyleSchema.d.ts

@@ -0,0 +1,16 @@
+import type { Ref } from 'vue';
+export type StyleClassValue = string | Ref<string>;
+export type StyleClassList = string[] | ReadonlyArray<StyleClassValue>;
+export type StyleResolverReturn = StyleClassValue | StyleClassList;
+export type OneArgStyleResolver<TStyle> = (style: TStyle) => StyleResolverReturn;
+export type StyleResolverLike<TStyle> = OneArgStyleResolver<TStyle>;
+export type StyleResolvers<TStyle> = Record<string, StyleResolverLike<TStyle>>;
+export type StyleSetupResolvers = Record<string, StyleResolverLike<any>>;
+export type SetupStyleDefinition<TResolvers extends StyleSetupResolvers = StyleSetupResolvers> = {
+    setup: () => TResolvers;
+    __stylePropsBrand: unknown;
+};
+export type InferStyleProps<T> = T extends {
+    __stylePropsBrand?: infer P;
+} ? P : never;
+export declare function defineStyle<TResolvers extends StyleSetupResolvers>(setup: () => TResolvers): SetupStyleDefinition<TResolvers>;

package/dist/schema/StyleSchema.js

@@ -0,0 +1,6 @@
+export function defineStyle(setup) {
+    return {
+        setup,
+        __stylePropsBrand: null,
+    };
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,9 @@
+export * from './LayoutBindingEditorPolicyMetadata.js';
+export * from './LayoutBindingEditorSectionMetadata.js';
+export * from './LayoutDefinitionMeta.js';
+export * from './LayoutFieldIntentMetadata.js';
+export * from './LayoutFieldUiMetadata.js';
+export * from './LayoutSchema.js';
+export * from './LayoutVariantBindings.js';
+export * from './SlotSchema.js';
+export * from './StyleSchema.js';

package/dist/schema/index.js

@@ -0,0 +1,9 @@
+export * from './LayoutBindingEditorPolicyMetadata.js';
+export * from './LayoutBindingEditorSectionMetadata.js';
+export * from './LayoutDefinitionMeta.js';
+export * from './LayoutFieldIntentMetadata.js';
+export * from './LayoutFieldUiMetadata.js';
+export * from './LayoutSchema.js';
+export * from './LayoutVariantBindings.js';
+export * from './SlotSchema.js';
+export * from './StyleSchema.js';

package/dist/theme-contract/CompositeFieldOpByFamily.d.ts

@@ -0,0 +1,126 @@
+export declare const COMPOSITE_FIELD_SPEC_BY_FAMILY: {
+    readonly border: {
+        readonly color: {
+            readonly defaultOp: "borderColor";
+            readonly targetFamily: "color";
+        };
+        readonly width: {
+            readonly defaultOp: "borderWidth";
+            readonly targetFamily: "borderWidth";
+        };
+        readonly style: {
+            readonly defaultOp: "borderStyle";
+            readonly targetFamily: "borderStyle";
+        };
+    };
+    readonly shadow: {
+        readonly compose: {
+            readonly defaultOp: "shadowCompose";
+            readonly targetFamily: "shadowCompose";
+        };
+        readonly offsetX1: {
+            readonly defaultOp: "shadowX1";
+            readonly targetFamily: "shadowOffset";
+        };
+        readonly offsetY1: {
+            readonly defaultOp: "shadowY1";
+            readonly targetFamily: "shadowOffset";
+        };
+        readonly blur1: {
+            readonly defaultOp: "shadowBlur1";
+            readonly targetFamily: "shadowBlur";
+        };
+        readonly spread1: {
+            readonly defaultOp: "shadowSpread1";
+            readonly targetFamily: "shadowSpread";
+        };
+        readonly opacity1: {
+            readonly defaultOp: "shadowOpacity1";
+            readonly targetFamily: "shadowOpacity";
+        };
+        readonly offsetX2: {
+            readonly defaultOp: "shadowX2";
+            readonly targetFamily: "shadowOffset";
+        };
+        readonly offsetY2: {
+            readonly defaultOp: "shadowY2";
+            readonly targetFamily: "shadowOffset";
+        };
+        readonly blur2: {
+            readonly defaultOp: "shadowBlur2";
+            readonly targetFamily: "shadowBlur";
+        };
+        readonly spread2: {
+            readonly defaultOp: "shadowSpread2";
+            readonly targetFamily: "shadowSpread";
+        };
+        readonly opacity2: {
+            readonly defaultOp: "shadowOpacity2";
+            readonly targetFamily: "shadowOpacity";
+        };
+    };
+    readonly text: {
+        readonly family: {
+            readonly defaultOp: "fontFamily";
+            readonly targetFamily: "font";
+        };
+        readonly size: {
+            readonly defaultOp: "textSize";
+            readonly targetFamily: "textSize";
+        };
+        readonly weight: {
+            readonly defaultOp: "fontWeight";
+            readonly targetFamily: "fontWeight";
+        };
+        readonly leading: {
+            readonly defaultOp: "leading";
+            readonly targetFamily: "leading";
+        };
+        readonly tracking: {
+            readonly defaultOp: "tracking";
+            readonly targetFamily: "tracking";
+        };
+    };
+    readonly title: {
+        readonly family: {
+            readonly defaultOp: "fontFamily";
+            readonly targetFamily: "font";
+        };
+        readonly size: {
+            readonly defaultOp: "textSize";
+            readonly targetFamily: "textSize";
+        };
+        readonly weight: {
+            readonly defaultOp: "fontWeight";
+            readonly targetFamily: "fontWeight";
+        };
+        readonly leading: {
+            readonly defaultOp: "leading";
+            readonly targetFamily: "leading";
+        };
+        readonly tracking: {
+            readonly defaultOp: "tracking";
+            readonly targetFamily: "tracking";
+        };
+        readonly transform: {
+            readonly defaultOp: "textTransform";
+            readonly targetFamily: "textTransform";
+        };
+    };
+};
+export declare const OPS_BY_TOKEN_FAMILY: {
+    readonly color: readonly ["borderColor", "divideColor", "bg", "textColor", "shadowColor", "ringColor"];
+    readonly borderWidth: readonly ["borderWidth", "borderWidthT", "borderWidthR", "borderWidthB", "borderWidthL", "divideWidth"];
+    readonly borderStyle: readonly ["borderStyle", "divideStyle"];
+    readonly shadowCompose: readonly ["shadowCompose"];
+    readonly shadowOffset: readonly ["shadowX1", "shadowY1", "shadowX2", "shadowY2"];
+    readonly shadowBlur: readonly ["shadowBlur1", "shadowBlur2"];
+    readonly shadowSpread: readonly ["shadowSpread1", "shadowSpread2"];
+    readonly shadowOpacity: readonly ["shadowOpacity1", "shadowOpacity2"];
+    readonly font: readonly ["fontFamily"];
+    readonly textSize: readonly ["textSize"];
+    readonly fontWeight: readonly ["fontWeight"];
+    readonly leading: readonly ["leading"];
+    readonly tracking: readonly ["tracking"];
+    readonly textTransform: readonly ["textTransform"];
+};