@riverbankcms/sdk 0.108.0 → 0.111.0

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

@@ -115,8 +115,8 @@ export declare const accordionSystemSchema: z.ZodObject<{
         triggerColorToken: z.ZodOptional<z.ZodString>;
         accent: z.ZodOptional<z.ZodObject<{
             edge: z.ZodEnum<{
-                bottom: "bottom";
                 left: "left";
+                bottom: "bottom";
                 top: "top";
             }>;
             colorToken: z.ZodString;

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,11 +6,12 @@
 export * from './types';
 export * from './classNames';
 export * from './generateButtonCss';
+export * from './resolveButtonColourStates';
 export * from './affordanceIcons';
 export * from './generateDefaultButtonSystem';
 export * from './constants';
 export * from './presets';
-export * from './personalities';
+export * from './styles';
 export * from './effects/types';
 export * from './effects/registry';
 export * from './effects/presets/transform';

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[];

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

@@ -0,0 +1,80 @@
+import type { z } from 'zod';
+import type { StyleTags } from '../../site-styles/styleTags';
+import type { ButtonGlobalSettings, ButtonSizes, ButtonSystem, ButtonVariant } from '../types';
+export declare const PUBLIC_BUTTON_ROLES: readonly ["primary", "secondary", "outline", "ghost", "accent"];
+export type PublicButtonRole = (typeof PUBLIC_BUTTON_ROLES)[number];
+export type CompleteButtonRole = 'primary' | 'secondary';
+export type SupportingButtonRole = Exclude<PublicButtonRole, CompleteButtonRole>;
+export type ButtonVariantAppearance = Readonly<Pick<ButtonVariant, 'background' | 'borderRadius' | 'shadow' | 'border' | 'hoverBackgroundToken' | 'effects' | 'sizes' | 'affordance'>>;
+export type PublicButtonVariant<TRole extends PublicButtonRole = PublicButtonRole> = Omit<ButtonVariant, 'id' | 'enabled'> & Readonly<{
+    id: TRole;
+    enabled: true;
+}>;
+export type CompleteButtonRoles = Readonly<{
+    [TRole in PublicButtonRole]: PublicButtonVariant<TRole>;
+}>;
+type CompleteRoleDefinition<TRole extends PublicButtonRole> = Readonly<{
+    kind: 'complete';
+    appearance: ButtonVariantAppearance;
+}>;
+type DerivedRoleDefinition = Readonly<{
+    kind: 'derive';
+    from: CompleteButtonRole;
+    overrides?: Partial<ButtonVariantAppearance>;
+}>;
+export type ButtonRoleDefinitions = Readonly<{
+    primary: CompleteRoleDefinition<'primary'>;
+    secondary: CompleteRoleDefinition<'secondary'>;
+    outline: CompleteRoleDefinition<'outline'> | DerivedRoleDefinition;
+    ghost: CompleteRoleDefinition<'ghost'> | DerivedRoleDefinition;
+    accent: CompleteRoleDefinition<'accent'> | DerivedRoleDefinition;
+}>;
+export type ButtonStyleSystemDefinition = Readonly<{
+    global: ButtonGlobalSettings;
+    sizes?: ButtonSizes;
+    roles: ButtonRoleDefinitions;
+}>;
+type StringParameterKey<TParameters> = Extract<keyof TParameters, string>;
+export type ButtonStyleControl<TParameters> = {
+    [TKey in StringParameterKey<TParameters>]: Readonly<{
+        kind: 'choice';
+        parameter: TKey;
+        label: string;
+        options: readonly Readonly<{
+            value: Extract<TParameters[TKey], string>;
+            label: string;
+        }>[];
+    }>;
+}[StringParameterKey<TParameters>];
+export type ButtonStyleRecipe<TId extends string = string, TParameters = Readonly<Record<string, never>>> = Readonly<{
+    id: TId;
+    accessibilityLabel: string;
+    tags: StyleTags;
+    parameterSchema: z.ZodType<TParameters>;
+    defaultParameters: TParameters;
+    controls: readonly ButtonStyleControl<TParameters>[];
+    defineSystem: (parameters: TParameters) => ButtonStyleSystemDefinition;
+}>;
+export type ResolveButtonStyleError = Readonly<{
+    kind: 'invalid-parameters';
+    styleId: string;
+    issues: readonly string[];
+}> | Readonly<{
+    kind: 'invalid-button-system';
+    styleId: string;
+    issues: readonly string[];
+}>;
+export type ResolveButtonStyleResult = Readonly<{
+    kind: 'resolved';
+    buttonSystem: ButtonSystem;
+}> | Readonly<{
+    kind: 'error';
+    error: ResolveButtonStyleError;
+}>;
+export declare function defineButtonStyleRecipe<const TId extends string, TParameters>(recipe: ButtonStyleRecipe<TId, TParameters>): ButtonStyleRecipe<TId, TParameters>;
+export declare function materializeButtonRoles(definitions: ButtonRoleDefinitions): CompleteButtonRoles;
+export declare function resolveButtonStyleRecipe<TId extends string, TParameters>(recipe: ButtonStyleRecipe<TId, TParameters>, parameters: unknown): ResolveButtonStyleResult;
+export declare function isPublicButtonRole(value: string): value is PublicButtonRole;
+export declare function hasCompletePublicButtonRoles(buttonSystem: ButtonSystem): boolean;
+export declare function listMissingPublicButtonRoles(buttonSystem: ButtonSystem): readonly PublicButtonRole[];
+export {};

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

@@ -0,0 +1,3 @@
+export * from './domain';
+export * from './registry';
+export * from './selection';

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

@@ -0,0 +1,49 @@
+import { type ButtonColourTreatment, type ButtonGlobalSettings } from '../../types';
+import { type ButtonVariantAppearance, type ButtonStyleRecipe, type ButtonStyleSystemDefinition } from '../domain';
+type AuthoringColourTreatment = 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 AuthoringAppearance = Omit<ButtonVariantAppearance, 'background' | 'hoverBackgroundToken'> & Readonly<{
+    background: AuthoringColourTreatment;
+    hoverBackgroundToken?: string;
+}>;
+type AuthoringCompleteRole = Readonly<{
+    kind: 'complete';
+    appearance: AuthoringAppearance;
+}>;
+type AuthoringDerivedRole = Readonly<{
+    kind: 'derive';
+    from: 'primary' | 'secondary';
+    overrides?: Partial<AuthoringAppearance>;
+}>;
+type AuthoringRoleDefinitions = Readonly<{
+    primary: AuthoringCompleteRole;
+    secondary: AuthoringCompleteRole;
+    outline: AuthoringCompleteRole | AuthoringDerivedRole;
+    ghost: AuthoringCompleteRole | AuthoringDerivedRole;
+    accent: AuthoringCompleteRole | AuthoringDerivedRole;
+}>;
+type AuthoringGlobalSettings = Omit<ButtonGlobalSettings, 'hoverColorToken'> & Readonly<{
+    hoverColorToken?: string;
+}>;
+export declare function defineStaticButtonStyleRecipe<const TId extends string>(input: {
+    id: TId;
+    accessibilityLabel: string;
+    tags: ButtonStyleRecipe<TId>['tags'];
+    system: Readonly<{
+        global: AuthoringGlobalSettings;
+        sizes?: ButtonStyleSystemDefinition['sizes'];
+        roles: AuthoringRoleDefinitions;
+    }>;
+}): ButtonStyleRecipe<TId>;
+export {};

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

@@ -0,0 +1,67 @@
+export declare const quietArrowRecipe: Readonly<{
+    id: "quiet-arrow";
+    accessibilityLabel: 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;
+    }>>>;
+    parameterSchema: import("zod").ZodType<{
+        secondaryTreatment: "outlined" | "solid-accent";
+    }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+        secondaryTreatment: "outlined" | "solid-accent";
+    }, unknown>>;
+    defaultParameters: {
+        secondaryTreatment: "outlined" | "solid-accent";
+    };
+    controls: readonly Readonly<{
+        kind: "choice";
+        parameter: "secondaryTreatment";
+        label: string;
+        options: readonly Readonly<{
+            value: "outlined" | "solid-accent";
+            label: string;
+        }>[];
+    }>[];
+    defineSystem: (parameters: {
+        secondaryTreatment: "outlined" | "solid-accent";
+    }) => Readonly<{
+        global: import("../../../../../blocks/src/index").ButtonGlobalSettings;
+        sizes?: import("../..").ButtonSizes;
+        roles: Readonly<{
+            primary: Readonly<{
+                kind: "complete";
+                appearance: import("..").ButtonVariantAppearance;
+            }>;
+            secondary: Readonly<{
+                kind: "complete";
+                appearance: import("..").ButtonVariantAppearance;
+            }>;
+            outline: Readonly<{
+                kind: "complete";
+                appearance: import("..").ButtonVariantAppearance;
+            }> | Readonly<{
+                kind: "derive";
+                from: import("..").CompleteButtonRole;
+                overrides?: Partial<import("..").ButtonVariantAppearance>;
+            }>;
+            ghost: Readonly<{
+                kind: "complete";
+                appearance: import("..").ButtonVariantAppearance;
+            }> | Readonly<{
+                kind: "derive";
+                from: import("..").CompleteButtonRole;
+                overrides?: Partial<import("..").ButtonVariantAppearance>;
+            }>;
+            accent: Readonly<{
+                kind: "complete";
+                appearance: import("..").ButtonVariantAppearance;
+            }> | Readonly<{
+                kind: "derive";
+                from: import("..").CompleteButtonRole;
+                overrides?: Partial<import("..").ButtonVariantAppearance>;
+            }>;
+        }>;
+    }>;
+}>;