@riverbankcms/sdk 0.107.0 → 0.109.0

package/dist/_dts/theme-core/src/accordions/types.d.ts

@@ -87,8 +87,8 @@ export declare const accordionSystemSchema: z.ZodObject<{
             semibold: "semibold";
         }>>;
         fontFamily: z.ZodOptional<z.ZodEnum<{
-            body: "body";
             heading: "heading";
+            body: "body";
         }>>;
         fontScale: z.ZodOptional<z.ZodEnum<{
             body: "body";
@@ -116,8 +116,8 @@ export declare const accordionSystemSchema: z.ZodObject<{
         accent: z.ZodOptional<z.ZodObject<{
             edge: z.ZodEnum<{
                 left: "left";
-                top: "top";
                 bottom: "bottom";
+                top: "top";
             }>;
             colorToken: z.ZodString;
             thickness: z.ZodEnum<{

package/dist/_dts/theme-core/src/buttons/core.d.ts

@@ -1,54 +1,23 @@
 /**
- * Core Button CSS Generator
+ * Small button emitter used by the SDK bridge.
  *
- * Pure functions for generating button CSS without requiring the full Theme type.
- * Used by both the full CMS theme system and the SDK theme bridge.
+ * The bridge deliberately has a smaller structural contract than a full CMS
+ * theme, but colour relationships still compile through the canonical button
+ * colour-state resolver.
  */
-export type ButtonBackgroundType = 'solid' | 'transparent' | 'gradient';
+import type { ExpandedPalette } from '../palette/expandPalette';
+import { type ButtonColourTreatment } from './types';
 export interface ButtonVariantCore {
-    /** Unique variant identifier (e.g., 'primary', 'secondary') */
-    id: string;
-    /** Background style */
-    background: ButtonBackgroundType;
-    /** Background color token for solid backgrounds (e.g., 'primary') */
-    backgroundToken?: string;
-    /** Gradient stops for gradient backgrounds */
-    gradientStops?: string[];
-    /** Gradient direction for gradient backgrounds */
-    gradientDirection?: 'to-r' | 'to-l' | 'to-t' | 'to-b' | 'to-tr' | 'to-tl' | 'to-br' | 'to-bl';
-    /** Text color token */
-    textToken: string;
-    /** Border color token (for outline style) */
-    borderToken?: string;
-    /** Border width */
-    borderWidth?: 'none' | 'thin' | 'medium' | 'thick';
+    readonly id: string;
+    readonly treatment: ButtonColourTreatment;
+    readonly borderWidth?: 'none' | 'thin' | 'medium' | 'thick';
 }
 export interface ButtonCoreSettings {
-    /** Corner radius style */
-    corners: 'square' | 'soft' | 'rounded' | 'pill';
-    /** Shadow intensity */
-    shadow: 'none' | 'low' | 'medium' | 'high';
-    /** Default border width for variants with borders */
-    borderWidth: 'none' | 'thin' | 'medium' | 'thick';
-    /** Font weight */
-    fontWeight?: number;
-    /** Text transform */
-    textTransform?: 'none' | 'uppercase' | 'lowercase' | 'capitalize';
+    readonly corners: 'square' | 'soft' | 'rounded' | 'pill';
+    readonly shadow: 'none' | 'low' | 'medium' | 'high';
+    readonly borderWidth: 'none' | 'thin' | 'medium' | 'thick';
+    readonly fontWeight?: number;
+    readonly textTransform?: 'none' | 'uppercase' | 'lowercase' | 'capitalize';
 }
-/**
- * Generate button CSS from core variant definitions.
- *
- * This is a pure function with no dependencies on Theme type.
- * It generates CSS that uses rgb(var(--tb-{token})) for colors.
- *
- * @param scopeId - Theme scope ID for selector (e.g., 'sdk' -> [data-theme-scope="sdk"])
- * @param variants - Button variant definitions
- * @param settings - Global button settings
- * @returns CSS string
- */
-export declare function generateButtonCoreCss(scopeId: string, variants: ButtonVariantCore[], settings: ButtonCoreSettings): string;
-/**
- * Get default button variants for SDK usage.
- * These create primary, secondary, outline, and ghost buttons.
- */
+export declare function generateButtonCoreCss(scopeId: string, variants: readonly ButtonVariantCore[], settings: ButtonCoreSettings, palette: ExpandedPalette): string;
 export declare function getDefaultButtonVariants(): ButtonVariantCore[];

package/dist/_dts/theme-core/src/buttons/effectClassification.d.ts

@@ -0,0 +1,147 @@
+export type ButtonUnsupportedEffectReason = 'alpha_requires_surface' | 'changes_foreground' | 'changes_border' | 'changes_element_opacity' | 'unresolved_background_overlay' | 'not_button_effect';
+export type ButtonEffectPolicy = Readonly<{
+    classification: 'colour-transition';
+    transition: Readonly<{
+        kind: 'adjust-shade';
+        direction: 'darker' | 'lighter';
+    }> | Readonly<{
+        kind: 'replace-background';
+    }>;
+}> | Readonly<{
+    classification: 'non-colour';
+}> | Readonly<{
+    classification: 'unsupported-colour' | 'unsupported-background-overlay' | 'not-button';
+    reason: ButtonUnsupportedEffectReason;
+}>;
+export type ButtonEffectClassification = ButtonEffectPolicy['classification'] | 'unknown';
+/**
+ * Exhaustive live policy for every registered effect id.
+ *
+ * The resolver consumes the transition payload directly, so adding an effect
+ * cannot update classification without also defining its runtime behavior.
+ */
+export declare const BUTTON_EFFECT_POLICIES: {
+    readonly 'darken-background': {
+        readonly classification: "colour-transition";
+        readonly transition: {
+            readonly kind: "adjust-shade";
+            readonly direction: "darker";
+        };
+    };
+    readonly 'lighten-background': {
+        readonly classification: "colour-transition";
+        readonly transition: {
+            readonly kind: "adjust-shade";
+            readonly direction: "lighter";
+        };
+    };
+    readonly 'background-on-hover': {
+        readonly classification: "colour-transition";
+        readonly transition: {
+            readonly kind: "replace-background";
+        };
+    };
+    readonly 'background-on-hover-alpha': {
+        readonly classification: "unsupported-colour";
+        readonly reason: "alpha_requires_surface";
+    };
+    readonly 'fade-background': {
+        readonly classification: "unsupported-colour";
+        readonly reason: "changes_element_opacity";
+    };
+    readonly 'opacity-reduce': {
+        readonly classification: "unsupported-colour";
+        readonly reason: "changes_element_opacity";
+    };
+    readonly 'gradient-text': {
+        readonly classification: "unsupported-colour";
+        readonly reason: "changes_foreground";
+    };
+    readonly 'text-color-change': {
+        readonly classification: "unsupported-colour";
+        readonly reason: "changes_foreground";
+    };
+    readonly 'border-color-change': {
+        readonly classification: "unsupported-colour";
+        readonly reason: "changes_border";
+    };
+    readonly 'aurora-glow': {
+        readonly classification: "unsupported-background-overlay";
+        readonly reason: "unresolved_background_overlay";
+    };
+    readonly 'cosmic-stardust': {
+        readonly classification: "unsupported-background-overlay";
+        readonly reason: "unresolved_background_overlay";
+    };
+    readonly 'gradient-border-fill': {
+        readonly classification: "unsupported-background-overlay";
+        readonly reason: "unresolved_background_overlay";
+    };
+    readonly 'animated-gradient-border-fill': {
+        readonly classification: "unsupported-background-overlay";
+        readonly reason: "unresolved_background_overlay";
+    };
+    readonly 'nav-underline': {
+        readonly classification: "not-button";
+        readonly reason: "not_button_effect";
+    };
+    readonly 'nav-frosted-base': {
+        readonly classification: "not-button";
+        readonly reason: "not_button_effect";
+    };
+    readonly 'nav-frosted-hover': {
+        readonly classification: "not-button";
+        readonly reason: "not_button_effect";
+    };
+    readonly 'nav-frosted-active': {
+        readonly classification: "not-button";
+        readonly reason: "not_button_effect";
+    };
+    readonly 'animated-gradient': {
+        readonly classification: "non-colour";
+    };
+    readonly 'border-glow': {
+        readonly classification: "non-colour";
+    };
+    readonly 'drop-shadow': {
+        readonly classification: "non-colour";
+    };
+    readonly 'inner-shadow': {
+        readonly classification: "non-colour";
+    };
+    readonly 'neumorphic-shadow': {
+        readonly classification: "non-colour";
+    };
+    readonly 'outer-glow': {
+        readonly classification: "non-colour";
+    };
+    readonly 'retro-3d-shadow': {
+        readonly classification: "non-colour";
+    };
+    readonly 'scale-up': {
+        readonly classification: "non-colour";
+    };
+    readonly 'scale-down': {
+        readonly classification: "non-colour";
+    };
+    readonly lift: {
+        readonly classification: "non-colour";
+    };
+    readonly 'press-down': {
+        readonly classification: "non-colour";
+    };
+    readonly pop: {
+        readonly classification: "non-colour";
+    };
+    readonly 'border-bottom-grow': {
+        readonly classification: "non-colour";
+    };
+    readonly 'sketchy-border': {
+        readonly classification: "non-colour";
+    };
+    readonly 'pulse-animation': {
+        readonly classification: "non-colour";
+    };
+};
+export declare function getButtonEffectPolicy(effectId: string): ButtonEffectPolicy | null;
+export declare function classifyButtonEffectId(effectId: string): ButtonEffectClassification;

package/dist/_dts/theme-core/src/buttons/effects/types.d.ts

@@ -1,5 +1,4 @@
 import type { TokenResolver } from '../../tokens/resolver';
-import type { ButtonPreset } from '../presets/types';
 import type { ButtonVariant } from '../types';
 import type { Theme } from '../../schema';
 import type { InteractiveElementConfig } from '../../interactive/types';
@@ -39,7 +38,7 @@ export interface EffectContext {
     /** User-provided customization options */
     options: Record<string, unknown>;
     /** Element configuration (access to background, colors, etc.) */
-    buttonConfig: ButtonVariant | ButtonPreset | InteractiveElementConfig;
+    buttonConfig: ButtonVariant | InteractiveElementConfig;
     /** Token resolver for converting tokens to CSS vars */
     tokens: TokenResolver;
     /** Theme configuration (for accessing theme-level settings like shadows) */
@@ -127,7 +126,7 @@ export interface EffectPreset {
      * @param buttonConfig - Button configuration (ButtonVariant or ButtonPreset)
      * @returns True if effect can be applied to this button
      */
-    isApplicable?: (buttonConfig: ButtonVariant | ButtonPreset) => boolean;
+    isApplicable?: (buttonConfig: ButtonVariant | InteractiveElementConfig) => boolean;
 }
 /**
  * Reference to an effect preset with customization options

package/dist/_dts/theme-core/src/buttons/generateDefaultButtonSystem.d.ts

@@ -1,5 +1,5 @@
 import type { Theme } from '../schema';
-import type { ButtonSystem } from './types';
+import { type ButtonSystem } from './types';
 /**
  * Generate default button system from theme settings.
  *

package/dist/_dts/theme-core/src/buttons/index.d.ts

@@ -6,6 +6,7 @@
 export * from './types';
 export * from './classNames';
 export * from './generateButtonCss';
+export * from './resolveButtonColourStates';
 export * from './affordanceIcons';
 export * from './generateDefaultButtonSystem';
 export * from './constants';

package/dist/_dts/theme-core/src/buttons/personalities/index.d.ts

@@ -20,6 +20,17 @@ export declare const buttonPersonalities: readonly [Readonly<{
         era: import("../../../../blocks/src/index").StyleEra;
     }>>>;
     buttonSystem: import("../../../../blocks/src/index").ButtonSystem;
+}>, Readonly<{
+    id: ButtonPersonalityId<"two-tone-pill">;
+    name: string;
+    description: string;
+    tags: Readonly<Partial<Readonly<{
+        tone: import("../../../../blocks/src/index").StyleTone;
+        energy: import("../../../../blocks/src/index").StyleEnergy;
+        motion: import("../../../../blocks/src/index").StyleMotion;
+        era: import("../../../../blocks/src/index").StyleEra;
+    }>>>;
+    buttonSystem: import("../../../../blocks/src/index").ButtonSystem;
 }>, Readonly<{
     id: ButtonPersonalityId<"earth-pill">;
     name: string;

package/dist/_dts/theme-core/src/buttons/personalities/two-tone-pill.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Two-tone Pill keeps Soft Pill's shape, spacing, typography, and motion while
+ * giving secondary actions their own solid palette role. The derived
+ * `onSecondary` token keeps the label legible as the site's palette changes.
+ */
+export declare const twoTonePill: Readonly<{
+    id: import("./types").ButtonPersonalityId<"two-tone-pill">;
+    name: string;
+    description: string;
+    tags: Readonly<Partial<Readonly<{
+        tone: import("../../../../blocks/src/index").StyleTone;
+        energy: import("../../../../blocks/src/index").StyleEnergy;
+        motion: import("../../../../blocks/src/index").StyleMotion;
+        era: import("../../../../blocks/src/index").StyleEra;
+    }>>>;
+    buttonSystem: import("../../../../blocks/src/index").ButtonSystem;
+}>;

package/dist/_dts/theme-core/src/buttons/personalities/types.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { type ButtonSystem } from '../types';
+import { type ButtonColourTreatment, type ButtonGlobalSettings, type ButtonSystem, type ButtonVariant } from '../types';
 import { type StyleTags } from '../../site-styles/styleTags';
 /**
  * Branded ID for a button personality entry in the curated library.
@@ -46,13 +46,13 @@ export declare const buttonPersonalitySchema: z.ZodObject<{
         era: z.ZodOptional<z.ZodEnum<{
             editorial: "editorial";
             modern: "modern";
-            retro: "retro";
-            technical: "technical";
             organic: "organic";
+            technical: "technical";
+            retro: "retro";
         }>>;
     }, z.core.$strip>;
     buttonSystem: z.ZodObject<{
-        global: z.ZodObject<{
+        global: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
             cornerStyle: z.ZodEnum<{
                 square: "square";
                 rounded: "rounded";
@@ -74,8 +74,8 @@ export declare const buttonPersonalitySchema: z.ZodObject<{
             fontWeight: z.ZodUnion<readonly [z.ZodLiteral<500>, z.ZodLiteral<600>, z.ZodLiteral<700>]>;
             borderWidth: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
             typography: z.ZodOptional<z.ZodEnum<{
-                body: "body";
                 heading: "heading";
+                body: "body";
             }>>;
             fontSize: z.ZodOptional<z.ZodString>;
             letterSpacing: z.ZodOptional<z.ZodEnum<{
@@ -102,7 +102,7 @@ export declare const buttonPersonalitySchema: z.ZodObject<{
                 darken: "darken";
                 saturate: "saturate";
             }>;
-            hoverColorToken: z.ZodOptional<z.ZodString>;
+            hoverColorToken: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("..").OpaqueButtonColourToken, string>>>;
             gradientStyle: z.ZodOptional<z.ZodEnum<{
                 linear: "linear";
                 radial: "radial";
@@ -114,18 +114,18 @@ export declare const buttonPersonalitySchema: z.ZodObject<{
                 hard: "hard";
                 smooth: "smooth";
             }>>;
-        }, z.core.$strip>;
-        variants: z.ZodArray<z.ZodObject<{
+        }, z.core.$strip>>;
+        variants: z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
             id: z.ZodString;
             name: z.ZodString;
             enabled: z.ZodBoolean;
             priority: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
             background: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"solid">;
-                colorToken: z.ZodString;
+                colorToken: z.ZodPipe<z.ZodString, z.ZodTransform<import("..").OpaqueButtonColourToken, string>>;
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<"gradient">;
-                stops: z.ZodArray<z.ZodString>;
+                stops: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("..").OpaqueButtonColourToken, string>>>, z.ZodTransform<[import("..").OpaqueButtonColourToken, import("..").OpaqueButtonColourToken, ...import("..").OpaqueButtonColourToken[]], import("..").OpaqueButtonColourToken[]>>;
                 direction: z.ZodEnum<{
                     "to-r": "to-r";
                     "to-l": "to-l";
@@ -136,10 +136,11 @@ export declare const buttonPersonalitySchema: z.ZodObject<{
                     "to-br": "to-br";
                     "to-bl": "to-bl";
                 }>;
+                foregroundToken: z.ZodPipe<z.ZodString, z.ZodTransform<import("..").OpaqueButtonColourToken, string>>;
             }, z.core.$strip>, z.ZodObject<{
-                type: z.ZodLiteral<"transparent">;
+                type: z.ZodLiteral<"surface">;
+                role: z.ZodLiteral<"link">;
             }, z.core.$strip>], "type">;
-            textColorToken: z.ZodString;
             borderRadius: z.ZodOptional<z.ZodString>;
             shadow: z.ZodOptional<z.ZodObject<{
                 elevation: z.ZodEnum<{
@@ -161,26 +162,13 @@ export declare const buttonPersonalitySchema: z.ZodObject<{
             }, z.core.$strip>>;
             border: z.ZodOptional<z.ZodObject<{
                 widthClass: z.ZodString;
-                colorToken: z.ZodString;
             }, z.core.$strip>>;
-            hoverBackgroundToken: z.ZodOptional<z.ZodString>;
+            hoverBackgroundToken: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("..").OpaqueButtonColourToken, string>>>;
             effects: z.ZodOptional<z.ZodObject<{
-                base: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    effectId: z.ZodString;
-                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                }, z.core.$strip>>>;
-                hover: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    effectId: z.ZodString;
-                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                }, z.core.$strip>>>;
-                active: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    effectId: z.ZodString;
-                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                }, z.core.$strip>>>;
-                focus: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    effectId: z.ZodString;
-                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                }, z.core.$strip>>>;
+                base: z.ZodOptional<z.ZodArray<z.ZodType<import("../../../../blocks/src/index").EffectApplication, unknown, z.core.$ZodTypeInternals<import("../../../../blocks/src/index").EffectApplication, unknown>>>>;
+                hover: z.ZodOptional<z.ZodArray<z.ZodType<import("../../../../blocks/src/index").EffectApplication, unknown, z.core.$ZodTypeInternals<import("../../../../blocks/src/index").EffectApplication, unknown>>>>;
+                active: z.ZodOptional<z.ZodArray<z.ZodType<import("../../../../blocks/src/index").EffectApplication, unknown, z.core.$ZodTypeInternals<import("../../../../blocks/src/index").EffectApplication, unknown>>>>;
+                focus: z.ZodOptional<z.ZodArray<z.ZodType<import("../../../../blocks/src/index").EffectApplication, unknown, z.core.$ZodTypeInternals<import("../../../../blocks/src/index").EffectApplication, unknown>>>>;
             }, z.core.$strip>>;
             sizes: z.ZodOptional<z.ZodObject<{
                 sm: z.ZodOptional<z.ZodObject<{
@@ -202,9 +190,8 @@ export declare const buttonPersonalitySchema: z.ZodObject<{
             }, z.core.$strip>>;
             affordance: z.ZodOptional<z.ZodObject<{
                 iconId: z.ZodString;
-                colorToken: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
-        }, z.core.$strip>>;
+        }, z.core.$strip>>>;
         sizes: z.ZodOptional<z.ZodPipe<z.ZodObject<{
             sm: z.ZodObject<{
                 padding: z.ZodString;
@@ -269,5 +256,30 @@ export declare function defineButtonPersonality<const TId extends string>(input:
     name: string;
     description: string;
     tags: StyleTags;
-    buttonSystem: ButtonSystem;
+    buttonSystem: ButtonSystemAuthoringInput;
 }): ButtonPersonality<ButtonPersonalityId<TId>>;
+type ButtonColourTreatmentAuthoringInput = Readonly<{
+    type: 'solid';
+    colorToken: string;
+}> | Readonly<{
+    type: 'gradient';
+    stops: readonly [string, string, ...string[]];
+    direction: Extract<ButtonColourTreatment, {
+        type: 'gradient';
+    }>['direction'];
+    foregroundToken: string;
+}> | Extract<ButtonColourTreatment, {
+    type: 'surface';
+}>;
+type ButtonVariantAuthoringInput = Omit<ButtonVariant, 'background' | 'hoverBackgroundToken'> & Readonly<{
+    background: ButtonColourTreatmentAuthoringInput;
+    hoverBackgroundToken?: string;
+}>;
+type ButtonGlobalSettingsAuthoringInput = Omit<ButtonGlobalSettings, 'hoverColorToken'> & Readonly<{
+    hoverColorToken?: string;
+}>;
+type ButtonSystemAuthoringInput = Omit<ButtonSystem, 'global' | 'variants'> & Readonly<{
+    global: ButtonGlobalSettingsAuthoringInput;
+    variants: readonly ButtonVariantAuthoringInput[];
+}>;
+export {};

package/dist/_dts/theme-core/src/buttons/presets.d.ts

@@ -1,43 +1,22 @@
 import type { ButtonSystem } from './types';
-/**
- * Button Preset
- *
- * A preset is a complete ButtonSystem configuration (global settings + variants)
- * that users can select to quickly style their site's buttons.
- */
 export interface ButtonPreset {
     id: string;
     name: string;
     description: string;
     category: 'modern' | 'retro' | 'minimal' | 'artistic' | 'technical';
     buttonSystem: ButtonSystem;
-    /**
-     * Theme compatibility metadata
-     *
-     * Defines which theme characteristics work well with this preset.
-     * Used for intelligent filtering to show only contextually appropriate presets.
-     */
     compatibility?: {
-        /** Which palette modes work well (undefined = works with both) */
         modes?: ('light' | 'dark')[];
-        /** Which tone axes match (undefined = works with all) */
         tones?: ('minimal' | 'classic' | 'bold')[];
-        /** Which energy levels match (undefined = works with all) */
         energies?: ('calm' | 'vibrant')[];
     };
 }
 /**
- * Button Presets Library
- *
- * Curated collection of button system configurations extracted from
- * button experiments and design explorations.
+ * The dashboard gallery and generated site styles now share the same curated
+ * button definitions. The former experiment-era preset catalogue duplicated
+ * colour choices and effect emitters, so it could drift outside the canonical
+ * colour contract.
  */
 export declare const buttonPresets: ButtonPreset[];
-/**
- * Get preset by ID
- */
 export declare function getPresetById(id: string): ButtonPreset | undefined;
-/**
- * Get presets by category
- */
 export declare function getPresetsByCategory(category: ButtonPreset['category']): ButtonPreset[];

package/dist/_dts/theme-core/src/buttons/resolveButtonColourStates.d.ts

@@ -0,0 +1,100 @@
+import type { ExpandedPalette } from '../palette/expandPalette';
+import type { ButtonColourTreatment, ButtonGlobalSettings, ButtonVariant, OpaqueButtonColourToken, VariantEffects } from './types';
+import { type ButtonUnsupportedEffectReason } from './effectClassification';
+export { classifyButtonEffectId, type ButtonEffectClassification, } from './effectClassification';
+export declare const BUTTON_VISUAL_STATES: readonly ["base", "hover", "focus", "active", "disabled"];
+export type ButtonVisualState = (typeof BUTTON_VISUAL_STATES)[number];
+export declare const BUTTON_CONTRAST_POLICY: {
+    readonly textMinimumRatio: 4.5;
+    readonly nonTextMinimumRatio: 3;
+    readonly gradientSamplesPerSegment: 20;
+    readonly alphaBackgrounds: "reject-without-known-surface";
+    readonly disabled: "retain-full-colour-contract";
+};
+export type ButtonColourContractError = Readonly<{
+    tag: 'unknown_palette_token';
+    variantId: string;
+    state: ButtonVisualState;
+    token: OpaqueButtonColourToken;
+}> | Readonly<{
+    tag: 'missing_on_colour';
+    variantId: string;
+    state: ButtonVisualState;
+    backgroundToken: OpaqueButtonColourToken;
+    foregroundToken: OpaqueButtonColourToken;
+}> | Readonly<{
+    tag: 'insufficient_contrast';
+    variantId: string;
+    state: ButtonVisualState;
+    background: string;
+    foreground: string;
+    ratio: number;
+    requiredRatio: number;
+}> | Readonly<{
+    tag: 'unsupported_colour_effect';
+    variantId: string;
+    state: ButtonVisualState;
+    effectId: string;
+    reason: ButtonUnsupportedEffectReason;
+}> | Readonly<{
+    tag: 'invalid_colour_effect_options';
+    variantId: string;
+    state: ButtonVisualState;
+    effectId: string;
+    option: string;
+}> | Readonly<{
+    tag: 'inapplicable_colour_effect';
+    variantId: string;
+    state: ButtonVisualState;
+    effectId: string;
+    treatment: ButtonColourTreatment['type'];
+}> | Readonly<{
+    tag: 'unknown_button_effect';
+    variantId: string;
+    state: ButtonVisualState;
+    effectId: string;
+}>;
+export type ResolvedButtonColour = Readonly<{
+    kind: 'solid';
+    backgroundToken: OpaqueButtonColourToken;
+    foregroundToken: OpaqueButtonColourToken;
+    backgroundCss: string;
+    foregroundCss: string;
+}> | Readonly<{
+    kind: 'gradient';
+    backgroundTokens: readonly [OpaqueButtonColourToken, OpaqueButtonColourToken, ...OpaqueButtonColourToken[]];
+    foregroundToken: OpaqueButtonColourToken;
+    backgroundCss: string;
+    foregroundCss: string;
+}> | Readonly<{
+    kind: 'surface';
+    role: 'link';
+    backgroundCss: 'transparent';
+    foregroundCss: string;
+}>;
+export type ResolvedButtonColourStates = Readonly<Record<ButtonVisualState, ResolvedButtonColour>>;
+export type ResolvedButtonFocusIndicator = Readonly<{
+    kind: 'two-tone';
+    innerCss: string;
+    outerCss: string;
+    minimumPairContrast: number;
+}> | Readonly<{
+    kind: 'surface-role';
+    colorCss: string;
+    minimumSurfaceContrast: number;
+}>;
+export type ButtonColourContractResult = Readonly<{
+    ok: true;
+    states: ResolvedButtonColourStates;
+    focusIndicator: ResolvedButtonFocusIndicator;
+    nonColourEffects: VariantEffects;
+}> | Readonly<{
+    ok: false;
+    error: ButtonColourContractError;
+}>;
+export declare function compileButtonColourStates(input: Readonly<{
+    variant: ButtonVariant;
+    global: ButtonGlobalSettings;
+    palette: ExpandedPalette;
+}>): ButtonColourContractResult;
+export declare function formatButtonColourContractError(error: ButtonColourContractError): string;

package/dist/_dts/theme-core/src/buttons/resolvedButtonCss.d.ts

@@ -0,0 +1,16 @@
+import type { ResolvedButtonColour, ResolvedButtonFocusIndicator } from './resolveButtonColourStates';
+export type ButtonCssDeclaration = readonly [property: string, value: string];
+/**
+ * Canonical colour declaration mapping shared by full themes and ThemeBridge.
+ * Both background properties are always emitted so transitions cannot retain
+ * a stale gradient or solid layer.
+ */
+export declare function resolvedButtonColourDeclarations(colour: ResolvedButtonColour): readonly ButtonCssDeclaration[];
+export declare function resolvedButtonFocusDeclarations(indicator: ResolvedButtonFocusIndicator): readonly ButtonCssDeclaration[];
+/**
+ * Disabled buttons retain their validated colour pair and add a non-layout
+ * visual affordance. `currentColor` keeps the cue inside the same contrast
+ * relationship, while retaining pointer events lets the not-allowed cursor
+ * remain observable.
+ */
+export declare const RESOLVED_BUTTON_DISABLED_DECLARATIONS: readonly ButtonCssDeclaration[];