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;
    shape:     HandlersShape;
    icon:      ButtonIcon;
    label:     ChipLabel;
}

export interface ChipColor {
    backdrop:   BaseClass;
    background: AccentClass;
    text:       AccentClass;
}

export interface ChipElevation {
    boxShadow: BosShadowClass;
}

export interface ChipLabel {
    typo: TentacledTypo;
}

export interface TentacledTypo {
    fontSize:      MediaQuery;
    lineHeight:    MediaQuery;
    fontWeight:    string;
    letterSpacing: string;
    textTransform: string;
}

export interface ChipSize {
    height:   MediaQuery;
    minWidth: MediaQuery;
}

export interface AmbitiousSpace {
    padding: StickyPadding;
}

export interface StickyPadding {
    hor: SquareClass;
}

export interface CodeBlock {
    color: MenuColor;
    space: CodeBlockSpace;
}

export interface CodeBlockSpace {
    padding: SpaceValue;
}

export interface CodeInline {
    typo:  CodeInlineTypo;
    space: CodeBlockSpace;
    shape: CodeInlineShape;
    color: AppBarColor;
}

export interface CodeInlineShape {
    borderRadius: BorderRadiusEnum;
    border:       string;
}

export interface CodeInlineTypo {
    fontFamily: FontFaceNameEnum;
}

export interface Collapse {
    color:    CollapseColor;
    mutation: FieldsMutation;
    shape:    CheckTypeClass;
    size:     CollapseSize;
    button:   CollapseButton;
}

export interface CollapseButton {
    color:     MischievousColor;
    elevation: TentacledElevation;
    mutation:  FieldsMutation;
}

export interface MischievousColor {
    background: SearchCancelClass;
}

export interface TentacledElevation {
    bosShadow: BosShadowClass;
}

export interface CollapseColor {
    background: MagentaBackground;
    border:     MagentaBackground;
}

export interface MagentaBackground {
    base:     string;
    expanded: string;
}

export interface ColorPicker {
    color:                  FieldsColor;
    elevation:              FieldsElevation;
    mutation:               FieldsMutation;
    size:                   ColorPickerSize;
    space:                  string;
    shape:                  ColorPickerShape;
    sketchPicker:           SketchPicker;
    sketchPickerInput:      SketchPickerInput;
    sketchPickerHex:        SketchPickerHex;
    sketchPickerFlexBoxFix: SketchPickerFlexBoxFix;
    sketchPickerThumbs:     SketchPickerThumbs;
}

export interface ColorPickerShape {
    borderSize:   BorderSizeEnum;
    borderRadius: IndigoBorderRadius;
}

export interface IndigoBorderRadius {
    base:     BorderRadiusEnum;
    isCircle: BorderRadiusEnum;
}

export interface ColorPickerSize {
    height: HeightClass;
    width:  HeightClass;
}

export interface SketchPicker {
    color:     SketchPickerColor;
    elevation: SketchPickerElevation;
    mutation:  FieldsMutation;
    shape:     HandlersShape;
}

export interface SketchPickerColor {
    background: HandlerEnum;
    border:     EditorIndentGuideEnum;
    text:       string;
}

export interface SketchPickerElevation {
    boxShadow: string;
    zIndex:    number;
}

export interface SketchPickerFlexBoxFix {
    space:    SketchPickerFlexBoxFixSpace;
    maxWidth: string;
}

export interface SketchPickerFlexBoxFixSpace {
    marginTop:  BorderRadiusEnum;
    paddingTop: string;
}

export interface SketchPickerHex {
    maxWidth: string;
}

export interface SketchPickerInput {
    color:     SketchPickerInputColor;
    elevation: ChipElevation;
    shape:     SketchPickerInputShape;
}

export interface SketchPickerInputColor {
    background: HandlerEnum;
    border:     IndecentBorder;
    text:       IndecentBorder;
}

export interface IndecentBorder {
    base:    string;
    hovered: string;
    focused: string;
}

export interface SketchPickerInputShape {
    borderRadius: BorderRadiusEnum;
    borderSize:   string;
}

export interface SketchPickerThumbs {
    space: SketchPickerFlexBoxFixSpace;
}

export interface ContentSwitcher {
    space:  ContentSwitcherSpace;
    size:   ContentSwitcherSize;
    shape:  HandlersShape;
    color:  ContentSwitcherColor;
    button: ContentSwitcherButton;
    item:   ContentSwitcherItem;
}

export interface ContentSwitcherButton {
    color:     BraggadociousColor;
    elevation: StickyElevation;
}

export interface BraggadociousColor {
    background: BoxShadowClass;
    text:       BoxShadowClass;
}

export interface BoxShadowClass {
    activated: string;
}

export interface StickyElevation {
    boxShadow: BoxShadowClass;
}

export interface ContentSwitcherColor {
    background: FriskyBackground;
}

export interface FriskyBackground {
    base:  EditorIndentGuideEnum;
    blend: string;
}

export interface ContentSwitcherItem {
    color:     Color1;
    elevation: IndigoElevation;
}

export interface Color1 {
    background: AmbitiousBackground;
}

export interface IndigoElevation {
    boxShadow: IndigoBoxShadow;
}

export interface IndigoBoxShadow {
    base:      string;
    activated: string;
}

export interface ContentSwitcherSize {
    height: HeightClass;
}

export interface ContentSwitcherSpace {
    gap:     string;
    padding: string;
}

export interface DateRange {
    presetMark:     PresetMark;
    pickerInput:    PickerInput;
    realTime:       RealTime;
    realTimeIcon:   RealTimeIcon;
    realTimeLoader: RealTimeLoader;
}

export interface PickerInput {
    color: PickerInputColor;
}

export interface PickerInputColor {
    background: MischievousBackground;
    border:     FontWeightClass;
    text:       HilariousText;
}

export interface MischievousBackground {
    active:  string;
    hovered: string;
    error:   BackgroundError;
    help:    BackgroundError;
    info:    BackgroundError;
    success: BackgroundError;
    warning: BackgroundError;
}

export interface BackgroundError {
    base:    string;
    focused: string;
}

export interface HilariousText {
    base:   string;
    weaker: Focused;
}

export interface PresetMark {
    color: LegendColor;
}

export interface RealTime {
    color: RealTimeColor;
}

export interface RealTimeColor {
    background: BraggadociousBackground;
    text:       BraggadociousBackground;
}

export interface BraggadociousBackground {
    active: SearchCancelClass;
    base:   SearchCancelClass;
}

export interface RealTimeIcon {
    typo:  LayoutClass;
    color: RealTimeColor;
}

export interface RealTimeLoader {
    color: RealTimeLoaderColor;
}

export interface RealTimeLoaderColor {
    fill: string;
}

export interface DateTimeRangeControl {
    color:          DateTimeRangeControlColor;
    elevation:      FieldsElevation;
    shape:          SketchPickerInputShape;
    size:           ContentSwitcherSize;
    space:          DateTimeRangeControlSpace;
    mutation:       FieldsMutation;
    input:          DateTimeRangeControlInput;
    arrow:          DateTimeRangeControlArrow;
    realTimeButton: RealTimeButton;
}

export interface DateTimeRangeControlArrow {
    color: RealTimeLoaderColor;
    size:  ScrollbarsSize;
}

export interface DateTimeRangeControlColor {
    border: FontWeightClass;
}

export interface DateTimeRangeControlInput {
    size:  InputSize;
    space: InputSpace;
}

export interface InputSize {
    height: SquareClass;
    width:  TentacledWidth;
}

export interface TentacledWidth {
    base:        SquareClass;
    withTime:    SquareClass;
    withSeconds: SquareClass;
    withMillis:  SquareClass;
}

export interface InputSpace {
    padding: SquareClass;
}

export interface RealTimeButton {
    size: ScrollbarsSize;
    typo: RealTimeButtonTypo;
}

export interface RealTimeButtonTypo {
    fontSize: HeightClass;
}

export interface DateTimeRangeControlSpace {
    padding: SquareClass;
    gap:     SquareClass;
}

export interface DecoratorBar {
    color: AppLayoutColor;
    shape: DecoratorBarShape;
}

export interface DecoratorBarShape {
    stroke: BorderRadiusEnum;
}

export interface Dialog {
    size:       DialogSize;
    headerIcon: DialogHeaderIcon;
    header:     DialogHeader;
}

export interface DialogHeader {
    color: ProgressBarColor;
}

export interface ProgressBarColor {
    background: IndecentText;
}

export interface DialogHeaderIcon {
    color: ProgressBarColor;
    typo:  AvatarTimeZoneTypo;
}

export interface AvatarTimeZoneTypo {
    fontSize:   string;
    lineHeight: string;
}

export interface DialogSize {
    minHeight: string;
    maxWidth:  string;
}

export interface DiffEditor {
    color:      DiffEditorColor;
    shape:      DiffEditorShape;
    rules:      Rules;
    difference: Difference;
    modified:   Modified;
}

export interface DiffEditorColor {
    background: Background1;
    border:     HilariousBorder;
    text:       AmbitiousText;
}

export interface Background1 {
    base:                        EditorOverviewRulerEnum;
    editor:                      HandlerEnum;
    editorIndentGuide:           EditorIndentGuideEnum;
    editorIndentGuideActive:     EditorIndentGuideActiveEnum;
    editorSuggestWidget:         HandlerEnum;
    editorSuggestWidgetSelected: string;
    editorOverviewRuler:         EditorOverviewRulerEnum;
    inactiveSelection:           string;
    lineHighlight:               string;
    selectionHighlight:          string;
    selection:                   string;
    wordHighlight:               string;
    listHovered:                 string;
    miniMap:                     EditorOverviewRulerEnum;
    miniMapSelectionHighlighted: string;
    miniMapSlider:               string;
    miniMapSliderHovered:        string;
    miniMapSliderActive:         string;
    removedText:                 string;
    insertedText:                string;
}

export interface HilariousBorder {
    editorSuggestWidget: EditorIndentGuideEnum;
}

export interface AmbitiousText {
    base:                           Active;
    editor:                         Active;
    editorCursor:                   Active;
    editorSuggestWidget:            Active;
    editorSuggestWidgetHighlighted: string;
    active:                         Active;
    editorLineNumber:               string;
    editorLineNumberActive:         Active;
    editorWhitespace:               string;
    listHovered:                    Active;
}

export interface Difference {
    color: AppLayoutColor;
    shape: DifferenceShape;
}

export interface DifferenceShape {
    borderLeft: string;
}

export interface Modified {
    shape: DifferenceShape;
}

export interface Rules {
    color: RulesColor;
}

export interface RulesColor {
    text: { [key: string]: SpaceValue };
}

export interface DiffEditorShape {
    borderRadius: IndecentBorderRadius;
}

export interface IndecentBorderRadius {
    base:  BorderRadiusEnum;
    inner: string;
}

export interface CmpDivider {
    space: CunningSpace;
    shape: CheckTypeClass;
    size:  StickySize;
    color: Color2;
}

export interface Color2 {
    fill: StickyFill;
}

export interface StickyFill {
    base:          string;
    inverse:       string;
    strong:        string;
    stronger:      string;
    weak:          string;
    weaker:        string;
    weakest:       string;
    success:       string;
    successWeak:   string;
    successStrong: string;
    error:         string;
    errorWeak:     string;
    errorStrong:   string;
    warning:       CheckTypeWarning;
    warningWeak:   string;
    warningStrong: WarningStrongEnum;
    info:          string;
    infoWeak:      string;
    infoStrong:    string;
    help:          string;
    helpWeak:      string;
    helpStrong:    string;
    primary:       string;
    secondary:     string;
    blendBase:     string;
    blendInverse:  string;
    dataBlue:      string;
    dataBronze:    string;
    dataGreen:     string;
    dataTeal:      string;
    dataSky:       string;
    dataSlate:     string;
    dataIndigo:    string;
    dataDusk:      string;
    dataPurple:    string;
    dataMagenta:   string;
    dataRed:       string;
    neutral?:      EditorIndentGuideActiveEnum;
}

export interface StickySize {
    height: StickyHeight;
}

export interface StickyHeight {
    vertical: string;
}

export interface CunningSpace {
    margin: PurpleMargin;
}

export interface PurpleMargin {
    base:     string;
    vertical: string;
}

export interface Drawer {
    color: MenuColor;
}

export interface EditableContent {
    color:     EditableContentColor;
    elevation: ChipElevation;
    mutation:  FieldsMutation;
    shape:     HandlersShape;
    icon:      EditableContentIcon;
}

export interface EditableContentColor {
    background: Background2;
}

export interface Background2 {
    hovered: EditorOverviewRulerEnum;
    focused: string;
}

export interface EditableContentIcon {
    color:    LabelIconColor;
    mutation: FieldsMutation;
    size:     ClearIndicatorSize;
    space:    CloseSpace;
}

export interface ClearIndicatorSize {
    square: SpaceValue;
}

export interface Editor {
    color:     EditorColor;
    shape:     EditorShape;
    line:      EditorLine;
    message:   Message;
    ruler:     Ruler;
    scrollBar: ScrollBar;
    suggest:   Suggest;
}

export interface EditorColor {
    text:       SpaceValue;
    background: Background3;
    border:     AmbitiousBorder;
}

export interface Background3 {
    readOnly: EditorOverviewRulerEnum;
}

export interface AmbitiousBorder {
    base:     BorderEnabled;
    readOnly: EditorOverviewRulerEnum;
}

export interface EditorLine {
    color: MenuColor;
    space: LineSpace;
}

export interface LineSpace {
    paddingLeft: string;
    marginLeft:  string;
}

export interface Message {
    elevation: MessageElevation;
    color:     MessageColor;
    shape:     HandlersShape;
    space:     GroupTitleSpace;
    typo:      MessageTypo;
}

export interface MessageColor {
    text:       SpaceValue;
    background: SpaceValue;
    border:     SpaceValue;
}

export interface MessageElevation {
    boxShadow: SpaceValue;
}

export interface MessageTypo {
    fontFamily: FontFaceNameEnum;
    fontSize:   string;
}

export interface Ruler {
    size:  RulerSize;
    shape: RulerShape;
}

export interface RulerShape {
    borderLeft: BorderLeft;
}

export interface BorderLeft {
    hasMiniMap: string;
}

export interface RulerSize {
    width: string;
}

export interface ScrollBar {
    color: ScrollBarColor;
    shape: ScrollBarShape;
    size:  ItemSymbolSize;
}

export interface ScrollBarColor {
    background: Background4;
}

export interface Background4 {
    track:  SpaceValue;
    slider: SearchCancelClass;
}

export interface ScrollBarShape {
    borderRadius: HilariousBorderRadius;
}

export interface HilariousBorderRadius {
    slider: BorderRadiusEnum;
}

export interface EditorShape {
    borderRadius: BorderRadiusEnum;
    borderSize:   BorderSizeEnum;
    borderStyle:  string;
}

export interface Suggest {
    elevation: SuggestElevation;
}

export interface SuggestElevation {
    boxShadow: SpaceValue;
    zIndex:    FluffyZIndex;
}

export interface FluffyZIndex {
    base: number;
}

export interface CmpField {
    addon:              Addon;
    controlDistributor: ControlDistributor;
    labelHelper:        ControlDistributor;
    requiredMark:       RequiredMark;
}

export interface Addon {
    color: MessageColor;
    shape: AddonShape;
    size:  ContentSwitcherSize;
    space: AddonSpace;
}

export interface AddonShape {
    borderRadius: SpaceValue;
    borderSize:   SpaceValue;
}

export interface AddonSpace {
    padding: Translation;
}

export interface ControlDistributor {
    size: ControlDistributorSize;
}

export interface ControlDistributorSize {
    minHeight: SquareClass;
}

export interface RequiredMark {
    space: ItemSymbolSpace;
    color: RequiredMarkColor;
}

export interface RequiredMarkColor {
    text: CunningText;
}

export interface CunningText {
    base:    string;
    help:    string;
    error:   EditorIndentGuideEnum;
    success: string;
    warning: Deleted;
    info:    string;
}

export interface FieldsCombiner {
    button: FieldsCombinerButton;
    input:  FieldsCombinerInput;
    item:   FieldsCombinerItem;
    select: Select;
}

export interface FieldsCombinerButton {
    color:     Color3;
    mutation:  FieldsMutation;
    shape:     TentacledShape;
    elevation: IndecentElevation;
}

export interface Color3 {
    border: CunningBorder;
}

export interface CunningBorder {
    combinedButtons: CombinedButtonsClass;
    base:            BorderEnabled;
    error:           EditorIndentGuideEnum;
    warning:         Checked;
    success:         Checked;
    hovered:         Focused;
}

export interface CombinedButtonsClass {
    light: string;
    dark:  string;
}

export interface IndecentElevation {
    zIndex: TentacledZIndex;
}

export interface TentacledZIndex {
    base:    number;
    focused: number;
}

export interface TentacledShape {
    borderSize: StickyBorderSize;
}

export interface StickyBorderSize {
    base:            BorderSizeEnum;
    combinedButtons: BorderSizeEnum;
}

export interface FieldsCombinerInput {
    elevation: InputElevation;
    color:     SelectColor;
}

export interface SelectColor {
    border: MagentaBorder;
}

export interface MagentaBorder {
    hovered: string;
}

export interface InputElevation {
    zIndex: StickyZIndex;
}

export interface StickyZIndex {
    focused: number;
}

export interface FieldsCombinerItem {
    color: Color4;
    shape: StickyShape;
    size:  ContentSwitcherSize;
}

export interface Color4 {
    background: Background5;
    border:     FriskyBorder;
}

export interface Background5 {
    checkType: EditorOverviewRulerEnum;
}

export interface FriskyBorder {
    checkType: TrackClass;
}

export interface StickyShape {
    checkType: CheckTypeClass;
}

export interface Select {
    color:     SelectColor;
    mutation:  FieldsMutation;
    elevation: InputElevation;
}

export interface Form {
    group:  Group;
    legend: FormLegend;
}

export interface Group {
    color: Color5;
    shape: GroupShape;
    space: GroupSpace;
}

export interface Color5 {
    border: BorderRadiusClass;
}

export interface BorderRadiusClass {
    boxed: string;
}

export interface GroupShape {
    borderRadius: BorderRadiusClass;
    borderSize:   BorderRadiusClass;
}

export interface GroupSpace {
    padding: BorderRadiusClass;
}

export interface FormLegend {
    size: CollapseSize;
}

export interface CmpHeading {
    typo: HeadingTypo;
}

export interface HeadingTypo {
    fontSize:      LineHeightClass;
    lineHeight:    LineHeightClass;
    fontFamily:    OriginalNameEnum;
    fontWeight:    string;
    letterSpacing: string;
    textTransform: string;
}

export interface Helper {
    color: HelperColor;
    space: HelperSpace;
    icon:  HelperIcon;
}

export interface HelperColor {
    text: MagentaText;
}

export interface MagentaText {
    base:  string;
    error: EditorIndentGuideEnum;
}

export interface HelperIcon {
    size:  FluffySize;
    color: Color6;
}

export interface Color6 {
    fill: FillClass;
}

export interface HelperSpace {
    marginTop: FluffyMarginTop;
    gap:       LayoutClass;
}

export interface FluffyMarginTop {
    base:     BorderRadiusEnum;
    forGroup: string;
}

export interface Hero {
    typo: HeroTypo;
}

export interface HeroTypo {
    fontSize:      HeightClass;
    lineHeight:    HeightClass;
    fontFamily:    OriginalNameEnum;
    fontWeight:    string;
    letterSpacing: string;
    textTransform: string;
}

export interface HighChart {
    color:              HighChartColor;
    chart:              Chart;
    plot:               InlineMessageBanner;
    title:              HighChartTitle;
    subtitle:           HighChartSubtitle;
    subtitleY:          SubtitleY;
    xAxis:              Wrapper;
    xAxisTitle:         XAxisLabels;
    xAxisCrosshair:     InlineMessageBanner;
    xAxisLabels:        XAxisLabels;
    xAxisLabelsY:       AxisLabelsY;
    xAxisLine:          InlineMessageBanner;
    xAxisGridLine:      InlineMessageBanner;
    xAxisTick:          InlineMessageBanner;
    xAxisGridLineMinor: InlineMessageBanner;
    yAxis:              Wrapper;
    yAxisTitle:         XAxisLabels;
    yAxisCrosshair:     InlineMessageBanner;
    yAxisLabels:        XAxisLabels;
    yAxisLabelsY:       AxisLabelsY;
    yAxisLine:          InlineMessageBanner;
    yAxisGridLine:      InlineMessageBanner;
    yAxisTick:          InlineMessageBanner;
    yAxisGridLineMinor: InlineMessageBanner;
    tooltip:            HighChartTooltip;
    plotOptionsPie:     InlineMessageBanner;
    plotOptionsPieLine: InlineMessageBanner;
}

export interface Chart {
    color: AppLayoutColor;
    space: ChartSpace;
}

export interface ChartSpace {
    paddingBottom: string;
    paddingTop:    string;
    paddingLeft:   string;
    paddingRight:  string;
}

export interface HighChartColor {
    fill: { [key: string]: string };
}

export interface InlineMessageBanner {
    color: ShapeClass;
}

export interface HighChartSubtitle {
    color: RealTimeLoaderColor;
    typo:  StickyTypo;
}

export interface StickyTypo {
    fontSize:      string;
    letterSpacing: string;
}

export interface SubtitleY {
    size: RulerSize;
}

export interface HighChartTitle {
    color: RealTimeLoaderColor;
    size:  ItemGroupHeadingSize;
    typo:  StickyTypo;
}

export interface HighChartTooltip {
    color: BetaBadgeColor;
    space: GroupTitleSpace;
}

export interface XAxisLabels {
    color: RealTimeLoaderColor;
    typo:  XAxisLabelsTypo;
}

export interface XAxisLabelsTypo {
    fontSize:   string;
    fontWeight: string;
}

export interface AxisLabelsY {
    space: GroupTitleSpace;
    color: RealTimeLoaderColor;
}

export interface Highlighted {
    color: AppLayoutColor;
}

export interface CmpIcon {
    size:  AvatarSize;
    typo:  IndigoTypo;
    color: Color2;
}

export interface IndigoTypo {
    fontFamily: FluffyFontFamily;
    fontWeight: string;
    lineHeight: string;
}

export interface FluffyFontFamily {
    base: FontFaceNameEnum;
    alt:  FontFaceNameEnum;
}

export interface IconButtonDropdown {
    size: IconButtonDropdownSize;
}

export interface IconButtonDropdownSize {
    width: MediaQuery;
}

export interface IconButtonGoToDocs {
    marker: IconButtonGoToDocsMarker;
}

export interface IconButtonGoToDocsMarker {
    typo: MarkerTypo;
    size: IndigoSize;
}

export interface IndigoSize {
    offset: SizeOffset;
}

export interface SizeOffset {
    enabled: LayoutClass;
    hovered: LayoutClass;
}

export interface MarkerTypo {
    fontSize: SquareClass;
}

export interface IconButtonStatus {
    color: IconButtonStatusColor;
}

export interface IconButtonStatusColor {
    background: Background6;
    text:       Background6;
}

export interface Background6 {
    error:   AccentClass;
    help:    AccentClass;
    info:    AccentClass;
    success: AccentClass;
    warning: AccentClass;
}

export interface IconButtonStop {
    icon:   IconButtonStopIcon;
    circle: InlineMessageBanner;
}

export interface IconButtonStopIcon {
    color: HeadingColor;
    size:  HandlersSize;
}

export interface InlineMessage {
    color:      InlineMessageColor;
    arrow:      ControlMarkerSVG;
    contentImg: ContentImgClass;
    content:    InlineMessageContent;
    footer:     InlineMessageFooter;
    header:     InlineMessageFooter;
}

export interface InlineMessageColor {
    background: HandlerEnum;
    border:     FillClass;
}

export interface InlineMessageContent {
    space: MagentaSpace;
}

export interface MagentaSpace {
    padding: IndigoPadding;
    margin:  string;
}

export interface IndigoPadding {
    noHasScroll: string;
    hasScroll:   string;
}

export interface InlineMessageFooter {
    space: FriskySpace;
}

export interface FriskySpace {
    padding: IndigoPadding;
}

export interface InputControl {
    color:          InputControlColor;
    elevation:      InputControlElevation;
    mutation:       FieldsMutation;
    shape:          InputControlShape;
    size:           InputControlSize;
    space:          InputControlSpace;
    icon:           InputControlIcon;
    pseudoCalendar: PseudoCalendar;
    pseudoFile:     PseudoFile;
    pseudoRange:    PseudoRange;
    pseudoSearch:   PseudoSearch;
    showPassword:   ShowPassword;
}

export interface InputControlColor {
    background: Background7;
    border:     StickyBorder;
    text:       FriskyText;
}

export interface Background7 {
    base:    FluffyBase;
    error:   FluffyBase;
    success: FluffyBase;
    warning: FluffyBase;
}

export interface FluffyBase {
    enabled:  HandlerEnum;
    readonly: EditorOverviewRulerEnum;
    disabled: HandlerEnum;
    hovered:  HandlerEnum;
    focused:  HandlerEnum;
}

export interface FriskyText {
    base:    TentacledBase;
    inverse: TentacledBase;
    error:   TentacledBase;
    success: TentacledBase;
    warning: TentacledBase;
}

export interface TentacledBase {
    enabled:     EnabledEnum;
    hovered:     EnabledEnum;
    focused:     Active;
    placeholder: EditorIndentGuideActiveEnum;
    filled:      Filled;
    disabled:    EnabledEnum;
    readonly:    Readonly;
}

export interface InputControlElevation {
    boxShadow: FluffyBoxShadow;
    zIndex:    IndigoZIndex;
}

export interface IndigoZIndex {
    addonToRight: number;
}

export interface InputControlIcon {
    color:     AmbitiousColor;
    mutation:  FieldsMutation;
    elevation: BarElevation;
    size:      ScrollbarsSize;
    space:     MischievousSpace;
}

export interface MischievousSpace {
    offset: StickyOffset;
}

export interface StickyOffset {
    base:     MediaQuery;
    password: MediaQuery;
}

export interface PseudoCalendar {
    color:    PseudoCalendarColor;
    mutation: FieldsMutation;
    shape:    PseudoCalendarShape;
    size:     ScrollbarsSize;
    space:    PseudoCalendarSpace;
}

export interface PseudoCalendarColor {
    background: MagentaBorder;
}

export interface PseudoCalendarShape {
    borderRadius:    BorderRadiusEnum;
    backgroundSize:  MediaQuery;
    backgroundImage: FluffyBackgroundImage;
}

export interface FluffyBackgroundImage {
    picker:     string;
    timePicker: string;
}

export interface PseudoCalendarSpace {
    padding: HeightClass;
    offset:  HeightClass;
}

export interface PseudoFile {
    color: PseudoFileColor;
    shape: HandlersShape;
    space: PseudoCalendarSpace;
    size:  ContentSwitcherSize;
}

export interface PseudoFileColor {
    background: ColorLink;
    text:       ColorLink;
}

export interface PseudoRange {
    color:     PseudoRangeColor;
    elevation: PseudoRangeElevation;
    mutation:  PseudoRangeMutation;
    shape:     PseudoRangeShape;
    size:      PseudoRangeSize;
}

export interface PseudoRangeColor {
    background: Background8;
}

export interface Background8 {
    track: TrackClass;
    thumb: SpaceValue;
}

export interface PseudoRangeElevation {
    boxShadow: IndecentBoxShadow;
}

export interface IndecentBoxShadow {
    thumb: SearchCancelClass;
}

export interface PseudoRangeMutation {
    transitionDuration: TransitionDuration;
}

export interface TransitionDuration {
    thumb: string;
}

export interface PseudoRangeShape {
    borderRadius: AmbitiousBorderRadius;
}

export interface AmbitiousBorderRadius {
    track: SpaceValue;
    thumb: SearchCancelClass;
}

export interface PseudoRangeSize {
    width:  SizeWidth;
    height: SizeWidth;
    square: TransitionDuration;
}

export interface SizeWidth {
    track: string;
}

export interface PseudoSearch {
    color:    PseudoSearchColor;
    mutation: FieldsMutation;
    shape:    PseudoSearchShape;
    size:     ScrollbarsSize;
    space:    PseudoCalendarSpace;
}

export interface PseudoSearchColor {
    background: TextClass;
}

export interface PseudoSearchShape {
    borderRadius:    BorderRadiusEnum;
    backgroundSize:  SquareClass;
    backgroundImage: TextClass;
}

export interface InputControlShape {
    borderRadius: BorderRadiusEnum;
    borderSize:   IndigoBorderSize;
    opacity:      PurpleOpacity;
}

export interface IndigoBorderSize {
    base:      BorderSizeEnum;
    typeRange: string;
}

export interface ShowPassword {
    space: ShowPasswordSpace;
}

export interface ShowPasswordSpace {
    offset: MediaQuery;
}

export interface InputControlSize {
    width:  SquareClass;
    height: SquareClass;
}

export interface InputControlSpace {
    padding:      IndecentPadding;
    paddingLeft:  PaddingLeft;
    paddingRight: PaddingRight;
}

export interface IndecentPadding {
    top:       PaddingTop;
    hor:       MediaQuery;
    typeColor: string;
    typeRange: string;
}

export interface PaddingTop {
    fileType: SquareClass;
}

export interface PaddingLeft {
    typeIcon: MediaQuery;
}

export interface PaddingRight {
    password:         SquareClass;
    passwordWithIcon: SquareClass;
    withIcon:         SquareClass;
}

export interface KeyValue {
    color:  HeadingColor;
    typo:   KeyValueTypo;
    unit:   Unit;
    visual: Visual;
}

export interface KeyValueTypo {
    lineHeight: SquareClass;
}

export interface Unit {
    space: UnitSpace;
}

export interface UnitSpace {
    marginLeft: BorderRadiusEnum;
}

export interface Visual {
    color: HeadingColor;
}

export interface CmpLabel {
    size:   ContentSwitcherSize;
    space:  BraggadociousSpace;
    marker: LabelMarker;
}

export interface LabelMarker {
    color: RequiredMarkColor;
}

export interface BraggadociousSpace {
    margin: FluffyMargin;
}

export interface FluffyMargin {
    ver: SquareClass;
    hor: LayoutClass;
}

export interface CmpLink {
    color:     Color7;
    shape:     LinkShape;
    elevation: ChipElevation;
    mutation:  ThumbMutation;
}

export interface Color7 {
    text: FillClass;
}

export interface LinkShape {
    opacity: PurpleOpacity;
}

export interface CmpList {
    space: ItemValueSpace;
}

export interface CmpLoader {
    gradient:                  Drawer;
    logoEvenPath:              LogoPath;
    logoOddPath:               LogoPath;
    spinnerAnimatedStrokeTemp: SpinnerAnimatedStrokeTemp;
    spinnerAnimatedStroke:     SpinnerAnimatedStroke;
    spinner:                   Spinner;
}

export interface LogoPath {
    color: LogoEvenPathColor;
}

export interface LogoEvenPathColor {
    background: Background9;
}

export interface Background9 {
    light: string;
    dark:  string;
    brand: string;
}

export interface Spinner {
    color: SpinnerColor;
    size:  AvatarSize;
}

export interface SpinnerColor {
    background: Background10;
}

export interface Background10 {
    brand:      string;
    brandDark:  string;
    brandLight: string;
    light:      string;
    dark:       string;
    lightTrans: string;
    darkTrans:  string;
    error:      string;
    success:    string;
    warning:    string;
    help:       string;
    info:       string;
}

export interface SpinnerAnimatedStroke {
    color: SpinnerColor;
}

export interface SpinnerAnimatedStrokeTemp {
    color: SpinnerAnimatedStrokeTempColor;
}

export interface SpinnerAnimatedStrokeTempColor {
    background: CombinedButtonsClass;
}

export interface MainMenu {
    secondaryCloser:             NavSubItemAppNewTab;
    secondaryHeadingIcon:        AvatarTimeZoneLeft;
    secondaryHeading:            SecondaryHeading;
    secondaryItemIcon:           AvatarTimeZoneLeft;
    secondaryItemLinkAction:     SubtitleY;
    secondaryItemLinkFavorite:   SecondaryItemLinkFavorite;
    secondaryItemLinkIcon:       AvatarTimeZoneRight;
    secondaryItemLinkSecurity:   SecondaryItemLinkSecurity;
    secondaryItemLink:           SecondaryItemLink;
    secondaryItem:               SecondaryItem;
    secondaryMsgResults:         SecondaryMsgResults;
    secondarySearchInput:        SecondarySearchInput;
    secondarySearchLabelContent: SecondarySearchLabelContent;
    secondarySearchLabel:        AvatarTimeZoneLeft;
    secondarySearch:             Inner;
    secondary:                   MainMenuSecondary;
    space:                       SpaceValue;
    size:                        MainMenuSize;
    shape:                       MenusShape;
    color:                       MainMenuColor;
    mutation:                    MainMenuMutation;
    typo:                        MainMenuTypo;
    avatarChangeDomain:          AvatarChangeDomain;
    avatarItem:                  AvatarItem;
    avatarLink:                  AvatarLink;
    avatarRoleIcon:              AvatarRoleIcon;
    avatarTimeZoneLeft:          AvatarTimeZoneLeft;
    avatarTimeZoneRight:         AvatarTimeZoneRight;
    avatarTimeZone:              AvatarTimeZone;
    avatarUserInfo:              AvatarUserInfo;
    avatarUserThumb:             AvatarUserThumb;
    avatarWrapper:               AvatarWrapper;
    button:                      MainMenuButton;
    externalSearch:              ExternalSearch;
    field:                       MainMenuField;
    fixer:                       Fixer;
    inner:                       Inner;
    labelIcon:                   AvatarTimeZoneRight;
    label:                       MainMenuLabel;
    legalIcon:                   LegalIcon;
    legalLink:                   ItemGroupHeading;
    link:                        MainMenuLink;
    linkSecondary:               LinkSecondary;
    linkIcon:                    LinkIcon;
    linkLegal:                   LinkLegal;
    logoCustom:                  LogoCustom;
    logoResellerImg:             LogoReseller;
    logoResellerTriggerIcon:     LogoResellerTriggerIcon;
    logoResellerTrigger:         LogoReseller;
    logoReseller:                LogoResellerClass;
    logoWrapper:                 ItemGroupHeading;
    logo:                        LogoResellerClass;
    navItemBadge:                NavItemBadge;
    navItemHelpLinkIcon:         Visual;
    navItemLinkContent:          NavItemLinkContent;
    navItemLinkDropIcon:         NavItemLinkDropIcon;
    navItemLinkIcon:             NavItemLinkIcon;
    navItemLink:                 NavItemLink;
    navItemLogoutLinkIcon:       Visual;
    navItem:                     NavItem;
    navSubItemAppNewTab:         NavSubItemAppNewTab;
    navSubItemLinkIcon:          NavSubItemLinkIcon;
    navSubItemLinkSocial:        NavSubItemLinkSocial;
    navSubItemLink:              NavSubItemLink;
    navSubNav:                   SubtitleY;
    nav:                         Nav;
    overlay:                     MainMenuOverlay;
    priorityLabel:               AvatarTimeZoneLeft;
    prioritySelectIcon:          PrioritySelectIcon;
    prioritySelect:              PrioritySelect;
    priority:                    Priority;
    searchItemAction:            SearchItem;
    searchItemIcon:              SearchItemIcon;
    searchItemLink:              SearchItemLink;
    searchItemWrapper:           SubtitleY;
    searchItem:                  SearchItem;
    search:                      Search;
    userDetails:                 UserDetails;
    userDetailsAvatarName:       UserDetailsAvatar;
    userDetailsAvatarDomain:     UserDetailsAvatarDomain;
    userDetailsAvatarRol:        UserDetailsAvatar;
}

export interface AvatarChangeDomain {
    mutation: FieldsMutation;
    shape:    AvatarChangeDomainShape;
    size:     AppLayoutSize;
    typo:     BackdropTypo;
}

export interface AvatarChangeDomainShape {
    border:       TextClass;
    borderRadius: BorderRadiusEnum;
}

export interface AvatarItem {
    size:  ItemGroupHeadingSize;
    color: PseudoCalendarColor;
}

export interface AvatarLink {
    mutation: FieldsMutation;
    space:    ListItemSpace;
    size:     ItemGroupHeadingSize;
    color:    PseudoSearchColor;
}

export interface AvatarRoleIcon {
    mutation: FieldsMutation;
    shape:    HandlersShape;
    size:     AppLayoutSize;
    typo:     BackdropTypo;
}

export interface AvatarTimeZone {
    mutation: FieldsMutation;
    shape:    HandlersShape;
    typo:     AvatarTimeZoneTypo;
    color:    PseudoSearchColor;
}

export interface AvatarTimeZoneLeft {
    space: string;
    typo:  BackdropTypo;
    color: HeadingColor;
    size?: RulerSize;
}

export interface AvatarTimeZoneRight {
    space: string;
    typo:  BackdropTypo;
}

export interface AvatarUserInfo {
    space: AvatarUserInfoSpace;
    size:  ItemGroupHeadingSize;
    typo:  AvatarTimeZoneTypo;
    color: AvatarUserInfoColor;
}

export interface AvatarUserInfoColor {
    text: NeutralClass;
}

export interface AvatarUserInfoSpace {
    left:  string;
    right: string;
}

export interface AvatarUserThumb {
    shape: CodeInlineShape;
    space: string;
    size:  ItemSymbolSize;
    color: AvatarUserThumbColor;
}

export interface AvatarUserThumbColor {
    background: SpaceValue;
    border:     EditorOverviewRulerEnum;
    text:       SpaceValue;
}

export interface AvatarWrapper {
    size: AppLayoutSize;
}

export interface MainMenuButton {
    color: Color8;
}

export interface Color8 {
    background: string;
    text:       TextClass;
}

export interface MainMenuColor {
    background: HandlerEnum;
    text:       StickyText;
}

export interface ExternalSearch {
    size:      RulerSize;
    elevation: AppBarElevation;
}

export interface MainMenuField {
    color:     FieldColor;
    elevation: ChipElevation;
}

export interface FieldColor {
    background: HandlerEnum;
    border:     TextClass;
    text:       MischievousText;
}

export interface MischievousText {
    placeholder: EditorIndentGuideActiveEnum;
    enabled:     CheckedEnum;
    focused:     Active;
}

export interface Fixer {
    size:  AppLayoutSize;
    typo:  AvatarTimeZoneTypo;
    color: HeadingColor;
}

export interface Inner {
    size:  RulerSize;
    space: string;
}

export interface MainMenuLabel {
    mutation: FieldsMutation;
    space:    string;
    typo:     XAxisLabelsTypo;
    color:    HeadingColor;
}

export interface LegalIcon {
    mutation: FieldsMutation;
    shape:    LegalIconShape;
    size:     AppLayoutSize;
    typo:     AvatarTimeZoneTypo;
    color:    LegalIconColor;
}

export interface LegalIconShape {
    content:      string;
    borderRadius: BorderRadiusEnum;
}

export interface MainMenuLink {
    color: Color9;
}

export interface Color9 {
    background: BackgroundClass;
    text:       BraggadociousText;
}

export interface BraggadociousText {
    enabled:   string;
    hovered:   string;
    activated: string;
}

export interface LinkIcon {
    color: LinkIconColor;
}

export interface LinkIconColor {
    background: BackgroundClass;
    text:       BoxShadowClass;
}

export interface LinkLegal {
    color: LinkLegalColor;
    typo:  LinkLegalTypo;
}

export interface LinkLegalTypo {
    fontSize:   SpaceValue;
    lineHeight: SpaceValue;
}

export interface LinkSecondary {
    color: LinkSecondaryColor;
}

export interface LinkSecondaryColor {
    text: BoxShadowClass;
}

export interface LogoResellerClass {
    mutation: FieldsMutation;
    shape:    LogoShape;
    size:     LogoResellerSize;
    color:    HeadingColor;
}

export interface LogoShape {
    background: ShapeFontSize;
}

export interface ShapeFontSize {
    sm: string;
    md: string;
}

export interface LogoResellerSize {
    height: string;
    width:  TransitionClass;
}

export interface TransitionClass {
    collapsed: string;
    expanded:  string;
}

export interface LogoCustom {
    shape: LogoCustomShape;
}

export interface LogoCustomShape {
    backgroundSize: string;
}

export interface LogoReseller {
    mutation: LogoResellerImgMutation;
}

export interface LogoResellerImgMutation {
    transition: TransitionClass;
}

export interface LogoResellerTriggerIcon {
    mutation: FieldsMutation;
    size:     RulerSize;
    color:    PseudoSearchColor;
}

export interface MainMenuMutation {
    transition:         string;
    transitionDuration: string;
}

export interface Nav {
    mutation: FieldsMutation;
}

export interface NavItem {
    shape: ShapeClass;
    space: string;
    color: Color10;
}

export interface Color10 {
    text:       SpaceValue;
    border:     HandlerEnum;
    background: Background11;
}

export interface Background11 {
    expanded: string;
}

export interface NavItemBadge {
    space: string;
    shape: HandlersShape;
    size:  ItemGroupHeadingSize;
    typo:  XAxisLabelsTypo;
    color: BetaBadgeColor;
}

export interface NavItemLink {
    mutation: FieldsMutation;
    space:    NavItemLinkSpace;
    typo:     NavItemLinkTypo;
}

export interface NavItemLinkSpace {
    ver: string;
    hor: TransitionClass;
}

export interface NavItemLinkTypo {
    lineHeight: string;
    fontWeight: string;
    fontSize:   string;
}

export interface NavItemLinkContent {
    size:  RulerSize;
    space: string;
    typo:  ItemLabelLeftTypo;
}

export interface NavItemLinkDropIcon {
    mutation: LogoResellerImgMutation;
    size:     ItemSymbolSize;
    typo:     BackdropTypo;
}

export interface NavItemLinkIcon {
    size: ItemSymbolSize;
    typo: BackdropTypo;
}

export interface NavSubItemAppNewTab {
    mutation: ThumbMutation;
    space:    string;
    typo:     BackdropTypo;
}

export interface NavSubItemLink {
    typo:  NavItemLinkTypo;
    space: NavSubItemLinkSpace;
    color: NavSubItemLinkColor;
}

export interface NavSubItemLinkColor {
    text: BraggadociousText;
}

export interface NavSubItemLinkSpace {
    padding: HilariousPadding;
}

export interface HilariousPadding {
    ver:   string;
    left:  string;
    right: string;
}

export interface NavSubItemLinkIcon {
    space: string;
    typo:  NavSubItemLinkIconTypo;
}

export interface NavSubItemLinkIconTypo {
    lineHeight: string;
}

export interface NavSubItemLinkSocial {
    mutation: ThumbMutation;
    size:     ItemSymbolSize;
    typo:     AvatarTimeZoneTypo;
    color:    NavSubItemLinkSocialColor;
}

export interface NavSubItemLinkSocialColor {
    background: Social;
    text:       Text1;
}

export interface Text1 {
    enabled:    Focused;
    hovered:    HandlerEnum;
    twitter:    string;
    linkedin:   string;
    youtube:    string;
    googlePlus: string;
}

export interface MainMenuOverlay {
    size:      AppLayoutSize;
    elevation: BarElevation;
    color:     AppLayoutColor;
}

export interface Priority {
    mutation: ThumbMutation;
    size:     RulerSize;
    space:    PrioritySpace;
    shape:    HeaderShape;
}

export interface PrioritySpace {
    ver:      BorderRadiusEnum;
    hor:      string;
    expanded: string;
}

export interface PrioritySelect {
    mutation: ThumbMutation;
    typo:     PrioritySelectTypo;
    shape:    HandlersShape;
    size:     AppLayoutSize;
    space:    PrioritySelectSpace;
    color:    PrioritySelectColor;
}

export interface PrioritySelectColor {
    background: ColorLink;
    text:       string;
    border:     TextClass;
}

export interface PrioritySelectSpace {
    enabled:  string;
    expanded: string;
}

export interface PrioritySelectTypo {
    lineHeight: string;
    fontSize:   PrioritySelectSpace;
}

export interface PrioritySelectIcon {
    shape:    PrioritySelectIconShape;
    mutation: ThumbMutation;
    typo:     PrioritySelectIconTypo;
    color:    HeadingColor;
}

export interface PrioritySelectIconShape {
    content: string;
}

export interface PrioritySelectIconTypo {
    fontFamily: FontFaceNameEnum;
    lineHeight: string;
    fontSize:   PrioritySelectSpace;
}

export interface Search {
    size:  RulerSize;
    color: AppLayoutColor;
}

export interface SearchItem {
    mutation?: ThumbMutation;
    size:      AppLayoutSize;
    typo:      AvatarTimeZoneTypo;
    shape:     ShapeClass;
}

export interface SearchItemIcon {
    size: AppLayoutSize;
    typo: AvatarTimeZoneTypo;
}

export interface SearchItemLink {
    size:  AppLayoutSize;
    space: string;
}

export interface MainMenuSecondary {
    mutation:  ThumbMutation;
    size:      RulerSize;
    elevation: SketchPickerElevation;
    color:     BetaBadgeColor;
}

export interface SecondaryHeading {
    space: string;
    typo:  GroupTitleTypo;
    color: HeadingColor;
}

export interface SecondaryItem {
    mutation: ThumbMutation;
    size:     ItemGroupHeadingSize;
    typo:     NavSubItemLinkIconTypo;
    shape:    SecondaryItemShape;
    color:    BetaBadgeColor;
}

export interface SecondaryItemShape {
    border: ShapeText;
}

export interface ShapeText {
    enabled:   string;
    activated: string;
}

export interface SecondaryItemLink {
    mutation: FieldsMutation;
    size:     SecondaryItemLinkSize;
    typo:     XAxisLabelsTypo;
}

export interface SecondaryItemLinkSize {
    width: string;
    space: string;
}

export interface SecondaryItemLinkFavorite {
    color: SecondaryItemLinkFavoriteColor;
}

export interface SecondaryItemLinkFavoriteColor {
    background: BraggadociousText;
    text:       ShapeText;
}

export interface SecondaryItemLinkSecurity {
    mutation: ThumbMutation;
}

export interface SecondaryMsgResults {
    typo:  BackdropTypo;
    color: HeadingColor;
}

export interface SecondarySearchInput {
    size:  SecondarySearchInputSize;
    space: string;
    color: BetaBadgeColor;
}

export interface SecondarySearchInputSize {
    width:        string;
    borderRadius: string;
}

export interface SecondarySearchLabelContent {
    size:  RulerSize;
    space: string;
    typo:  GroupTitleTypo;
    color: HeadingColor;
}

export interface MainMenuSize {
    width: TransitionClass;
}

export interface MainMenuTypo {
    fontSize: ShapeFontSize;
}

export interface UserDetails {
    mutation: ThumbMutation;
    typo:     LinkLegalTypo;
}

export interface UserDetailsAvatar {
    color: LabelsColor;
    typo:  LinkLegalTypo;
}

export interface CmpMenu {
    heading:  MenuHeading;
    item:     FluffyItem;
    itemIcon: MenuItemIcon;
}

export interface MenuHeading {
    space: ChartSpace;
}

export interface FluffyItem {
    shape:     HandlersShape;
    space:     Space1;
    size:      CollapseSize;
    color:     MenuOptionColor;
    elevation: ChipElevation;
    mutation:  FieldsMutation;
}

export interface Space1 {
    paddingHor: string;
}

export interface MenuItemIcon {
    space: HeadCellOrderSpace;
    size:  ItemSymbolSize;
}

export interface HeadCellOrderSpace {
    offset: string;
}

export interface Modal {
    color:              AppLayoutColor;
    elevation:          ModalElevation;
    space:              GroupTitleSpace;
    size:               ModalSize;
    backdrop:           ModalBackdrop;
    content:            ModalContent;
    footerButtons:      FooterOns;
    footer:             ModalFooter;
    headerBottom:       HeaderBottom;
    headerButtons:      HeaderButtons;
    headerDecoratorBar: HeaderDecoratorBar;
    headerIcon:         ModalHeaderIcon;
    header:             ModalHeader;
}

export interface ModalBackdrop {
    elevation: ModalElevation;
}

export interface ModalElevation {
    zIndex: FluffyZIndex;
}

export interface ModalContent {
    space: Space2;
}

export interface Space2 {
    padding: SpacingPadding;
    margin:  string;
}

export interface SpacingPadding {
    ver: string;
    hor: string;
}

export interface ModalFooter {
    color:     AppLayoutColor;
    elevation: AppBarElevation;
    space:     Spac;
}

export interface Spac {
    padding: SpacingPadding;
}

export interface FooterOns {
    space: FooterButtonsSpace;
}

export interface FooterButtonsSpace {
    gap:        string;
    marginLeft: string;
}

export interface ModalHeader {
    shape:     ShapeClass;
    elevation: AppBarElevation;
    space:     NavSubItemLinkSpace;
}

export interface HeaderBottom {
    shape: ShapeClass;
    color: AppLayoutColor;
    size:  HeaderBottomSize;
}

export interface HeaderBottomSize {
    spacing: Spac;
}

export interface HeaderButtons {
    space: HeaderButtonsSpace;
}

export interface HeaderButtonsSpace {
    gap: string;
}

export interface HeaderDecoratorBar {
    size:  ItemGroupHeadingSize;
    space: ItemSymbolSpace;
}

export interface ModalHeaderIcon {
    typo:  BackdropTypo;
    space: ItemSymbolSpace;
}

export interface ModalSize {
    height:    IndigoHeight;
    minWidth:  string;
    width:     string;
    maxWidth:  LayoutClass;
    maxHeight: string;
    minHeight: LayoutClass;
}

export interface IndigoHeight {
    full: string;
}

export interface Notification {
    item:       NotificationItem;
    icon:       NotificationIcon;
    headerIcon: NotificationHeaderIcon;
}

export interface NotificationHeaderIcon {
    color: Color11;
    typo:  BackdropTypo;
}

export interface Color11 {
    background: FillClass;
}

export interface NotificationIcon {
    color: BetaBadgeColor;
    typo:  BackdropTypo;
}

export interface NotificationItem {
    shape: ColorClass;
}

export interface CmpOverlay {
    color: Color12;
}

export interface Color12 {
    background: Background12;
}

export interface Background12 {
    light: Dark;
    dark:  Dark;
}

export interface Dark {
    opacity: string;
    opaque:  string;
}

export interface Panel {
    color:               PanelColor;
    elevation:           PanelElevation;
    shape:               SketchPickerInputShape;
    content:             PanelContent;
    footerAction:        FooterAction;
    footerAppend:        FooterAction;
    footerPrepend:       ErPrepend;
    footer:              PanelFooter;
    headerAction:        FooterAction;
    headerAppend:        FooterAction;
    headerIcon:          PanelHeaderIcon;
    headerLegend:        HeaderLegend;
    headerPrepend:       ErPrepend;
    headerSubtitle:      HeaderSubtitle;
    headerTitle:         HeaderTitle;
    headerTitleSelector: HeaderTitleSelector;
    header:              PanelHeader;
}

export interface PanelColor {
    background: HandlerEnum;
    border:     MischievousBorder;
}

export interface MischievousBorder {
    ground:       string;
    stickyBottom: EditorIndentGuideEnum;
    stickyTop:    EditorIndentGuideEnum;
    stickyRight:  EditorIndentGuideEnum;
    stickyLeft:   EditorIndentGuideEnum;
    activated:    EditorIndentGuideEnum;
    draggable:    EditorIndentGuideEnum;
    overlay:      EditorIndentGuideEnum;
    popOut:       EditorIndentGuideEnum;
}

export interface PanelContent {
    space: Space3;
}

export interface Space3 {
    padding: LayoutClass;
    margin:  LayoutClass;
}

export interface PanelElevation {
    boxShadow: HilariousBoxShadow;
}

export interface HilariousBoxShadow {
    depth: DepthClass;
}

export interface PanelFooter {
    color:     AppBarColor;
    elevation: AppBarElevation;
    space:     Space4;
}

export interface Space4 {
    padding: MarginLeftClass;
}

export interface MarginLeftClass {
    xs: string;
    sm: string;
    md: string;
}

export interface FooterAction {
    space: FooterActionSpace;
}

export interface FooterActionSpace {
    marginLeft: MarginLeftClass;
}

export interface ErPrepend {
    space: FooterPrependSpace;
}

export interface FooterPrependSpace {
    marginRight: MarginLeftClass;
}

export interface PanelHeader {
    color:     ShapeClass;
    elevation: AppBarElevation;
    space:     Space4;
}

export interface PanelHeaderIcon {
    color: HeadingColor;
    size:  HeaderLegendSize;
    space: FooterPrependSpace;
    typo:  IndecentTypo;
}

export interface HeaderLegendSize {
    height: MarginLeftClass;
}

export interface IndecentTypo {
    fontSize: MediaQuery;
}

export interface HeaderLegend {
    size:  HeaderLegendSize;
    space: FooterActionSpace;
}

export interface HeaderSubtitle {
    space: ListItemSpace;
    size:  SketchPickerHex;
}

export interface HeaderTitle {
    size: SketchPickerHex;
}

export interface HeaderTitleSelector {
    size: HeaderTitleSelectorSize;
}

export interface HeaderTitleSelectorSize {
    height: SpaceValue;
}

export interface PanelSection {
    content: PanelSectionContent;
    footer:  ContentClass;
    header:  ContentClass;
}

export interface PanelSectionContent {
    space: Space5;
}

export interface Space5 {
    margin:  PaddingClass;
    padding: PaddingClass;
}

export interface PaddingClass {
    noHasScroll:          string;
    hasScroll:            string;
    removeSpace:          string;
    removeSpaceHasScroll: string;
}

export interface ContentClass {
    space: GroupTitleSpace;
}

export interface Partitions {
    color: PartitionsColor;
    size:  ContentSwitcherSize;
    shape: PartitionsShape;
    space: PartitionsSpace;
}

export interface PartitionsColor {
    background: HasContentClass;
}

export interface PartitionsShape {
    borderRadius: BorderRadiusEnum;
    opacity:      SearchCancelClass;
}

export interface PartitionsSpace {
    gap: Gap;
}

export interface Gap {
    hasSeparators: SquareClass;
}

export interface Popover {
    elevation: ModalElevation;
    shape:     HandlersShape;
    arrow:     PopoverArrow;
}

export interface PopoverArrow {
    shape: CheckTypeClass;
    size:  IndecentSize;
}

export interface IndecentSize {
    square: StickySquare;
}

export interface StickySquare {
    inner: number;
    outer: number;
}

export interface CmpProgressBar {
    size:     HilariousSize;
    shape:    HandlersShape;
    progress: Progress;
    track:    ProgressBarTrack;
}

export interface Progress {
    color: ProgressColor;
    shape: HandlersShape;
}

export interface ProgressColor {
    background: Background13;
}

export interface Background13 {
    base:    string;
    success: string;
    warning: CheckTypeWarning;
    error:   string;
    info:    string;
}

export interface HilariousSize {
    height: ShapeFontSize;
}

export interface ProgressBarTrack {
    color: ProgressColor;
}

export interface RadioControl {
    color:     FieldsColor;
    elevation: FieldsElevation;
    mutation:  FieldsMutation;
    shape:     CheckboxControlShape;
    size:      ScrollbarsSize;
    space:     RadioControlSpace;
    marker:    RadioControlMarker;
}

export interface RadioControlMarker {
    color: MenuColor;
    size:  ScrollbarsSize;
}

export interface RadioControlSpace {
    margin: SpaceValue;
}

export interface SelectControl {
    color:                   InputControlColor;
    elevation:               FieldsElevation;
    mutation:                FieldsMutation;
    shape:                   SelectControlShape;
    size:                    SelectControlSize;
    space:                   SelectControlSpace;
    chip:                    Wrapper;
    clearIndicator:          ClearIndicator;
    indicator:               Indicator;
    menuGroup:               MenuGroup;
    menuHeading:             MenuHeadingClass;
    menuList:                MenuList;
    menuOption:              MenuOption;
    menuWrapper:             Wrapper;
    menu:                    SelectControlMenu;
    multiValueContainer:     MultiValueContainer;
    multiValueDraggable:     MultiValueDraggable;
    multiValueDraggableIcon: Nav;
    selectAll:               SelectAll;
    valueContainer:          ValueContainer;
    valueIcon:               ValueIconClass;
    valueWrapper:            ValueWrapper;
}

export interface ClearIndicator {
    size: ClearIndicatorSize;
}

export interface Indicator {
    size:     IndicatorSize;
    space:    GroupTitleSpace;
    mutation: FieldsMutation;
}

export interface IndicatorSize {
    width: SquareClass;
}

export interface SelectControlMenu {
    color: MenuColor;
    space: Space6;
}

export interface Space6 {
    marginTop:    PurpleMarginTop;
    marginBottom: MarginBottom;
    offset:       IndigoOffset;
}

export interface MarginBottom {
    isQuiet: string;
}

export interface IndigoOffset {
    top: OffsetTop;
}

export interface OffsetTop {
    isRelative: string;
}

export interface MenuGroup {
    space: ContentSwitcherSpace;
}

export interface MenuHeadingClass {
    color: HeadingColor;
    size:  MenuHeadingSize;
    typo:  MenuHeadingTypo;
    space: MenuHeadingSpace;
}

export interface MenuHeadingSize {
    minHeight: Height;
}

export interface Height {
    base:             string;
    isMultipleSubtle: string;
}

export interface MenuHeadingSpace {
    marginBottom: string;
    padding:      Translation;
}

export interface MenuHeadingTypo {
    lineHeight: Height;
}

export interface MenuList {
    color: MenuColor;
    size:  ListSize;
    space: GroupTitleSpace;
}

export interface MenuOption {
    color:    MenuOptionColor;
    mutation: FieldsMutation;
    shape:    HandlersShape;
    space:    AddonSpace;
    typo:     MenuHeadingTypo;
    size:     MenuHeadingSize;
}

export interface MultiValueContainer {
    color: MultiValueContainerColor;
    space: MultiValueContainerSpace;
}

export interface MultiValueContainerColor {
    text: MagentaBorder;
}

export interface MultiValueContainerSpace {
    gap:          BorderRadiusEnum;
    margin:       PaddingRightClass;
    padding:      AmbitiousPadding;
    paddingRight: PaddingRightClass;
    marginLeft:   Margin;
    marginRight:  Margin;
}

export interface PaddingRightClass {
    chip: string;
}

export interface Margin {
    button: string;
}

export interface AmbitiousPadding {
    hor: PurpleHor;
}

export interface PurpleHor {
    isSubtle: BorderRadiusEnum;
}

export interface MultiValueDraggable {
    color:     PseudoCalendarColor;
    elevation: ChipElevation;
    mutation:  FieldsMutation;
}

export interface SelectAll {
    space: SelectAllSpace;
    shape: SelectAllShape;
}

export interface SelectAllShape {
    border: BraggadociousBorder;
}

export interface BraggadociousBorder {
    bottom: string;
}

export interface SelectAllSpace {
    padding: CunningPadding;
}

export interface CunningPadding {
    base:             MediaQuery;
    isMultipleSubtle: MediaQuery;
}

export interface SelectControlShape {
    borderRadius: BorderRadiusEnum;
    borderSize:   SpaceValue;
    opacity:      PurpleOpacity;
}

export interface SelectControlSize {
    width:     MediaQuery;
    height:    SquareClass;
    maxHeight: PurpleMaxHeight;
}

export interface PurpleMaxHeight {
    isMultiple: MediaQuery;
}

export interface SelectControlSpace {
    padding: MagentaPadding;
    offset:  SpaceMargin;
}

export interface SpaceMargin {
    scroll: string;
}

export interface MagentaPadding {
    hor:      SquareClass;
    scroll:   string;
    sortable: string;
}

export interface ValueContainer {
    space: AddonSpace;
}

export interface ValueIconClass {
    size:  ScrollbarsSize;
    space: ValueIconSpace;
}

export interface ValueWrapper {
    size: ValueWrapperSize;
}

export interface ValueWrapperSize {
    maxHeight: FluffyMaxHeight;
}

export interface FluffyMaxHeight {
    base:       MediaQuery;
    isMultiple: MediaQuery;
    maxWidth:   MaxWidth;
}

export interface MaxWidth {
    isMultipleSubtle: string;
}

export interface SplitLayout {
    color:    SplitLayoutColor;
    mutation: FieldsMutation;
    size:     SplitLayoutSize;
    shape:    SplitLayoutShape;
}

export interface SplitLayoutColor {
    text:       SpaceValue;
    background: Background14;
    border:     EditorIndentGuideEnum;
}

export interface Background14 {
    base:     EditorOverviewRulerEnum;
    hovered:  string;
    pressed:  string;
    dragging: string;
}

export interface SplitLayoutShape {
    borderSize: OffsetClass;
}

export interface SplitLayoutSize {
    square: number;
}

export interface StatusMessage {
    shape: SketchPickerInputShape;
    color: ShapeClass;
}

export interface Stepper {
    container:     StepperContainer;
    item:          StepperItem;
    itemIndicator: Thumbnail;
    separator:     StepperSeparator;
}

export interface StepperContainer {
    color: AppBarColor;
    size:  ContentSwitcherSize;
    space: ContentSwitcherSpace;
    shape: CheckTypeClass;
}

export interface StepperItem {
    color: Color13;
    space: HeaderButtonsSpace;
}

export interface Color13 {
    text: Text2;
}

export interface Text2 {
    base:    string;
    current: Active;
}

export interface Thumbnail {
    shape: LinkShape;
}

export interface StepperSeparator {
    color: AppLayoutColor;
    space: CellActionsSpace;
}

export interface Strong {
    typo: StrongTypo;
}

export interface StrongTypo {
    fontWeight: BorderClass;
}

export interface SwitchControl {
    shape:   LinkShape;
    handler: SwitchControlHandler;
    text:    SwitchControlText;
    track:   SwitchControlTrack;
}

export interface SwitchControlHandler {
    elevation: HandlersElevation;
    size:      ScrollbarsSize;
    shape:     HandlersShape;
    mutation:  FieldsMutation;
    color:     HandlersColor;
}

export interface SwitchControlText {
    typo:  TextTypo;
    color: TextColor;
}

export interface TextColor {
    text: Text3;
}

export interface Text3 {
    unchecked: CheckedClass;
    checked:   CheckedClass;
}

export interface TextTypo {
    fontSize:      SquareClass;
    lineHeight:    SquareClass;
    letterSpacing: string;
    fontWeight:    string;
}

export interface SwitchControlTrack {
    elevation: ChipElevation;
    size:      ColorPickerSize;
    shape:     HandlersShape;
    mutation:  FieldsMutation;
    color:     Color14;
}

export interface Color14 {
    background: Text3;
}

export interface Table {
    afterRowAction:       AfterRowAction;
    body:                 Highlighted;
    cellActions:          CellActions;
    cellBoolean:          CellBoolean;
    cellEditableFooter:   CellEditableFooter;
    cellExpandMarker:     CellExpandMarker;
    cellMarker:           CellMarker;
    cellQuickActions:     CellQuickActions;
    cellClickableWrapper: CellClickableWrapper;
    cellExpandedContent:  CellExpandedContentClass;
    cellExpandedWrapper:  CellExpandedWrapper;
    cellWrapper:          CellWrapper;
    cell:                 Cell;
    filterColumnsCell:    FilterColumnsCell;
    filter:               Filter;
    headCellGrabber:      HeadCellGrabber;
    headCellOrder:        HeadCellOrder;
    headCellSeparator:    HeadCellSeparator;
    headCell:             HeadCell;
    headRow:              HeadRow;
    head:                 Head;
    row:                  Row;
}

export interface AfterRowAction {
    color:    AfterRowActionColor;
    typo:     BackdropTypo;
    mutation: FieldsMutation;
}

export interface AfterRowActionColor {
    background: MagentaBorder;
    text:       MagentaBorder;
}

export interface Cell {
    color:     CellColor;
    elevation: CellElevation;
    mutation:  FieldsMutation;
    shape:     CheckTypeClass;
    space:     CellSpace;
}

export interface CellColor {
    background: Background15;
    border:     string;
    text:       SpaceValue;
}

export interface Background15 {
    backdrop: FluffyBackdrop;
}

export interface FluffyBackdrop {
    hovered: BorderClass;
}

export interface CellElevation {
    zIndex: IndecentZIndex;
}

export interface IndecentZIndex {
    columnHighlight: string;
}

export interface CellSpace {
    padding: FriskyPadding;
}

export interface FriskyPadding {
    hor: PaddingHeight;
    ver: Ver;
}

export interface PaddingHeight {
    compact:     string;
    default:     string;
    comfortable: string;
}

export interface Ver {
    compact:     PurpleComfortable;
    default:     PurpleComfortable;
    comfortable: PurpleComfortable;
}

export interface PurpleComfortable {
    base: string;
    tall: string;
}

export interface CellActions {
    size:  RulerSize;
    space: CellActionsSpace;
}

export interface CellBoolean {
    color: HeadingColor;
    size:  CellBooleanSize;
}

export interface CellBooleanSize {
    square: IndigoSquare;
}

export interface IndigoSquare {
    true:  string;
    false: string;
}

export interface CellClickableWrapper {
    elevation: AppBarElevation;
    color:     PseudoCalendarColor;
    mutation:  FieldsMutation;
}

export interface CellEditableFooter {
    color: ShapeClass;
    shape: CheckTypeClass;
}

export interface CellExpandMarker {
    typo: BackdropTypo;
}

export interface CellExpandedWrapper {
    elevation: CellExpandedWrapperElevation;
    typo:      RealTimeButtonTypo;
    color:     AppLayoutColor;
    size:      IndicatorSize;
}

export interface CellExpandedWrapperElevation {
    zIndex: string;
}

export interface CellMarker {
    color:    LinkLegalColor;
    mutation: FieldsMutation;
}

export interface CellQuickActions {
    shape:    TransitionDurationClass;
    size:     RulerSize;
    space:    HeaderButtonsSpace;
    mutation: FieldsMutation;
}

export interface CellWrapper {
    typo:      RealTimeButtonTypo;
    elevation: CellWrapperElevation;
    space:     CellWrapperSpace;
}

export interface CellWrapperElevation {
    boxShadow: AmbitiousBoxShadow;
}

export interface AmbitiousBoxShadow {
    before: BorderClass;
    after:  string;
}

export interface CellWrapperSpace {
    padding: MischievousPadding;
}

export interface MischievousPadding {
    hor: VerClass;
    ver: VerClass;
}

export interface VerClass {
    compact:     HorComfortable;
    default:     HorComfortable;
    comfortable: HorComfortable;
}

export interface HorComfortable {
    afterRow:   string;
    expanded:   string;
    expandedLg: string;
}

export interface Filter {
    shape: HandlersShape;
    space: Spac;
}

export interface FilterColumnsCell {
    space: FilterColumnsCellSpace;
}

export interface Head {
    color:     AppLayoutColor;
    elevation: HeadElevation;
    size:      HeadSize;
}

export interface HeadElevation {
    boxShadow: string;
    zIndex:    string;
}

export interface HeadSize {
    height: PaddingHeight;
}

export interface HeadCell {
    elevation: AppBarElevation;
}

export interface HeadCellGrabber {
    elevation: BarElevation;
    color:     HeadCellGrabberColor;
    mutation:  FieldsMutation;
}

export interface HeadCellGrabberColor {
    background: Background16;
}

export interface Background16 {
    after:   Checked;
    hovered: string;
}

export interface HeadCellOrder {
    color:    LabelIconColor;
    shape:    HeadCellOrderShape;
    mutation: FieldsMutation;
    size:     ItemSymbolSize;
    space:    HeadCellOrderSpace;
}

export interface HeadCellOrderShape {
    opacity: TentacledOpacity;
}

export interface TentacledOpacity {
    base:     string;
    selected: string;
}

export interface HeadCellSeparator {
    color: HeadCellSeparatorColor;
}

export interface HeadCellSeparatorColor {
    background: ColorBorderSize;
}

export interface ColorBorderSize {
    after: string;
}

export interface HeadRow {
    color: HeadRowColor;
    shape: HeadRowShape;
}

export interface HeadRowColor {
    background: Background17;
}

export interface Background17 {
    after: After;
}

export interface After {
    base:     Weak;
    scrolled: App;
}

export interface HeadRowShape {
    borderSize: ShapeFontSize;
}

export interface Row {
    color:     RowColor;
    elevation: RowElevation;
    size:      RowSize;
    shape:     RowShape;
    mutation:  RowMutation;
}

export interface RowColor {
    background: Background18;
}

export interface Background18 {
    modifiedBlink: string;
    even:          Even;
    odd:           Even;
    after:         string;
}

export interface Even {
    base:        string;
    created:     Created;
    deleted:     App;
    afterRow:    HandlerEnum;
    highlighted: string;
    expanded:    string;
    selected:    string;
}

export interface RowElevation {
    boxShadow: CunningBoxShadow;
    zIndex:    HilariousZIndex;
}

export interface CunningBoxShadow {
    isDragging: string;
}

export interface HilariousZIndex {
    isAfterRow: string;
}

export interface RowMutation {
    transitionDuration: IndigoTransitionDuration;
}

export interface IndigoTransitionDuration {
    bgColor:       string;
    modifiedBlink: string;
}

export interface RowShape {
    borderRadius: PaddingHeight;
    borderSize:   ColorBorderSize;
    opacity:      PurpleOpacity;
}

export interface RowSize {
    height: IndecentHeight;
}

export interface IndecentHeight {
    compact:     MediaQuery;
    default:     MediaQuery;
    comfortable: MediaQuery;
}

export interface Tabs {
    aside:     Aside;
    container: TabsContainer;
    content:   ContentClass;
    divider:   TabsDivider;
    item:      TabsItem;
    mark:      Mark;
}

export interface Aside {
    color: ShapeClass;
    shape: CheckTypeClass;
    space: GroupTitleSpace;
}

export interface TabsContainer {
    color: AppBarColor;
    size:  ContentSwitcherSize;
    space: GroupTitleSpace;
    shape: CheckTypeClass;
}

export interface TabsDivider {
    space: WrapperSpace;
    color: AppLayoutColor;
}

export interface TabsItem {
    color: Color15;
    size:  ContentSwitcherSize;
    space: Space7;
    shape: HandlersShape;
    typo:  RealTimeButtonTypo;
}

export interface Color15 {
    background: Background19;
    text:       Text4;
}

export interface Background19 {
    hover: string;
}

export interface Text4 {
    enabled:  string;
    hovered:  string;
    selected: string;
    disabled: string;
}

export interface Space7 {
    padding: string;
    margin:  TentacledMargin;
}

export interface TentacledMargin {
    iconToText: string;
}

export interface Mark {
    color:    MarkColor;
    mutation: FieldsMutation;
    size:     ItemGroupHeadingSize;
    space:    GroupTitleSpace;
    shape:    HandlersShape;
}

export interface MarkColor {
    fill: IndigoFill;
}

export interface IndigoFill {
    default: string;
    primary: string;
}

export interface Tag {
    shape: HandlersShape;
    size:  TagSize;
    space: TagSpace;
    color: TagColor;
    badge: TagBadge;
    icon:  ValueIconClass;
}

export interface TagBadge {
    space: ValueIconSpace;
}

export interface TagColor {
    background: HasContentClass;
    text:       HasContentClass;
}

export interface TagSize {
    height: SquareClass;
}

export interface TagSpace {
    padding: BraggadociousPadding;
}

export interface BraggadociousPadding {
    hor: LayoutClass;
}

export interface TagGroup {
    shape: HandlersShape;
    space: AddonSpace;
    size:  ContentSwitcherSize;
    color: TagColor;
    item:  TagGroupItem;
    label: TagGroupLabel;
}

export interface TagGroupItem {
    space: Space8;
}

export interface Space8 {
    margin: MarginClass;
}

export interface MarginClass {
    hor: MediaQuery;
    ver: MediaQuery;
}

export interface TagGroupLabel {
    size:  ContentSwitcherSize;
    space: Space9;
}

export interface Space9 {
    marginRight:  string;
    marginBottom: LayoutClass;
}

export interface TextareaControl {
    color:     InputControlColor;
    elevation: InputControlElevation;
    mutation:  FieldsMutation;
    shape:     InputControlShape;
    size:      TextareaControlSize;
    space:     TextareaControlSpace;
}

export interface TextareaControlSize {
    width:  SpaceValue;
    height: SpaceValue;
}

export interface TextareaControlSpace {
    padding: MarginClass;
}

export interface Toast {
    color:            ToastColor;
    space:            HeaderButtonsSpace;
    size:             ToastSize;
    badge:            ToastBadge;
    content:          ToastContent;
    counter:          HeadCell;
    footer:           ToastFooter;
    footerActions:    FooterOns;
    header:           ToastHeader;
    headerIcon:       ToastHeaderIcon;
    headerSubtitle:   ListItem;
    progressBar:      ToastProgressBar;
    progressBarTrack: Highlighted;
    progressTrack:    ProgressTrack;
}

export interface ToastBadge {
    elevation: CellExpandedWrapperElevation;
}

export interface ToastColor {
    background: FillClass;
    border:     FillClass;
}

export interface ToastContent {
    space: Space10;
}

export interface Space10 {
    margin:  SpaceMargin;
    padding: Padding1;
}

export interface Padding1 {
    collapse: string;
    default:  string;
    scroll:   string;
}

export interface ToastFooter {
    space: Space11;
}

export interface Space11 {
    padding: Padding2;
}

export interface Padding2 {
    default: string;
    scroll:  string;
}

export interface ToastHeader {
    space: Space12;
}

export interface Space12 {
    padding: Padding3;
}

export interface Padding3 {
    collapse: string;
    default:  string;
}

export interface ToastHeaderIcon {
    color: MagentaColor;
    typo:  DataLabelsTypo;
    space: ItemSymbolSpace;
    size:  RulerSize;
}

export interface ToastProgressBar {
    color: ProgressBarColor;
    size:  ItemGroupHeadingSize;
}

export interface ProgressTrack {
    color: ProgressTrackColor;
}

export interface ProgressTrackColor {
    background: NeutralClass;
}

export interface ToastSize {
    width: StickyWidth;
}

export interface StickyWidth {
    default: string;
}

export interface ToastList {
    space: string;
}

export interface Toolbar {
    color:   MenuColor;
    size:    ContentSwitcherSize;
    divider: AvatarWrapper;
    group:   Drawer;
}

export interface UploadFiles {
    shape:         SketchPickerInputShape;
    size:          CollapseSize;
    color:         AppBarColor;
    typo:          LinkLegalTypo;
    dataItemPanel: Drawer;
    dripBlob:      Highlighted;
    drop:          Visual;
    fileInfo:      FileInfo;
    fileProgress:  UserDetailsAvatarDomain;
    fileStatus:    FileStatus;
    file:          UserDetailsAvatarDomain;
    imageClip:     Highlighted;
    imagePreview:  ImagePreview;
    itemPanel:     ItemPanel;
    labelIcon:     LabelIcon;
    panelProgress: UserDetailsAvatarDomain;
}

export interface FileInfo {
    color: FileInfoColor;
    space: WrapperSpace;
}

export interface FileInfoColor {
    text: Text5;
}

export interface Text5 {
    base:    StickyBase;
    success: StickyBase;
    error:   StickyBase;
}

export interface StickyBase {
    main: string;
    sub:  string;
}

export interface FileStatus {
    color: FileStatusColor;
}

export interface FileStatusColor {
    text: Text6;
}

export interface Text6 {
    base: StickyBase;
}

export interface ImagePreview {
    color: ImagePreviewColor;
}

export interface ImagePreviewColor {
    background: HandlerEnum;
    text:       Text7;
}

export interface Text7 {
    dark:    string;
    light:   string;
    error:   Weak;
    success: Checked;
}

export interface ItemPanel {
    color:     ItemPanelColor;
    elevation: AppBarElevation;
}

export interface ItemPanelColor {
    background: IndecentBackground;
}

export interface VaultFrame {
    color: VaultFrameColor;
}

export interface VaultFrameColor {
    background: Background20;
    text:       Background20;
}

export interface Background20 {
    warning: WarningStrongEnum;
    error:   string;
}

export interface Widget {
    elevation: ChipElevation;
    icon:      Visual;
}

export interface Meta {
    scheme: string;
}