@voxel51/voodo 1.4.0-dev.0 → 2.0.0

package/dist/types/color.d.ts

@@ -1,215 +1,173 @@
 import { ElementState } from './element';
-export declare const ActionColor: {
-    readonly PrimaryDefault: "action-primary-primary";
-    readonly PrimaryHover: "action-primary-secondary";
-    readonly PrimaryFocus: "action-primary-tertiary";
-    readonly PrimaryText: "action-primary-text";
-    readonly SecondaryDefault: "action-secondary-primary";
-    readonly SecondaryHover: "action-secondary-secondary";
-    readonly SecondaryFocus: "action-secondary-tertiary";
-    readonly SecondaryText: "action-secondary-text";
-    readonly SuccessDefault: "action-success-primary";
-    readonly SuccessHover: "action-success-secondary";
-    readonly SuccessFocus: "action-success-tertiary";
-    readonly SuccessText: "action-success-text";
-    readonly DangerDefault: "action-danger-primary";
-    readonly DangerHover: "action-danger-secondary";
-    readonly DangerFocus: "action-danger-tertiary";
-    readonly DangerText: "action-danger-text";
-    readonly IconDefault: "action-icon-default";
-};
-export type ActionColor = `${(typeof ActionColor)[keyof typeof ActionColor]}`;
-export declare namespace ActionColor {
-    type PrimaryDefault = typeof ActionColor.PrimaryDefault;
-    type PrimaryHover = typeof ActionColor.PrimaryHover;
-    type PrimaryFocus = typeof ActionColor.PrimaryFocus;
-    type PrimaryText = typeof ActionColor.PrimaryText;
-    type SecondaryDefault = typeof ActionColor.SecondaryDefault;
-    type SecondaryHover = typeof ActionColor.SecondaryHover;
-    type SecondaryFocus = typeof ActionColor.SecondaryFocus;
-    type SecondaryText = typeof ActionColor.SecondaryText;
-    type SuccessDefault = typeof ActionColor.SuccessDefault;
-    type SuccessHover = typeof ActionColor.SuccessHover;
-    type SuccessFocus = typeof ActionColor.SuccessFocus;
-    type SuccessText = typeof ActionColor.SuccessText;
-    type DangerDefault = typeof ActionColor.DangerDefault;
-    type DangerHover = typeof ActionColor.DangerHover;
-    type DangerFocus = typeof ActionColor.DangerFocus;
-    type DangerText = typeof ActionColor.DangerText;
-    type IconDefault = typeof ActionColor.IconDefault;
-}
+/**
+ * Color tokens as enums — GENERATED from Figma's variable export by
+ * kb/eng/projects/design-system-tokens/tools/build_color_types.py.
+ * Do not edit by hand; re-run the generator instead.
+ *
+ * Enum values are the Figma variable names, so they line up 1:1 with the
+ * CSS custom properties emitted from colors.ts.
+ */
 export declare const BackgroundColor: {
     readonly Transparent: "bg-transparent";
+    readonly Accent: "bg-accent";
     readonly Background: "bg-background";
-    readonly Card1: "bg-card-1";
-    readonly Card2: "bg-card-2";
+    readonly Card: "bg-card";
     readonly CardElevated: "bg-card-elevated";
+    readonly CardNested: "bg-card-nested";
+    readonly Failure: "bg-failure";
+    readonly Info: "bg-info";
     readonly Muted: "bg-muted";
     readonly Popover: "bg-popover";
-    readonly Selected: "bg-selected";
+    readonly Primary: "bg-primary";
     readonly Secondary: "bg-secondary";
-    readonly Raised: "bg-raised";
+    readonly Selected: "bg-selected";
+    readonly Success: "bg-success";
+    readonly Warning: "bg-warning";
 };
 export type BackgroundColor = `${(typeof BackgroundColor)[keyof typeof BackgroundColor]}`;
 export declare namespace BackgroundColor {
     type Transparent = typeof BackgroundColor.Transparent;
+    type Accent = typeof BackgroundColor.Accent;
     type Background = typeof BackgroundColor.Background;
-    type Card1 = typeof BackgroundColor.Card1;
-    type Card2 = typeof BackgroundColor.Card2;
+    type Card = typeof BackgroundColor.Card;
     type CardElevated = typeof BackgroundColor.CardElevated;
+    type CardNested = typeof BackgroundColor.CardNested;
+    type Failure = typeof BackgroundColor.Failure;
+    type Info = typeof BackgroundColor.Info;
     type Muted = typeof BackgroundColor.Muted;
     type Popover = typeof BackgroundColor.Popover;
-    type Selected = typeof BackgroundColor.Selected;
+    type Primary = typeof BackgroundColor.Primary;
     type Secondary = typeof BackgroundColor.Secondary;
-    type Raised = typeof BackgroundColor.Raised;
+    type Selected = typeof BackgroundColor.Selected;
+    type Success = typeof BackgroundColor.Success;
+    type Warning = typeof BackgroundColor.Warning;
 }
 export declare const BorderColor: {
+    readonly Active: "border-active";
     readonly Default: "border-default";
-    readonly Strong: "border-strong";
-    readonly Hover: "border-hover";
+    readonly Disabled: "border-disabled";
+    readonly Error: "border-error";
     readonly Focus: "border-focus";
+    readonly Hover: "border-hover";
+    readonly Input: "border-input";
+    readonly InputFocus: "border-input-focus";
+    readonly InputHover: "border-input-hover";
+    readonly Strong: "border-strong";
     readonly Subtle: "border-subtle";
-    readonly Active: "border-active";
-    readonly Error: "border-error";
     readonly Success: "border-success";
     readonly Warning: "border-warning";
-    readonly Disabled: "border-disabled";
     readonly CardElevated: "bg-card-elevated";
-    readonly Input: "border-input";
-    readonly InputHover: "border-input-hover";
-    readonly InputFocus: "border-input-focus";
 };
 export type BorderColor = `${(typeof BorderColor)[keyof typeof BorderColor]}`;
 export declare namespace BorderColor {
+    type Active = typeof BorderColor.Active;
     type Default = typeof BorderColor.Default;
-    type Strong = typeof BorderColor.Strong;
-    type Hover = typeof BorderColor.Hover;
+    type Disabled = typeof BorderColor.Disabled;
+    type Error = typeof BorderColor.Error;
     type Focus = typeof BorderColor.Focus;
+    type Hover = typeof BorderColor.Hover;
+    type Input = typeof BorderColor.Input;
+    type InputFocus = typeof BorderColor.InputFocus;
+    type InputHover = typeof BorderColor.InputHover;
+    type Strong = typeof BorderColor.Strong;
     type Subtle = typeof BorderColor.Subtle;
-    type Active = typeof BorderColor.Active;
-    type Error = typeof BorderColor.Error;
     type Success = typeof BorderColor.Success;
     type Warning = typeof BorderColor.Warning;
-    type Disabled = typeof BorderColor.Disabled;
     type CardElevated = typeof BorderColor.CardElevated;
-    type Input = typeof BorderColor.Input;
-    type InputHover = typeof BorderColor.InputHover;
-    type InputFocus = typeof BorderColor.InputFocus;
 }
-export declare const BrandColor: {
-    readonly Primary: "brand-primary";
-    readonly Accent: "brand-accent";
+export declare const CodeColor: {
+    readonly Bg: "code-bg";
+    readonly Border: "code-border";
+    readonly Text: "code-text";
 };
-export type BrandColor = `${(typeof BrandColor)[keyof typeof BrandColor]}`;
-export declare namespace BrandColor {
-    type Primary = typeof BrandColor.Primary;
-    type Accent = typeof BrandColor.Accent;
+export type CodeColor = `${(typeof CodeColor)[keyof typeof CodeColor]}`;
+export declare namespace CodeColor {
+    type Bg = typeof CodeColor.Bg;
+    type Border = typeof CodeColor.Border;
+    type Text = typeof CodeColor.Text;
+}
+export declare const FocusColor: {
+    readonly Ring: "focus-ring";
+};
+export type FocusColor = `${(typeof FocusColor)[keyof typeof FocusColor]}`;
+export declare namespace FocusColor {
+    type Ring = typeof FocusColor.Ring;
 }
 export declare const IconColor: {
+    readonly Brand: "icon-brand";
+    readonly Dark: "icon-dark";
+    readonly Decorative: "icon-decorative";
     readonly Default: "icon-default";
-    readonly Subtle: "icon-subtle";
+    readonly Disabled: "icon-disabled";
     readonly Emphasis: "icon-emphasis";
+    readonly Failure: "icon-failure";
+    readonly Info: "icon-info";
     readonly Muted: "icon-muted";
-    readonly Disabled: "icon-disabled";
-    readonly Decorative: "icon-decorative";
-    readonly Brand: "icon-brand";
-    readonly BrandAccent: "icon-brand-accent";
+    readonly Subtle: "icon-subtle";
     readonly Success: "icon-success";
-    readonly Destructive: "icon-destructive";
     readonly Warning: "icon-warning";
-    readonly Info: "icon-info";
-    readonly Dark: "icon-dark";
 };
 export type IconColor = `${(typeof IconColor)[keyof typeof IconColor]}`;
 export declare namespace IconColor {
+    type Brand = typeof IconColor.Brand;
+    type Dark = typeof IconColor.Dark;
+    type Decorative = typeof IconColor.Decorative;
     type Default = typeof IconColor.Default;
-    type Subtle = typeof IconColor.Subtle;
+    type Disabled = typeof IconColor.Disabled;
     type Emphasis = typeof IconColor.Emphasis;
+    type Failure = typeof IconColor.Failure;
+    type Info = typeof IconColor.Info;
     type Muted = typeof IconColor.Muted;
-    type Disabled = typeof IconColor.Disabled;
-    type Decorative = typeof IconColor.Decorative;
-    type Brand = typeof IconColor.Brand;
-    type BrandAccent = typeof IconColor.BrandAccent;
+    type Subtle = typeof IconColor.Subtle;
     type Success = typeof IconColor.Success;
-    type Destructive = typeof IconColor.Destructive;
     type Warning = typeof IconColor.Warning;
-    type Info = typeof IconColor.Info;
-    type Dark = typeof IconColor.Dark;
-}
-export declare const SemanticColor: {
-    readonly Success: "semantic-success";
-    readonly Destructive: "semantic-destructive";
-    readonly Info: "semantic-info";
-    readonly Warning: "semantic-warning";
-};
-export type SemanticColor = `${(typeof SemanticColor)[keyof typeof SemanticColor]}`;
-export declare namespace SemanticColor {
-    type Success = typeof SemanticColor.Success;
-    type Destructive = typeof SemanticColor.Destructive;
-    type Info = typeof SemanticColor.Info;
-    type Warning = typeof SemanticColor.Warning;
-}
-export declare const StatusColor: {
-    readonly Approved: "status-approved";
-    readonly Review: "status-review";
-    readonly Progress: "status-progress";
-    readonly Default: "status-default";
-    readonly Failed: "status-failed";
-};
-export type StatusColor = `${(typeof StatusColor)[keyof typeof StatusColor]}`;
-export declare namespace StatusColor {
-    type Approved = typeof StatusColor.Approved;
-    type Review = typeof StatusColor.Review;
-    type Progress = typeof StatusColor.Progress;
-    type Default = typeof StatusColor.Default;
-    type Failed = typeof StatusColor.Failed;
-}
-export declare const TextColor: {
-    readonly Fg: "text-fg";
-    readonly Primary: "text-primary";
-    readonly Secondary: "text-secondary";
-    readonly Tertiary: "text-tertiary";
-    readonly Muted: "text-muted";
-    readonly Placeholder: "text-placeholder";
-    readonly Success: "text-success";
-    readonly Destructive: "text-destructive";
-    readonly Warning: "text-warning";
-    readonly Info: "text-info";
-    readonly Accent: "text-accent";
-    readonly Decorative: "text-decorative";
-};
-export type TextColor = `${(typeof TextColor)[keyof typeof TextColor]}`;
-export declare namespace TextColor {
-    type Fg = typeof TextColor.Fg;
-    type Primary = typeof TextColor.Primary;
-    type Secondary = typeof TextColor.Secondary;
-    type Tertiary = typeof TextColor.Tertiary;
-    type Muted = typeof TextColor.Muted;
-    type Placeholder = typeof TextColor.Placeholder;
-    type Success = typeof TextColor.Success;
-    type Destructive = typeof TextColor.Destructive;
-    type Warning = typeof TextColor.Warning;
-    type Info = typeof TextColor.Info;
-    type Accent = typeof TextColor.Accent;
-    type Decorative = typeof TextColor.Decorative;
-}
-export declare const OverlayColor: {
-    readonly Default: "overlay-default";
-    readonly Light: "overlay-light";
-    readonly Heavy: "overlay-heavy";
-};
-export type OverlayColor = `${(typeof OverlayColor)[keyof typeof OverlayColor]}`;
-export declare namespace OverlayColor {
-    type Default = typeof OverlayColor.Default;
-    type Light = typeof OverlayColor.Light;
-    type Heavy = typeof OverlayColor.Heavy;
 }
-export declare const FocusColor: {
-    readonly Ring: "focus-ring";
+export declare const InteractiveColor: {
+    readonly DangerDefault: "interactive-danger-default";
+    readonly DangerHover: "interactive-danger-hover";
+    readonly DangerPressed: "interactive-danger-pressed";
+    readonly ExpressiveDefaultEnd: "interactive-expressive-default-end";
+    readonly ExpressiveDefaultMid: "interactive-expressive-default-mid";
+    readonly ExpressiveDefaultStart: "interactive-expressive-default-start";
+    readonly ExpressiveHoverEnd: "interactive-expressive-hover-end";
+    readonly ExpressiveHoverMid: "interactive-expressive-hover-mid";
+    readonly ExpressiveHoverStart: "interactive-expressive-hover-start";
+    readonly ExpressivePressedEnd: "interactive-expressive-pressed-end";
+    readonly ExpressivePressedMid: "interactive-expressive-pressed-mid";
+    readonly ExpressivePressedStart: "interactive-expressive-pressed-start";
+    readonly PrimaryDefault: "interactive-primary-default";
+    readonly PrimaryHover: "interactive-primary-hover";
+    readonly PrimaryPressed: "interactive-primary-pressed";
+    readonly SecondaryDefault: "interactive-secondary-default";
+    readonly SecondaryHover: "interactive-secondary-hover";
+    readonly SecondaryPressed: "interactive-secondary-pressed";
+    readonly SuccessDefault: "interactive-success-default";
+    readonly SuccessHover: "interactive-success-hover";
+    readonly SuccessPressed: "interactive-success-pressed";
 };
-export type FocusColor = `${(typeof FocusColor)[keyof typeof FocusColor]}`;
-export declare namespace FocusColor {
-    type Ring = typeof FocusColor.Ring;
+export type InteractiveColor = `${(typeof InteractiveColor)[keyof typeof InteractiveColor]}`;
+export declare namespace InteractiveColor {
+    type DangerDefault = typeof InteractiveColor.DangerDefault;
+    type DangerHover = typeof InteractiveColor.DangerHover;
+    type DangerPressed = typeof InteractiveColor.DangerPressed;
+    type ExpressiveDefaultEnd = typeof InteractiveColor.ExpressiveDefaultEnd;
+    type ExpressiveDefaultMid = typeof InteractiveColor.ExpressiveDefaultMid;
+    type ExpressiveDefaultStart = typeof InteractiveColor.ExpressiveDefaultStart;
+    type ExpressiveHoverEnd = typeof InteractiveColor.ExpressiveHoverEnd;
+    type ExpressiveHoverMid = typeof InteractiveColor.ExpressiveHoverMid;
+    type ExpressiveHoverStart = typeof InteractiveColor.ExpressiveHoverStart;
+    type ExpressivePressedEnd = typeof InteractiveColor.ExpressivePressedEnd;
+    type ExpressivePressedMid = typeof InteractiveColor.ExpressivePressedMid;
+    type ExpressivePressedStart = typeof InteractiveColor.ExpressivePressedStart;
+    type PrimaryDefault = typeof InteractiveColor.PrimaryDefault;
+    type PrimaryHover = typeof InteractiveColor.PrimaryHover;
+    type PrimaryPressed = typeof InteractiveColor.PrimaryPressed;
+    type SecondaryDefault = typeof InteractiveColor.SecondaryDefault;
+    type SecondaryHover = typeof InteractiveColor.SecondaryHover;
+    type SecondaryPressed = typeof InteractiveColor.SecondaryPressed;
+    type SuccessDefault = typeof InteractiveColor.SuccessDefault;
+    type SuccessHover = typeof InteractiveColor.SuccessHover;
+    type SuccessPressed = typeof InteractiveColor.SuccessPressed;
 }
 export declare const LinkColor: {
     readonly Default: "link-default";
@@ -222,50 +180,36 @@ export declare namespace LinkColor {
     type Hover = typeof LinkColor.Hover;
     type Visited = typeof LinkColor.Visited;
 }
-export declare const PaletteColor: {
-    readonly P1: "palette-1";
-    readonly P2: "palette-2";
-    readonly P3: "palette-3";
-    readonly P4: "palette-4";
-    readonly P5: "palette-5";
-    readonly P6: "palette-6";
-    readonly P7: "palette-7";
-    readonly P8: "palette-8";
-    readonly P9: "palette-9";
-    readonly P10: "palette-10";
-    readonly P11: "palette-11";
-    readonly P12: "palette-12";
-    readonly Orange: "palette-orange";
-    readonly Blue: "palette-blue";
-    readonly Green: "palette-green";
-    readonly Purple: "palette-purple";
-    readonly Pink: "palette-pink";
-    readonly Yellow: "palette-yellow";
-    readonly Teal: "palette-teal";
-    readonly Red: "palette-red";
+export declare const ScrimColor: {
+    readonly Default: "scrim-default";
+    readonly Heavy: "scrim-heavy";
+    readonly Light: "scrim-light";
 };
-export type PaletteColor = `${(typeof PaletteColor)[keyof typeof PaletteColor]}`;
-export declare namespace PaletteColor {
-    type P1 = typeof PaletteColor.P1;
-    type P2 = typeof PaletteColor.P2;
-    type P3 = typeof PaletteColor.P3;
-    type P4 = typeof PaletteColor.P4;
-    type P5 = typeof PaletteColor.P5;
-    type P6 = typeof PaletteColor.P6;
-    type P7 = typeof PaletteColor.P7;
-    type P8 = typeof PaletteColor.P8;
-    type P9 = typeof PaletteColor.P9;
-    type P10 = typeof PaletteColor.P10;
-    type P11 = typeof PaletteColor.P11;
-    type P12 = typeof PaletteColor.P12;
-    type Orange = typeof PaletteColor.Orange;
-    type Blue = typeof PaletteColor.Blue;
-    type Green = typeof PaletteColor.Green;
-    type Purple = typeof PaletteColor.Purple;
-    type Pink = typeof PaletteColor.Pink;
-    type Yellow = typeof PaletteColor.Yellow;
-    type Teal = typeof PaletteColor.Teal;
-    type Red = typeof PaletteColor.Red;
+export type ScrimColor = `${(typeof ScrimColor)[keyof typeof ScrimColor]}`;
+export declare namespace ScrimColor {
+    type Default = typeof ScrimColor.Default;
+    type Heavy = typeof ScrimColor.Heavy;
+    type Light = typeof ScrimColor.Light;
+}
+export declare const ScrollbarColor: {
+    readonly Thumb: "scrollbar-thumb";
+    readonly ThumbHover: "scrollbar-thumb-hover";
+    readonly Track: "scrollbar-track";
+};
+export type ScrollbarColor = `${(typeof ScrollbarColor)[keyof typeof ScrollbarColor]}`;
+export declare namespace ScrollbarColor {
+    type Thumb = typeof ScrollbarColor.Thumb;
+    type ThumbHover = typeof ScrollbarColor.ThumbHover;
+    type Track = typeof ScrollbarColor.Track;
+}
+export declare const SelectionColor: {
+    readonly Bg: "selection-bg";
+    readonly Text: "selection-text";
+};
+export type SelectionColor = `${(typeof SelectionColor)[keyof typeof SelectionColor]}`;
+export declare namespace SelectionColor {
+    type Bg = typeof SelectionColor.Bg;
+    type Text = typeof SelectionColor.Text;
 }
 export declare const SkeletonColor: {
     readonly Base: "skeleton-base";
@@ -276,6 +220,62 @@ export declare namespace SkeletonColor {
     type Base = typeof SkeletonColor.Base;
     type Shimmer = typeof SkeletonColor.Shimmer;
 }
+export declare const StatusColor: {
+    readonly ApprovedBg: "status-approved-bg";
+    readonly ApprovedText: "status-approved-text";
+    readonly DraftBg: "status-draft-bg";
+    readonly DraftText: "status-draft-text";
+    readonly FailedBg: "status-failed-bg";
+    readonly FailedText: "status-failed-text";
+    readonly ProgressBg: "status-progress-bg";
+    readonly ProgressText: "status-progress-text";
+    readonly ReviewBg: "status-review-bg";
+    readonly ReviewText: "status-review-text";
+};
+export type StatusColor = `${(typeof StatusColor)[keyof typeof StatusColor]}`;
+export declare namespace StatusColor {
+    type ApprovedBg = typeof StatusColor.ApprovedBg;
+    type ApprovedText = typeof StatusColor.ApprovedText;
+    type DraftBg = typeof StatusColor.DraftBg;
+    type DraftText = typeof StatusColor.DraftText;
+    type FailedBg = typeof StatusColor.FailedBg;
+    type FailedText = typeof StatusColor.FailedText;
+    type ProgressBg = typeof StatusColor.ProgressBg;
+    type ProgressText = typeof StatusColor.ProgressText;
+    type ReviewBg = typeof StatusColor.ReviewBg;
+    type ReviewText = typeof StatusColor.ReviewText;
+}
+export declare const TextColor: {
+    readonly Accent: "text-accent";
+    readonly Decorative: "text-decorative";
+    readonly Failure: "text-failure";
+    readonly Foreground: "text-foreground";
+    readonly Info: "text-info";
+    readonly Inverse: "text-inverse";
+    readonly Muted: "text-muted";
+    readonly Placeholder: "text-placeholder";
+    readonly Primary: "text-primary";
+    readonly Secondary: "text-secondary";
+    readonly Success: "text-success";
+    readonly Tertiary: "text-tertiary";
+    readonly Warning: "text-warning";
+};
+export type TextColor = `${(typeof TextColor)[keyof typeof TextColor]}`;
+export declare namespace TextColor {
+    type Accent = typeof TextColor.Accent;
+    type Decorative = typeof TextColor.Decorative;
+    type Failure = typeof TextColor.Failure;
+    type Foreground = typeof TextColor.Foreground;
+    type Info = typeof TextColor.Info;
+    type Inverse = typeof TextColor.Inverse;
+    type Muted = typeof TextColor.Muted;
+    type Placeholder = typeof TextColor.Placeholder;
+    type Primary = typeof TextColor.Primary;
+    type Secondary = typeof TextColor.Secondary;
+    type Success = typeof TextColor.Success;
+    type Tertiary = typeof TextColor.Tertiary;
+    type Warning = typeof TextColor.Warning;
+}
 export declare const TooltipColor: {
     readonly Bg: "tooltip-bg";
     readonly Text: "tooltip-text";
@@ -285,46 +285,79 @@ export declare namespace TooltipColor {
     type Bg = typeof TooltipColor.Bg;
     type Text = typeof TooltipColor.Text;
 }
-export declare const CodeColor: {
-    readonly Bg: "code-bg";
-    readonly Text: "code-text";
-    readonly Border: "code-border";
+export declare const VizChartColor: {
+    readonly Blue: "viz-chart-blue";
+    readonly Green: "viz-chart-green";
+    readonly Lime: "viz-chart-lime";
+    readonly Magenta: "viz-chart-magenta";
+    readonly Neutral: "viz-chart-neutral";
+    readonly Pink: "viz-chart-pink";
+    readonly Purple: "viz-chart-purple";
+    readonly Red: "viz-chart-red";
+    readonly Teal: "viz-chart-teal";
+    readonly Yellow: "viz-chart-yellow";
 };
-export type CodeColor = `${(typeof CodeColor)[keyof typeof CodeColor]}`;
-export declare namespace CodeColor {
-    type Bg = typeof CodeColor.Bg;
-    type Text = typeof CodeColor.Text;
-    type Border = typeof CodeColor.Border;
+export type VizChartColor = `${(typeof VizChartColor)[keyof typeof VizChartColor]}`;
+export declare namespace VizChartColor {
+    type Blue = typeof VizChartColor.Blue;
+    type Green = typeof VizChartColor.Green;
+    type Lime = typeof VizChartColor.Lime;
+    type Magenta = typeof VizChartColor.Magenta;
+    type Neutral = typeof VizChartColor.Neutral;
+    type Pink = typeof VizChartColor.Pink;
+    type Purple = typeof VizChartColor.Purple;
+    type Red = typeof VizChartColor.Red;
+    type Teal = typeof VizChartColor.Teal;
+    type Yellow = typeof VizChartColor.Yellow;
 }
-export declare const ScrollbarColor: {
-    readonly Track: "scrollbar-track";
-    readonly Thumb: "scrollbar-thumb";
-    readonly ThumbHover: "scrollbar-thumb-hover";
+export declare const VizOverlayColor: {
+    readonly Blue: "viz-overlay-blue";
+    readonly Green: "viz-overlay-green";
+    readonly Lime: "viz-overlay-lime";
+    readonly Magenta: "viz-overlay-magenta";
+    readonly Neutral: "viz-overlay-neutral";
+    readonly Pink: "viz-overlay-pink";
+    readonly Purple: "viz-overlay-purple";
+    readonly Red: "viz-overlay-red";
+    readonly Teal: "viz-overlay-teal";
+    readonly Yellow: "viz-overlay-yellow";
 };
-export type ScrollbarColor = `${(typeof ScrollbarColor)[keyof typeof ScrollbarColor]}`;
-export declare namespace ScrollbarColor {
-    type Track = typeof ScrollbarColor.Track;
-    type Thumb = typeof ScrollbarColor.Thumb;
-    type ThumbHover = typeof ScrollbarColor.ThumbHover;
+export type VizOverlayColor = `${(typeof VizOverlayColor)[keyof typeof VizOverlayColor]}`;
+export declare namespace VizOverlayColor {
+    type Blue = typeof VizOverlayColor.Blue;
+    type Green = typeof VizOverlayColor.Green;
+    type Lime = typeof VizOverlayColor.Lime;
+    type Magenta = typeof VizOverlayColor.Magenta;
+    type Neutral = typeof VizOverlayColor.Neutral;
+    type Pink = typeof VizOverlayColor.Pink;
+    type Purple = typeof VizOverlayColor.Purple;
+    type Red = typeof VizOverlayColor.Red;
+    type Teal = typeof VizOverlayColor.Teal;
+    type Yellow = typeof VizOverlayColor.Yellow;
 }
-export declare const SelectionColor: {
-    readonly Bg: "selection-bg";
-    readonly Text: "selection-text";
+export declare const BrandColor: {
+    readonly Primary: "brand-primary";
+    readonly Accent: "brand-accent";
 };
-export type SelectionColor = `${(typeof SelectionColor)[keyof typeof SelectionColor]}`;
-export declare namespace SelectionColor {
-    type Bg = typeof SelectionColor.Bg;
-    type Text = typeof SelectionColor.Text;
+export type BrandColor = `${(typeof BrandColor)[keyof typeof BrandColor]}`;
+export declare namespace BrandColor {
+    type Primary = typeof BrandColor.Primary;
+    type Accent = typeof BrandColor.Accent;
 }
-export type Color = ActionColor | BackgroundColor | BrandColor | IconColor | SemanticColor | StatusColor | TextColor | OverlayColor | FocusColor | LinkColor | PaletteColor | SkeletonColor | TooltipColor | CodeColor | ScrollbarColor | SelectionColor;
-/**
- * Tokens valid for text and icon color. Deliberately a subset of
- * {@link Color}: most other tokens (`BackgroundColor`, `BorderColor`,
- * `ScrollbarColor`, `SkeletonColor`, `OverlayColor`, `FocusColor`, ...)
- * describe surfaces, borders, or component-specific chrome, not text/icon
- * color — accepting them here would be a category error, not added
- * flexibility.
- */
+export declare const SemanticColor: {
+    readonly Success: "semantic-success";
+    readonly Destructive: "semantic-destructive";
+    readonly Info: "semantic-info";
+    readonly Warning: "semantic-warning";
+};
+export type SemanticColor = `${(typeof SemanticColor)[keyof typeof SemanticColor]}`;
+export declare namespace SemanticColor {
+    type Success = typeof SemanticColor.Success;
+    type Destructive = typeof SemanticColor.Destructive;
+    type Info = typeof SemanticColor.Info;
+    type Warning = typeof SemanticColor.Warning;
+}
+export type Color = BackgroundColor | BrandColor | CodeColor | FocusColor | IconColor | InteractiveColor | LinkColor | ScrimColor | ScrollbarColor | SelectionColor | SemanticColor | SkeletonColor | StatusColor | TextColor | TooltipColor | VizChartColor | VizOverlayColor;
 export type ThemeableColor = TextColor | IconColor | BrandColor;
 /**
  * Whether a value is one of the {@link ThemeableColor} tokens — which
@@ -335,10 +368,12 @@ export type ThemeableColor = TextColor | IconColor | BrandColor;
  * e.g. user-defined palettes) use this to tell the two apart at render time.
  */
 export declare function isColorToken(color: string): color is ThemeableColor;
+/** Every `Color` value. Generated — do not hand-maintain. */
+export declare const ALL_COLORS: readonly Color[];
 export declare const bgColorClass: (color: Color, elementState?: ElementState) => string;
 /**
  * Resolves a design-token color to a ready-to-use CSS value, e.g.
- * `var(--color-action-primary-primary)`. Safe to drop directly into an
+ * `var(--color-content-text-primary)`. Safe to drop directly into an
  * inline `style` prop (`style={{ color: getColorCssVar(TextColor.Success) }}`)
  * or wrap in a Tailwind arbitrary value (`` `bg-[${getColorCssVar(color)}]` ``)
  * — don't wrap the result in `var(...)` yourself, it's already included.