@devoinc/genesys-tokens-types/dist/brand.d.ts

Type declarations for @devoinc/genesys-tokens

export interface Brand {
    meta:  Meta;
    alias: Alias;
    cmp:   BrandCmp;
}

export interface Alias {
    breakpoints:  Breakpoints;
    color:        AliasColor;
    elevation:    AliasElevation;
    charts:       Charts;
    fields:       Fields;
    handlers:     Handlers;
    menus:        Menus;
    scrollbars:   Scrollbars;
    typographies: Typographies;
    mutation:     AliasMutation;
    shape:        AliasShape;
    size:         AliasSize;
    space:        AliasSpace;
    typo:         AliasTypo;
}

export interface Breakpoints {
    mediaQuery: MediaQuery;
}

export interface MediaQuery {
    xs?:   string;
    sm?:   string;
    md:    string;
    lg?:   string;
    xl?:   string;
    xxl?:  string;
    xxxl?: string;
    xxs?:  string;
    wide?: string;
}

export interface Charts {
    color:         ChartsColor;
    button:        ChartsButton;
    axis:          Axis;
    title:         TitleClass;
    subtitle:      TitleClass;
    tooltip:       ChartsTooltip;
    legend:        ChartsLegend;
    menu:          ChartsMenu;
    rangeSelector: RangeSelector;
    scrollbar:     Scrollbar;
    plotOptions:   PlotOptions;
    map:           ChartsMap;
}

export interface Axis {
    labels:        TitleClass;
    line:          AxisLine;
    gridLine:      GridLine;
    minorGridLine: GridLine;
    tick:          GridLine;
    title:         UserDetailsAvatarDomain;
}

export interface GridLine {
    color: ColorClass;
}

export interface ColorClass {
    border: SpaceValue;
}

export interface SpaceValue {
    base: string;
}

export interface TitleClass {
    color: LabelsColor;
    typo:  LabelsTypo;
}

export interface LabelsColor {
    text: SpaceValue;
}

export interface LabelsTypo {
    fontSize:   BorderSizeClass;
    fontWeight: SpaceValue;
}

export interface BorderSizeClass {
    md: string;
}

export interface AxisLine {
    color: PurpleColor;
}

export interface PurpleColor {
    border: BorderClass;
}

export interface BorderClass {
    base:   string;
    strong: string;
}

export interface UserDetailsAvatarDomain {
    color: LabelsColor;
}

export interface ChartsButton {
    color: FluffyColor;
    shape: PurpleShape;
}

export interface FluffyColor {
    fill: TextClass;
    text: TextClass;
}

export interface TextClass {
    enabled: string;
    hovered: string;
}

export interface PurpleShape {
    border:       TextClass;
    borderRadius: BorderSizeClass;
}

export interface ChartsColor {
    background: SpaceValue;
    fill:       PurpleFill;
}

export interface PurpleFill {
    heatRange: { [key: string]: string };
    basic:     { [key: string]: string };
}

export interface ChartsLegend {
    color: LegendColor;
    space: LegendSpace;
    shape: LegendShape;
    title: LegendTitle;
    item:  LegendItem;
}

export interface LegendColor {
    background: SpaceValue;
    text:       SpaceValue;
}

export interface LegendItem {
    typo:  PurpleTypo;
    color: LinkLegalColor;
}

export interface LinkLegalColor {
    text: TextClass;
}

export interface PurpleTypo {
    fontSize:       BorderSizeClass;
    fontWeight:     TextClass;
    textDecoration: TextClass;
}

export interface LegendShape {
    borderSize:   BorderSizeClass;
    borderRadius: BorderSizeClass;
}

export interface LegendSpace {
    padding: BorderSizeClass;
}

export interface LegendTitle {
    typo: DataLabelsTypo;
}

export interface DataLabelsTypo {
    fontSize: BorderSizeClass;
}

export interface ChartsMap {
    color: TentacledColor;
}

export interface TentacledColor {
    background: PurpleBackground;
    text:       PurpleText;
    border:     PurpleBorder;
}

export interface PurpleBackground {
    landscape: Landscape;
    water:     SpaceValue;
    road:      SpaceValue;
    poi:       Poi;
}

export interface Landscape {
    base:    HandlerEnum;
    manMade: EditorOverviewRulerEnum;
}

export enum HandlerEnum {
    RGBA2552552551 = "rgba(255,255,255,1)",
    RGBA25525525512 = "rgba(255,255,255,.12)",
}

export enum EditorOverviewRulerEnum {
    F5F8Fa = "#F5F8FA",
    RGBA25525525524 = "rgba(255,255,255,.24)",
}

export interface Poi {
    base: App;
    park: string;
}

export enum App {
    F0F3F5 = "#F0F3F5",
    F0Fffa = "#F0FFFA",
    Faf0F0 = "#FAF0F0",
    Fff9E6 = "#FFF9E6",
    RGBA25525525504 = "rgba(255,255,255,.04)",
}

export interface PurpleBorder {
    base:  EditorIndentGuideActiveEnum;
    label: HandlerEnum;
    road:  Road;
}

export enum EditorIndentGuideActiveEnum {
    RGBA25525525524 = "rgba(255,255,255,.24)",
    The9Db0Bd = "#9DB0BD",
}

export interface Road {
    base:  EditorIndentGuideEnum;
    label: EditorOverviewRulerEnum;
}

export enum EditorIndentGuideEnum {
    D62433 = "#D62433",
    E1Eaf0 = "#E1EAF0",
    F7B94F = "#F7B94F",
    RGBA25525525508 = "rgba(255,255,255,.08)",
    The0Aa672 = "#0AA672",
}

export interface PurpleText {
    base: CheckedEnum;
    road: SpaceValue;
}

export enum CheckedEnum {
    RGBA2552552551 = "rgba(255,255,255,1)",
    The233038 = "#233038",
}

export interface ChartsMenu {
    color: MenuColor;
    shape: MenuShape;
    space: LegendSpace;
    item:  PurpleItem;
}

export interface MenuColor {
    background: SpaceValue;
}

export interface PurpleItem {
    color:    LegalIconColor;
    shape:    MenuShape;
    space:    LegendSpace;
    typo:     DataLabelsTypo;
    mutation: PurpleMutation;
}

export interface LegalIconColor {
    background: TextClass;
    text:       TextClass;
}

export interface PurpleMutation {
    transitionDuration: SpaceValue;
}

export interface MenuShape {
    borderRadius: BorderSizeClass;
}

export interface PlotOptions {
    series:      Series;
    box:         LabelIcon;
    candlestick: Candlestick;
    errorBar:    LabelIcon;
    map:         PlotOptionsMap;
}

export interface LabelIcon {
    color: LabelIconColor;
}

export interface LabelIconColor {
    fill: SpaceValue;
}

export interface Candlestick {
    color: CandlestickColor;
}

export interface CandlestickColor {
    fill:   FluffyFill;
    border: FluffyBorder;
}

export interface FluffyBorder {
    base: string;
    up:   string;
}

export interface FluffyFill {
    up: string;
}

export interface PlotOptionsMap {
    color: StickyColor;
}

export interface StickyColor {
    border: SpaceValue;
    fill:   TentacledFill;
}

export interface TentacledFill {
    null: string;
}

export interface Series {
    shape:      SeriesShape;
    dataLabels: DataLabels;
}

export interface DataLabels {
    color: LabelsColor;
    typo:  DataLabelsTypo;
}

export interface SeriesShape {
    borderSize: BorderSizeClass;
}

export interface RangeSelector {
    input: RangeSelectorInput;
    label: UserDetailsAvatarDomain;
}

export interface RangeSelectorInput {
    color: IndigoColor;
}

export interface IndigoColor {
    background: ColorLink;
    border:     ColorLink;
    text:       ColorLink;
}

export interface ColorLink {
    enabled: string;
}

export interface Scrollbar {
    size:   ScrollbarSize;
    space:  ScrollbarSpace;
    track:  ScrollbarTrack;
    thumb:  ScrollbarThumb;
    riffle: LabelIcon;
}

export interface ScrollbarSize {
    square: BorderSizeClass;
}

export interface ScrollbarSpace {
    margin: BorderSizeClass;
}

export interface ScrollbarThumb {
    color: ThumbColor;
    shape: LegendShape;
}

export interface ThumbColor {
    backdrop: SearchCancelClass;
}

export interface SearchCancelClass {
    base:    string;
    hovered: string;
}

export interface ScrollbarTrack {
    color: IndecentColor;
    shape: LegendShape;
}

export interface IndecentColor {
    backdrop: SpaceValue;
}

export interface ChartsTooltip {
    color:         LegendColor;
    shape:         LegendShape;
    typo:          TooltipTypo;
    header:        TooltipHeader;
    groupTitle:    GroupTitle;
    item:          TooltipItem;
    itemSymbol:    ItemSymbol;
    itemLabelLeft: ItemLabelLeft;
    itemValue:     ItemValue;
    total:         Total;
    totalLabel:    ItemLabelLeft;
}

export interface GroupTitle {
    space: GroupTitleSpace;
    typo:  GroupTitleTypo;
}

export interface GroupTitleSpace {
    padding: string;
}

export interface GroupTitleTypo {
    fontSize:       string;
    fontWeight:     string;
    textTransform?: string;
    letterSpacing:  string;
    lineHeight?:    string;
}

export interface TooltipHeader {
    space: ContentImgSpace;
    typo:  HeaderTypo;
}

export interface ContentImgSpace {
    marginBottom: string;
}

export interface HeaderTypo {
    textAlign:  string;
    fontWeight: string;
}

export interface TooltipItem {
    color: HilariousColor;
    shape: HandlersShape;
    space: GroupTitleSpace;
    size:  CollapseSize;
    typo:  BackdropTypo;
}

export interface HilariousColor {
    background: FontWeightClass;
}

export interface FontWeightClass {
    base:   string;
    active: string;
}

export interface HandlersShape {
    borderRadius: BorderRadiusEnum;
}

export enum BorderRadiusEnum {
    The02Rem = "0.2rem",
    The04Rem = "0.4rem",
    The06Rem = "0.6rem",
    The50 = "50%",
    The999Rem = "999rem",
}

export interface CollapseSize {
    minHeight: string;
}

export interface BackdropTypo {
    fontSize: string;
}

export interface ItemLabelLeft {
    typo: ItemLabelLeftTypo;
}

export interface ItemLabelLeftTypo {
    fontWeight: string;
}

export interface ItemSymbol {
    size:  ItemSymbolSize;
    space: ItemSymbolSpace;
}

export interface ItemSymbolSize {
    square: string;
}

export interface ItemSymbolSpace {
    marginRight: string;
}

export interface ItemValue {
    space: ItemValueSpace;
    typo:  ItemValueTypo;
}

export interface ItemValueSpace {
    paddingLeft: string;
}

export interface ItemValueTypo {
    textAlign: string;
}

export interface Total {
    space: TotalSpace;
}

export interface TotalSpace {
    margin:  string;
    padding: string;
}

export interface TooltipTypo {
    fontSize:   SquareClass;
    lineHeight: SquareClass;
}

export interface SquareClass {
    sm?:       string;
    md:        string;
    lg?:       string;
    xs?:       string;
    xl?:       string;
    xxs?:      string;
    xxl?:      string;
    relative?: string;
    wide?:     string;
}

export interface AliasColor {
    background: FluffyBackground;
    border:     TentacledBorder;
    shadow:     Shadow;
    text:       FluffyText;
}

export interface FluffyBackground {
    action:   BackgroundAction;
    app:      App;
    backdrop: PurpleBackdrop;
    feedback: { [key: string]: BlendBase };
    handler:  HandlerEnum;
    social:   Social;
    surface:  BackgroundSurface;
    track:    FillClass;
}

export interface BackgroundAction {
    accentHigh:   AccentClass;
    accent:       AccentClass;
    neutral:      AccentClass;
    quiet:        AccentClass;
    error:        AccentClass;
    success:      AccentClass;
    warning:      AccentClass;
    help:         AccentClass;
    info:         AccentClass;
    blendBase:    AccentClass;
    blendInverse: AccentClass;
    blendError:   AccentClass;
    blendSuccess: AccentClass;
    blendWarning: AccentClass;
    blendHelp:    AccentClass;
    blendInfo:    AccentClass;
    backdrop?:    ActionBackdrop;
}

export interface AccentClass {
    enabled:    string;
    hovered:    string;
    focused:    string;
    pressed:    string;
    expanded?:  string;
    selected?:  string;
    activated?: string;
    disabled:   string;
}

export interface ActionBackdrop {
    base:    BaseClass;
    inverse: BaseClass;
}

export interface BaseClass {
    highlighted?: string;
    expanded?:    string;
    hovered:      string;
    focused:      string;
    pressed:      string;
}

export interface PurpleBackdrop {
    dark:      Body;
    light:     Body;
    primary:   Body;
    secondary: Body;
    error:     Body;
    success:   Body;
    warning:   Body;
    help:      Body;
    info:      Body;
}

export interface Body {
    weakest?:   string;
    weaker:     string;
    weak:       string;
    base:       string;
    strong:     string;
    stronger?:  string;
    strongest?: string;
    opaque?:    string;
    inverse?:   HandlerEnum;
}

export interface BlendBase {
    weaker?:    string;
    weak:       string;
    base:       string;
    strong?:    string;
    stronger?:  string;
    strongest?: string;
    disabled?:  string;
    inverse?:   string;
}

export interface Social {
    twitter:    string;
    linkedin:   string;
    youtube:    string;
    googlePlus: string;
}

export interface BackgroundSurface {
    base:      SurfaceBase;
    inverse:   Inverse;
    primary:   NeutralClass;
    secondary: NeutralClass;
    neutral:   NeutralClass;
    error:     NeutralClass;
    success:   NeutralClass;
    warning:   NeutralClass;
    help:      NeutralClass;
    info:      NeutralClass;
    backdrop:  SurfaceBackdrop;
    blend:     Blend;
}

export interface SurfaceBackdrop {
    base:    BackdropBase;
    inverse: BackdropBase;
}

export interface BackdropBase {
    hovered:   string;
    focused:   string;
    pressed:   string;
    expanded:  string;
    weakest:   string;
    weaker:    string;
    weak:      string;
    base:      string;
    strong:    string;
    stronger:  string;
    strongest: string;
}

export interface SurfaceBase {
    base:        HandlerEnum;
    raised:      EditorOverviewRulerEnum;
    featured:    App;
    expanded:    App;
    readonly:    string;
    created:     Created;
    deleted:     App;
    highlighted: EditorOverviewRulerEnum;
    modified:    string;
    selected:    string;
    activated:   string;
}

export enum Created {
    E1Eaf0 = "#E1EAF0",
    E1Faf2 = "#E1FAF2",
    Fad4D4 = "#FAD4D4",
    Faecd5 = "#FAECD5",
    RGBA25525525508 = "rgba(255,255,255,.08)",
}

export interface Blend {
    light:   Body;
    dark:    Body;
    error:   Body;
    success: Body;
    warning: Body;
    info:    Body;
    help:    Body;
}

export interface NeutralClass {
    base: string;
    weak: string;
}

export interface Inverse {
    base:        string;
    readonly:    App;
    created:     string;
    deleted:     Deleted;
    selected:    string;
    highlighted: CheckedEnum;
    modified:    string;
    activated:   string;
}

export enum Deleted {
    A76900 = "#A76900",
    RGBA25525525544 = "rgba(255,255,255,.44)",
    The056B49 = "#056B49",
    The81919C = "#81919C",
    The8F0E19 = "#8F0E19",
}

export interface FillClass {
    base?:    string;
    blend?:   string;
    error:    string;
    success:  string;
    warning:  string;
    info?:    string;
    help?:    string;
    inverse?: HandlerEnum;
    default?: string;
}

export interface TentacledBorder {
    elevation: DepthClass;
    feedback:  Feedback;
    separator: BorderSeparator;
    surface:   BorderSurface;
}

export interface DepthClass {
    ground:            string;
    raised?:           string;
    sticky:            Sticky;
    activated:         string;
    draggable:         string;
    overlay:           string;
    popOut:            string;
    draggableOverlay?: string;
}

export interface Sticky {
    bottom: string;
    top:    string;
    right:  string;
    left:   string;
}

export interface Feedback {
    primary:     SpaceValue;
    secondary:   BlendBase;
    neutral:     BlendBase;
    base:        BlendBase;
    inverse:     BlendBase;
    error:       BlendBase;
    success:     BlendBase;
    warning:     BlendBase;
    help:        BlendBase;
    info:        BlendBase;
    dataBlue:    BlendBase;
    dataBronze:  BlendBase;
    dataDusk:    BlendBase;
    dataGreen:   BlendBase;
    dataIndigo:  BlendBase;
    dataMagenta: BlendBase;
    dataPurple:  BlendBase;
    dataRed:     BlendBase;
    dataSky:     BlendBase;
    dataSlate:   BlendBase;
    dataTeal:    BlendBase;
}

export interface BorderSeparator {
    base:         Body;
    inverse:      Body;
    blendBase:    Body;
    blendInverse: Body;
}

export interface BorderSurface {
    primary:   SpaceValue;
    secondary: SpaceValue;
    neutral:   SpaceValue;
    base:      BlendBase;
    inverse:   BlendBase;
    error:     BlendBase;
    success:   BlendBase;
    warning:   BlendBase;
    help:      BlendBase;
    info:      BlendBase;
}

export interface Shadow {
    base:    ShadowBase;
    error:   BosShadowClass;
    success: BosShadowClass;
    warning: BosShadowClass;
    info:    BosShadowClass;
    help:    BosShadowClass;
}

export interface ShadowBase {
    enabled: string;
    focused: string;
}

export interface BosShadowClass {
    focused: string;
}

export interface FluffyText {
    action:       BackgroundAction;
    blendBase:    BlendBase;
    blendInverse: BlendBase;
    body:         Body;
    feedback:     { [key: string]: BlendBase };
    heading:      Body;
    hero:         Body;
    lead:         Body;
    link:         ColorLink;
    mono:         Body;
    overline:     Body;
    social:       Social;
    surface:      TextSurface;
}

export interface TextSurface {
    primary:   NeutralClass;
    secondary: NeutralClass;
    neutral:   BlendBase;
    error:     BlendBase;
    success:   BlendBase;
    warning:   BlendBase;
    help:      BlendBase;
    info:      BlendBase;
}

export interface AliasElevation {
    boxShadow:  PurpleBoxShadow;
    textShadow: TextShadow;
    zIndex:     PurpleZIndex;
}

export interface PurpleBoxShadow {
    depth:   DepthClass;
    base:    HelpClass;
    error:   HelpClass;
    success: HelpClass;
    warning: HelpClass;
    info:    HelpClass;
    help:    HelpClass;
    handler: BoxShadowHandler;
}

export interface HelpClass {
    focused:    string;
    focusedExt: string;
}

export interface BoxShadowHandler {
    base: BoxShadow;
}

export interface BoxShadow {
    enabled?: string;
    hovered:  string;
    focused?: string;
    pressed:  string;
}

export interface TextShadow {
    action: TextShadowAction;
}

export interface TextShadowAction {
    secondary: ActionSecondary;
}

export interface ActionSecondary {
    selected: string;
}

export interface PurpleZIndex {
    depth: Depth;
}

export interface Depth {
    ground:       string;
    raised:       string;
    stickyTop:    number;
    stickyRight:  number;
    stickyBottom: number;
    stickyLeft:   number;
    draggable:    number;
    overlay:      number;
    activated:    number;
    popOut:       number;
}

export interface Fields {
    color:     FieldsColor;
    elevation: FieldsElevation;
    mutation:  FieldsMutation;
    shape:     FieldsShape;
    size:      FieldsSize;
    space:     FieldsSpace;
    icon:      FieldsIcon;
}

export interface FieldsColor {
    background: TentacledBackground;
    text:       TentacledText;
    border:     StickyBorder;
}

export interface TentacledBackground {
    base:     BackgroundInverse;
    inverse?: BackgroundInverse;
    error:    BackgroundInverse;
    success:  BackgroundInverse;
    warning:  BackgroundInverse;
}

export interface BackgroundInverse {
    enabled:   HandlerEnum;
    readonly:  EditorOverviewRulerEnum;
    disabled:  HandlerEnum;
    hovered:   HandlerEnum;
    focused:   HandlerEnum;
    checked:   Checked;
    unchecked: HandlerEnum;
}

export enum Checked {
    E96060 = "#E96060",
    F7B94F = "#F7B94F",
    The0Aa672 = "#0AA672",
    The2A6Cbd = "#2A6CBD",
}

export interface StickyBorder {
    base:     BorderBaseClass;
    inverse?: BorderBaseClass;
    error:    BorderBaseClass;
    success:  BorderBaseClass;
    warning:  BorderBaseClass;
}

export interface BorderBaseClass {
    enabled:  BorderEnabled;
    hovered:  Deleted;
    focused:  Focused;
    readonly: EditorOverviewRulerEnum;
    disabled: EditorIndentGuideEnum;
    checked?: Checked;
    weak:     Weak;
    weaker:   Created;
    weakest:  App;
}

export enum BorderEnabled {
    C3D3De = "#C3D3DE",
    D62433 = "#D62433",
    F7B94F = "#F7B94F",
    RGBA25525525516 = "rgba(255,255,255,.16)",
    The0Aa672 = "#0AA672",
}

export enum Focused {
    D62433 = "#D62433",
    F7B94F = "#F7B94F",
    RGBA25525525544 = "rgba(255,255,255,.44)",
    The0Aa672 = "#0AA672",
    The81919C = "#81919C",
}

export enum Weak {
    D3E0E8 = "#D3E0E8",
    Fab6B6 = "#FAB6B6",
    Fadfaf = "#FADFAF",
    RGBA25525525512 = "rgba(255,255,255,.12)",
    The8Ef5D3 = "#8EF5D3",
}

export interface TentacledText {
    base:     PurpleBase;
    inverse?: PurpleBase;
    error:    PurpleBase;
    success:  PurpleBase;
    warning:  PurpleBase;
}

export interface PurpleBase {
    enabled:     EnabledEnum;
    hovered:     EnabledEnum;
    focused:     Active;
    placeholder: EditorIndentGuideActiveEnum;
    filled:      Filled;
    disabled:    EnabledEnum;
    readonly:    Readonly;
    checked:     CheckedEnum;
    unchecked:   string;
    weak:        string;
    weaker:      string;
}

export enum EnabledEnum {
    D62433 = "#D62433",
    RGBA25525525556 = "rgba(255,255,255,.56)",
    The233038 = "#233038",
}

export enum Filled {
    RGBA25525525572 = "rgba(255,255,255,.72)",
    The233038 = "#233038",
    The8F0E19 = "#8F0E19",
}

export enum Active {
    RGBA25525525564 = "rgba(255,255,255,.64)",
    The182026 = "#182026",
    The66141B = "#66141B",
}

export enum Readonly {
    RGBA25525525556 = "rgba(255,255,255,.56)",
    The233038 = "#233038",
    The8F0E19 = "#8F0E19",
}

export interface FieldsElevation {
    boxShadow: FluffyBoxShadow;
}

export interface FluffyBoxShadow {
    base:    BosShadowClass;
    error:   BosShadowClass;
    success: BosShadowClass;
    warning: BosShadowClass;
}

export interface FieldsIcon {
    color: AmbitiousColor;
    size:  ScrollbarsSize;
    space: PurpleSpace;
}

export interface AmbitiousColor {
    text: TrackClass;
}

export interface TrackClass {
    base?:    string;
    error:    string;
    success:  string;
    warning:  CheckTypeWarning;
    hovered?: Focused;
    info?:    string;
    help?:    string;
}

export enum CheckTypeWarning {
    Cf8911 = "#CF8911",
    F7B94F = "#F7B94F",
    Fadfaf = "#FADFAF",
}

export interface ScrollbarsSize {
    square: HeightClass;
}

export interface HeightClass {
    sm: string;
    md: string;
    lg: string;
}

export interface PurpleSpace {
    pos: SquareClass;
}

export interface FieldsMutation {
    transitionDuration: string;
}

export interface FieldsShape {
    backgroundImage: PurpleBackgroundImage;
    borderRadius:    BorderRadiusEnum;
    borderSize:      PurpleBorderSize;
    opacity:         PurpleOpacity;
}

export interface PurpleBackgroundImage {
    date:         string;
    time:         string;
    search:       string;
    searchCancel: SearchCancelClass;
}

export interface PurpleBorderSize {
    base:  BorderSizeEnum;
    check: BorderRadiusEnum;
}

export enum BorderSizeEnum {
    The01Rem = "0.1rem",
}

export interface PurpleOpacity {
    disabled: OpacityDisabled;
}

export enum OpacityDisabled {
    The4 = ".4",
}

export interface FieldsSize {
    height: SquareClass;
    square: SquareClass;
    width:  LayoutClass;
}

export interface LayoutClass {
    xxs?:      string;
    xs?:       string;
    sm:        string;
    md:        string;
    lg?:       string;
    xl?:       string;
    wide?:     string;
    xxl?:      string;
    xxxs?:     string;
    xxxl?:     string;
    relative?: string;
    full?:     string;
}

export interface FieldsSpace {
    padding: PurplePadding;
}

export interface PurplePadding {
    hor:      SquareClass;
    withIcon: SquareClass;
}

export interface Handlers {
    elevation: HandlersElevation;
    size:      HandlersSize;
    shape:     HandlersShape;
    mutation:  FieldsMutation;
    color:     HandlersColor;
}

export interface HandlersColor {
    background: HandlerEnum;
    text:       CheckedClass;
}

export interface CheckedClass {
    base:    string;
    error:   string;
    warning: string;
    success: string;
}

export interface HandlersElevation {
    boxShadow: BoxShadow;
}

export interface HandlersSize {
    square: PurpleSquare;
}

export interface PurpleSquare {
    xs: string;
    sm: string;
    md: string;
    lg: string;
}

export interface Menus {
    space:            MenusSpace;
    shape:            MenusShape;
    wrapper:          Wrapper;
    list:             CellExpandedContentClass;
    item:             MenusItem;
    itemIcon:         MenusItemIcon;
    itemGroup:        ListItem;
    itemGroupHeading: ItemGroupHeading;
}

export interface MenusItem {
    shape: HandlersShape;
    space: CellActionsSpace;
    size:  CollapseSize;
    color: MenuOptionColor;
}

export interface MenuOptionColor {
    backdrop:   BaseClass;
    background: StickyBackground;
    text:       StickyBackground;
}

export interface StickyBackground {
    created:   string;
    deleted:   string;
    disabled:  string;
    enabled:   string;
    featured?: string;
    expanded:  string;
    hovered:   string;
    focused:   string;
    pressed:   string;
    activated: string;
    selected:  string;
}

export interface CellActionsSpace {
    marginHor: string;
}

export interface ListItem {
    space: ListItemSpace;
}

export interface ListItemSpace {
    marginTop: string;
}

export interface ItemGroupHeading {
    size: ItemGroupHeadingSize;
}

export interface ItemGroupHeadingSize {
    height: string;
}

export interface MenusItemIcon {
    space: ValueIconSpace;
    size:  PurpleSize;
}

export interface PurpleSize {
    square: SquareClass;
}

export interface ValueIconSpace {
    marginRight: HeightClass;
}

export interface CellExpandedContentClass {
    size: ListSize;
}

export interface ListSize {
    maxHeight: string;
}

export interface MenusShape {
    border: IndigoBorder;
}

export interface IndigoBorder {
    separator: string;
}

export interface MenusSpace {
    marginTop: PurpleMarginTop;
}

export interface PurpleMarginTop {
    base:          string;
    isQuiet:       string;
    isGroundLevel: BorderRadiusEnum;
}

export interface Wrapper {
    space: WrapperSpace;
}

export interface WrapperSpace {
    margin: string;
}

export interface AliasMutation {
    transitionDuration: PurpleTransitionDuration;
}

export interface PurpleTransitionDuration {
    action:      string;
    quick:       string;
    blink:       string;
    opacity:     MediaQuery;
    translation: Translation;
    rotation:    { [key: string]: string };
}

export interface Translation {
    hor: HeightClass;
}

export interface Scrollbars {
    size:  ScrollbarsSize;
    track: ScrollbarsTrack;
    thumb: ScrollbarsThumb;
}

export interface ScrollbarsThumb {
    color:    ThumbColor;
    shape:    HandlersShape;
    mutation: ThumbMutation;
}

export interface ThumbMutation {
    transition: string;
}

export interface ScrollbarsTrack {
    color: BackgroundClass;
    shape: HandlersShape;
}

export interface BackgroundClass {
    backdrop: string;
}

export interface AliasShape {
    borderRadius: PurpleBorderRadius;
    borderSize:   FluffyBorderSize;
    opacity:      FluffyOpacity;
}

export interface PurpleBorderRadius {
    sm:       BorderRadiusEnum;
    md:       BorderRadiusEnum;
    lg:       BorderRadiusEnum;
    elevated: BorderRadiusEnum;
    pill:     BorderRadiusEnum;
    full:     BorderRadiusEnum;
}

export interface FluffyBorderSize {
    separator:   SquareClass;
    panel:       SpaceValue;
    header:      SpaceValue;
    base:        BorderSizeBase;
    contextMark: SpaceValue;
}

export interface BorderSizeBase {
    highlighted: BorderRadiusEnum;
    focused:     BorderRadiusEnum;
}

export interface FluffyOpacity {
    disabled: OpacityDisabled;
    blocked:  string;
}

export interface AliasSize {
    width:    PurpleWidth;
    minWidth: MinWidth;
    height:   PurpleHeight;
    square:   FluffySquare;
}

export interface PurpleHeight {
    surface: LayoutClass;
    toolbar: SquareClass;
    action:  SquareClass;
    tag:     SquareClass;
    track:   SquareClass;
}

export interface MinWidth {
    action: SquareClass;
}

export interface FluffySquare {
    handler: SquareClass;
    icon:    SquareIcon;
    thumb:   SquareClass;
    badge:   SquareBadge;
    bullet:  SquareClass;
}

export interface SquareBadge {
    hasContent: SquareClass;
    empty:      SquareClass;
}

export interface SquareIcon {
    base:     BorderedClass;
    inAction: SquareClass;
    isAction: SquareClass;
}

export interface BorderedClass {
    xxxxs?: string;
    xxxs:   string;
    xxs:    string;
    xs:     string;
    sm:     string;
    md:     string;
    lg:     string;
    xl:     string;
    xxl?:   string;
    xxxl?:  string;
    xxxxl?: string;
}

export interface PurpleWidth {
    popover: LayoutClass;
    sidebar: MediaQuery;
}

export interface AliasSpace {
    cmp:    LayoutClass;
    layout: LayoutClass;
}

export interface AliasTypo {
    fontFamily:    PurpleFontFamily;
    fontSize:      FontSize;
    fontWeight:    TextTransformClass;
    letterSpacing: LetterSpacing;
    lineHeight:    LineHeight;
    textTransform: TextTransformClass;
}

export interface PurpleFontFamily {
    action:   AltClass;
    body:     AltClass;
    heading:  AltClass;
    hero:     AltClass;
    icon:     FontFamilyIcon;
    lead:     AltClass;
    link:     AltClass;
    mono:     AltClass;
    overline: AltClass;
}

export interface AltClass {
    fontFaceName: FontFaceNameEnum;
    originalName: OriginalNameEnum;
}

export enum FontFaceNameEnum {
    DevoFontSansSerif = "'Devo Font', sans-serif",
    LtAppFontSansSerif = "'LtAppFont', sans-serif",
    LtIconfontSansSerif = "'lt-iconfont', sans-serif",
    MonoFontMonospace = "'Mono Font', monospace",
}

export enum OriginalNameEnum {
    JetBrainsMono = "JetBrains Mono",
    LtAppFontSansSerif = "'LtAppFont', sans-serif",
    LtIconfontSansSerif = "'lt-iconfont', sans-serif",
    MuseoSans = "Museo Sans",
}

export interface FontFamilyIcon {
    base: AltClass;
    alt:  AltClass;
}

export interface FontSize {
    action:   FontSizeClass;
    body:     FontSizeClass;
    heading:  LineHeightClass;
    hero:     SquareClass;
    icon:     BorderedClass;
    lead:     SquareClass;
    link:     SquareClass;
    mono:     SquareClass;
    overline: SquareClass;
}

export interface FontSizeClass {
    xxs: string;
    xs:  string;
    sm:  string;
    md:  string;
    lg:  string;
    xl:  string;
}

export interface LineHeightClass {
    h6:        string;
    h5:        string;
    h4:        string;
    h3:        string;
    h2:        string;
    h1:        string;
    relative?: string;
}

export interface TextTransformClass {
    action:    string;
    body:      string;
    overline:  string;
    heading:   string;
    hero:      string;
    lead:      string;
    link:      string;
    markers:   string;
    mono:      string;
    shortText: string;
    bolder:    string;
}

export interface LetterSpacing {
    action:   ResetClass;
    body:     ResetClass;
    heading:  ResetClass;
    hero:     ResetClass;
    lead:     ResetClass;
    link:     ResetClass;
    mono:     ResetClass;
    overline: ResetClass;
    reset:    ResetClass;
}

export interface ResetClass {
    em:      string;
    percent: Percent;
}

export enum Percent {
    The0 = "0%",
    The1325 = "13.25%",
    The1925 = "-1.925%",
}

export interface LineHeight {
    action:   LayoutClass;
    body:     LayoutClass;
    heading:  LineHeightClass;
    hero:     SquareClass;
    lead:     SquareClass;
    link:     SquareClass;
    mono:     SquareClass;
    overline: SquareClass;
    reset:    string;
}

export interface Typographies {
    typo: AliasTypo;
}

export interface BrandCmp {
    button:               CmpButton;
    iconButtonDropdown:   IconButtonDropdown;
    iconButtonGoToDocs:   IconButtonGoToDocs;
    iconButtonStatus:     IconButtonStatus;
    iconButtonStop:       IconButtonStop;
    diffEditor:           DiffEditor;
    editor:               Editor;
    highChart:            HighChart;
    calendar:             Calendar;
    dateRange:            DateRange;
    dateTimeRangeControl: DateTimeRangeControl;
    badge:                CmpBadge;
    boxMessage:           BoxMessage;
    decoratorBar:         DecoratorBar;
    helper:               Helper;
    icon:                 CmpIcon;
    inlineMessageBanner:  InlineMessageBanner;
    inlineMessage:        InlineMessage;
    keyValue:             KeyValue;
    loader:               CmpLoader;
    notification:         Notification;
    overlay:              CmpOverlay;
    partitions:           Partitions;
    progressBar:          CmpProgressBar;
    statusMessage:        StatusMessage;
    tag:                  Tag;
    tagGroup:             TagGroup;
    toastList:            ToastList;
    toast:                Toast;
    vaultFrame:           VaultFrame;
    checkboxControl:      CheckboxControl;
    chip:                 Chip;
    colorPicker:          ColorPicker;
    field:                CmpField;
    fieldsCombiner:       FieldsCombiner;
    form:                 Form;
    inputControl:         InputControl;
    label:                CmpLabel;
    radioControl:         RadioControl;
    selectControl:        SelectControl;
    switchControl:        SwitchControl;
    textareaControl:      TextareaControl;
    uploadFiles:          UploadFiles;
    appLayout:            AppLayout;
    buttonGroup:          ButtonGroup;
    dialog:               Dialog;
    divider:              CmpDivider;
    drawer:               Drawer;
    modal:                Modal;
    panel:                Panel;
    panelSection:         PanelSection;
    popover:              Popover;
    splitLayout:          SplitLayout;
    table:                Table;
    toolbar:              Toolbar;
    widget:               Widget;
    avatar:               Avatar;
    thumbnail:            Thumbnail;
    appBar:               AppBar;
    appMenu:              AppMenu;
    collapse:             Collapse;
    contentSwitcher:      ContentSwitcher;
    link:                 CmpLink;
    mainMenu:             MainMenu;
    menu:                 CmpMenu;
    stepper:              Stepper;
    tabs:                 Tabs;
    editableContent:      EditableContent;
    action:               CmpAction;
    blockQuote:           BlockQuote;
    body:                 CmpAction;
    codeBlock:            CodeBlock;
    codeInline:           CodeInline;
    heading:              CmpHeading;
    hero:                 Hero;
    inserted:             Highlighted;
    lead:                 Hero;
    list:                 CmpList;
    listItem:             ListItem;
    mono:                 Hero;
    overline:             Hero;
    highlighted:          Highlighted;
    strong:               Strong;
}

export interface CmpAction {
    typo: ActionTypo;
}

export interface ActionTypo {
    fontSize:      FontSizeClass;
    lineHeight:    FontSizeClass;
    fontFamily:    OriginalNameEnum;
    fontWeight:    string;
    letterSpacing: string;
    textTransform: string;
}

export interface AppBar {
    color:     AppBarColor;
    shape:     CheckTypeClass;
    size:      AppBarSize;
    elevation: AppBarElevation;
    divider:   AppBarDivider;
}

export interface AppBarColor {
    background: string;
    border:     string;
}

export interface AppBarDivider {
    size:  ItemGroupHeadingSize;
    space: WrapperSpace;
    color: AppBarColor;
}

export interface AppBarElevation {
    boxShadow: string;
}

export interface CheckTypeClass {
    borderSize: BorderSizeEnum;
}

export interface AppBarSize {
    height: FluffyHeight;
}

export interface FluffyHeight {
    base:    string;
    compact: string;
}

export interface AppLayout {
    color: AppLayoutColor;
    size:  AppLayoutSize;
    bar:   Bar;
}

export interface Bar {
    elevation: BarElevation;
}

export interface BarElevation {
    zIndex: number;
}

export interface AppLayoutColor {
    background: string;
}

export interface AppLayoutSize {
    height: string;
    width:  string;
}

export interface AppMenu {
    color:              AppLayoutColor;
    size:               AppMenuSize;
    shape:              AppMenuShape;
    mutation:           LogoCompactMutation;
    betaBadge:          BetaBadge;
    footer:             AppMenuFooter;
    header:             AppMenuHeader;
    heading:            AppMenuHeading;
    item:               AppMenuItem;
    itemIcon:           AppMenuItemIcon;
    logoCompact:        LogoCompactClass;
    logo:               LogoCompactClass;
    popoverItemIcon:    PopoverItemIcon;
    popoverItemActions: PopoverItemActions;
    separator:          AppMenuSeparator;
    tooltip:            AppMenuTooltip;
}

export interface BetaBadge {
    color: BetaBadgeColor;
}

export interface BetaBadgeColor {
    background: string;
    text:       string;
}

export interface AppMenuFooter {
    elevation: PurpleElevation;
    shape:     FooterShape;
}

export interface PurpleElevation {
    boxShadow: TentacledBoxShadow;
}

export interface TentacledBoxShadow {
    hasScroll: string;
}

export interface FooterShape {
    borderTop: string;
}

export interface AppMenuHeader {
    elevation: PurpleElevation;
    shape:     HeaderShape;
    size:      ItemGroupHeadingSize;
    space:     FluffySpace;
}

export interface HeaderShape {
    borderBottom: string;
}

export interface FluffySpace {
    paddingTop:    string;
    paddingRight:  PaddingLeftClass;
    paddingBottom: string;
    paddingLeft:   PaddingLeftClass;
    offset?:       PurpleOffset;
}

export interface PurpleOffset {
    base:   string;
    left:   string;
    toIcon: string;
}

export interface PaddingLeftClass {
    base:      string;
    collapsed: string;
}

export interface AppMenuHeading {
    color:    HeadingColor;
    mutation: HeadingMutation;
    space:    TentacledSpace;
    size:     ItemGroupHeadingSize;
}

export interface HeadingColor {
    text: string;
}

export interface HeadingMutation {
    transitionDuration: FluffyTransitionDuration;
}

export interface FluffyTransitionDuration {
    left:           string;
    leftDelay:      string;
    padding:        string;
    transform:      string;
    transformDelay: string;
}

export interface TentacledSpace {
    offset:       PaddingLeftClass;
    paddingLeft:  PaddingLeftClass;
    paddingRight: PaddingLeftClass;
}

export interface AppMenuItem {
    color:    CunningColor;
    mutation: LogoCompactMutation;
    space:    FluffySpace;
    typo:     FluffyTypo;
}

export interface CunningColor {
    background: ColorBackground;
    backdrop:   ColorBackground;
    text:       ColorBackground;
}

export interface ColorBackground {
    base:    string;
    hovered: string;
    active:  string;
}

export interface LogoCompactMutation {
    transitionDuration: TentacledTransitionDuration;
}

export interface TentacledTransitionDuration {
    left?:    string;
    width:    string;
    padding?: string;
    opacity:  string;
}

export interface FluffyTypo {
    fontWeight: FontWeightClass;
}

export interface AppMenuItemIcon {
    space: StickySpace;
    size:  ItemSymbolSize;
}

export interface StickySpace {
    offset: FluffyOffset;
}

export interface FluffyOffset {
    base:     string;
    collapse: string;
}

export interface LogoCompactClass {
    mutation: LogoCompactMutation;
    size:     ListSize;
}

export interface PopoverItemActions {
    mutation: PopoverItemActionsMutation;
}

export interface PopoverItemActionsMutation {
    transitionDuration: TransitionDurationClass;
}

export interface TransitionDurationClass {
    opacity: string;
}

export interface PopoverItemIcon {
    color: PopoverItemIconColor;
    shape: HandlersShape;
    size:  ItemSymbolSize;
}

export interface PopoverItemIconColor {
    background: StickyText;
}

export interface StickyText {
    base:     string;
    featured: string;
}

export interface AppMenuSeparator {
    color:    ShapeClass;
    mutation: SeparatorMutation;
    size:     SeparatorSize;
    space:    IndigoSpace;
}

export interface ShapeClass {
    border: string;
}

export interface SeparatorMutation {
    transitionDuration: StickyTransitionDuration;
}

export interface StickyTransitionDuration {
    left:  string;
    width: string;
}

export interface SeparatorSize {
    width: PaddingLeftClass;
}

export interface IndigoSpace {
    offset: PaddingLeftClass;
}

export interface AppMenuShape {
    borderRight: string;
}

export interface AppMenuSize {
    width:  PaddingLeftClass;
    height: string;
}

export interface AppMenuTooltip {
    space: IndecentSpace;
}

export interface IndecentSpace {
    offset: OffsetClass;
}

export interface OffsetClass {
    horizontal: string;
    vertical:   string;
}

export interface Avatar {
    color:     AvatarColor;
    elevation: AppBarElevation;
    size:      AvatarSize;
    shape:     AvatarShape;
    backdrop:  AvatarBackdrop;
}

export interface AvatarBackdrop {
    color:     BackdropColor;
    mutation:  FieldsMutation;
    typo:      BackdropTypo;
    elevation: AppBarElevation;
}

export interface BackdropColor {
    text: IndigoText;
}

export interface IndigoText {
    lightScheme: HandlerEnum;
    darkScheme:  CheckedEnum;
}

export interface AvatarColor {
    background: HasContentClass;
    text:       HasContentClass;
    border:     EditorIndentGuideActiveEnum;
}

export interface HasContentClass {
    primary:        string;
    secondary:      string;
    neutral:        string;
    blendBase?:     string;
    blendInverse?:  string;
    error:          string;
    success:        string;
    warning:        WarningStrongEnum;
    help:           string;
    info:           string;
    dataBlue?:      string;
    dataBronze:     string;
    dataGreen:      string;
    dataTeal:       string;
    dataSky:        string;
    dataSlate:      string;
    dataIndigo:     string;
    dataDusk:       string;
    dataPurple:     string;
    dataMagenta:    string;
    dataRed?:       string;
    quiet?:         string;
    data_dataBlue?: string;
    red?:           string;
}

export enum WarningStrongEnum {
    F5C776 = "#F5C776",
    F7B94F = "#F7B94F",
    The33250C = "#33250C",
}

export interface AvatarShape {
    borderRadius: FluffyBorderRadius;
    opacity:      PurpleOpacity;
    borderSize:   TentacledBorderSize;
}

export interface FluffyBorderRadius {
    circle:  BorderRadiusEnum;
    rounded: BorderRadiusEnum;
}

export interface TentacledBorderSize {
    bordered: BorderedClass;
}

export interface AvatarSize {
    square: BorderedClass;
}

export interface CmpBadge {
    shape: HandlersShape;
    size:  BadgeSize;
    space: FilterColumnsCellSpace;
    typo:  BadgeTypo;
    color: BadgeColor;
    icon:  BadgeIcon;
}

export interface BadgeColor {
    background: IndigoBackground;
    text:       HasContentClass;
}

export interface IndigoBackground {
    hasContent: HasContentClass;
    isEmpty:    HasContentClass;
}

export interface BadgeIcon {
    size: FluffySize;
}

export interface FluffySize {
    square: SizeSquare;
}

export interface SizeSquare {
    xxs: string;
    xs:  string;
    sm:  string;
    md:  string;
    lg:  string;
}

export interface BadgeSize {
    square: TentacledSquare;
}

export interface TentacledSquare {
    hasContent: MediaQuery;
    isEmpty:    MediaQuery;
}

export interface FilterColumnsCellSpace {
    padding: FluffyPadding;
}

export interface FluffyPadding {
    hor: BorderRadiusEnum;
}

export interface BadgeTypo {
    fontSize: SizeSquare;
}

export interface BlockQuote {
    color: LabelsColor;
    space: BlockQuoteSpace;
}

export interface BlockQuoteSpace {
    padding: TentacledPadding;
}

export interface TentacledPadding {
    alignLeft:  string;
    alignRight: string;
}

export interface BoxMessage {
    shape:   BoxMessageShape;
    space:   BoxMessageSpace;
    color:   BoxMessageColor;
    actions: Actions;
    close:   Close;
    heading: ContentImgClass;
    icon:    BoxMessageIcon;
}

export interface Actions {
    space: ActionsSpace;
}

export interface ActionsSpace {
    marginTop: string;
    gap:       string;
}

export interface Close {
    space: CloseSpace;
}

export interface CloseSpace {
    offset: TentacledOffset;
}

export interface TentacledOffset {
    top:   string;
    right: string;
}

export interface BoxMessageColor {
    background: IndecentBackground;
    border:     IndecentBackground;
}

export interface IndecentBackground {
    subtle?:  App;
    success:  string;
    warning?: string;
    error:    string;
    help?:    string;
    info?:    string;
    base?:    string;
}

export interface ContentImgClass {
    space: ContentImgSpace;
}

export interface BoxMessageIcon {
    color: MagentaColor;
    size:  ItemSymbolSize;
}

export interface MagentaColor {
    text: IndecentText;
}

export interface IndecentText {
    error:   string;
    success: string;
    warning: string;
    help:    string;
    info:    string;
}

export interface BoxMessageShape {
    borderSize:   GapClass;
    borderRadius: BorderRadiusEnum;
}

export interface GapClass {
    base:   string;
    subtle: string;
}

export interface BoxMessageSpace {
    gap:     GapClass;
    padding: GapClass;
}

export interface CmpButton {
    color:     FriskyColor;
    elevation: FluffyElevation;
    mutation:  FieldsMutation;
    space:     ButtonSpace;
    size:      ButtonSize;
    shape:     FluffyShape;
    icon:      ButtonIcon;
    label:     ButtonLabel;
    loader:    ButtonLoader;
}

export interface FriskyColor {
    backdrop:   BoxShadow;
    background: HilariousBackground;
    text:       HilariousBackground;
}

export interface HilariousBackground {
    accent:       Accent;
    accentHigh:   Accent;
    blendBase:    Accent;
    blendInverse: Accent;
    blendError:   AccentClass;
    blendSuccess: AccentClass;
    blendWarning: AccentClass;
    blendHelp:    AccentClass;
    blendInfo:    AccentClass;
    error:        Accent;
    help:         Accent;
    info:         Accent;
    neutral:      Accent;
    quiet:        Accent;
    quietBlend:   Accent;
    success:      Accent;
    warning:      Accent;
}

export interface Accent {
    activated:      string;
    enabled:        string;
    expanded:       string;
    disabled:       string;
    focused:        string;
    hovered:        string;
    loading:        string;
    loadingError:   string;
    loadingSuccess: string;
    pressed:        string;
    selected:       string;
}

export interface FluffyElevation {
    boxShadow: StickyBoxShadow;
}

export interface StickyBoxShadow {
    base:    BosShadowClass;
    error:   BosShadowClass;
    success: BosShadowClass;
    warning: BosShadowClass;
    info:    BosShadowClass;
    help:    BosShadowClass;
}

export interface ButtonIcon {
    typo:  BadgeTypo;
    space: HilariousSpace;
}

export interface HilariousSpace {
    margin: SizeSquare;
    offset: SizeSquare;
}

export interface ButtonLabel {
    typo: BadgeTypo;
}

export interface ButtonLoader {
    size: LoaderSize;
}

export interface LoaderSize {
    width: LayoutClass;
}

export interface FluffyShape {
    borderRadius: TentacledBorderRadius;
}

export interface TentacledBorderRadius {
    medium: BorderRadiusEnum;
    pill:   BorderRadiusEnum;
    full:   BorderRadiusEnum;
}

export interface ButtonSize {
    height:   LayoutClass;
    square:   LayoutClass;
    minWidth: LayoutClass;
}

export interface ButtonSpace {
    padding: MediaQuery;
}

export interface ButtonGroup {
    space: ButtonGroupSpace;
}

export interface ButtonGroupSpace {
    gap: SquareClass;
}

export interface Calendar {
    size:     CalendarSize;
    day:      Day;
    interval: Interval;
    week:     Week;
}

export interface Day {
    color:     DayColor;
    elevation: BarElevation;
    mutation:  FieldsMutation;
    shape:     DayShape;
    size:      ItemSymbolSize;
    space:     WrapperSpace;
}

export interface DayColor {
    background: AmbitiousBackground;
    text:       AmbitiousBackground;
}

export interface AmbitiousBackground {
    base:      string;
    hovered:   string;
    selected?: string;
    activated: string;
}

export interface DayShape {
    borderRadius: StickyBorderRadius;
    opacity:      PurpleOpacity;
}

export interface StickyBorderRadius {
    base:    BorderRadiusEnum;
    corners: BorderRadiusEnum;
}

export interface Interval {
    color: IntervalColor;
    shape: HandlersShape;
    size:  ItemGroupHeadingSize;
}

export interface IntervalColor {
    background: CunningBackground;
    text:       CunningBackground;
}

export interface CunningBackground {
    selected:  string;
    activated: string;
    mixed:     string;
}

export interface CalendarSize {
    minWidth: string;
}

export interface Week {
    color:     LegendColor;
    elevation: BarElevation;
    shape:     HandlersShape;
    size:      ItemSymbolSize;
    space:     WrapperSpace;
}

export interface CheckboxControl {
    color:            FieldsColor;
    elevation:        FieldsElevation;
    mutation:         FieldsMutation;
    shape:            CheckboxControlShape;
    size:             ScrollbarsSize;
    marker:           CheckboxControlMarker;
    controlMarkerSVG: ControlMarkerSVG;
}

export interface ControlMarkerSVG {
    size: ItemSymbolSize;
}

export interface CheckboxControlMarker {
    size: TentacledSize;
}

export interface TentacledSize {
    square: SquareClass;
    width:  FluffyWidth;
    height: TentacledHeight;
}

export interface TentacledHeight {
    mixed: BorderRadiusEnum;
}

export interface FluffyWidth {
    mixed: SquareClass;
}

export interface CheckboxControlShape {
    borderRadius: BorderRadiusEnum;
    borderSize:   BorderRadiusEnum;
    opacity:      PurpleOpacity;
}

export interface Chip {
    color:     ChipColor;
    elevation: ChipElevation;
    mutation:  FieldsMutation;
    space:     AmbitiousSpace;
    size:      ChipSize;
    s