@tracktor/design-system 4.24.0 → 4.25.0

package/dist/node_modules/@mui/material/esm/Typography/Typography.d.ts

@@ -0,0 +1,99 @@
+import { OverridableStringUnion } from '@mui/types';
+import { SxProps, SystemProps } from '@mui/system';
+import { Theme, TypeText } from '../styles/index.js';
+import { OverrideProps, OverridableComponent } from '../OverridableComponent/index.js';
+import { TypographyVariant } from '../styles/createTypography.js';
+import { TypographyClasses } from './typographyClasses.js';
+import * as React from 'react';
+export interface TypographyPropsVariantOverrides {}
+export interface TypographyPropsColorOverrides {}
+export interface TypographyOwnProps extends Omit<SystemProps<Theme>, 'color'> {
+  /**
+   * Set the text-align on the component.
+   * @default 'inherit'
+   */
+  align?: 'inherit' | 'left' | 'center' | 'right' | 'justify';
+  /**
+   * The content of the component.
+   */
+  children?: React.ReactNode;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<TypographyClasses>;
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   */
+  color?: OverridableStringUnion<'primary' | 'secondary' | 'success' | 'error' | 'info' | 'warning' | `text${Capitalize<keyof TypeText>}`, TypographyPropsColorOverrides> | (string & {}); // to work with v5 color prop type which allows any string
+  /**
+   * If `true`, the text will have a bottom margin.
+   * @default false
+   */
+  gutterBottom?: boolean;
+  /**
+   * If `true`, the text will not wrap, but instead will truncate with a text overflow ellipsis.
+   *
+   * Note that text overflow can only happen with block or inline-block level elements
+   * (the element needs to have a width in order to overflow).
+   * @default false
+   */
+  noWrap?: boolean;
+  /**
+   * If `true`, the element will be a paragraph element.
+   * @default false
+   * @deprecated Use the `component` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  paragraph?: boolean;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+  /**
+   * Applies the theme typography styles.
+   * @default 'body1'
+   */
+  variant?: OverridableStringUnion<TypographyVariant | 'inherit', TypographyPropsVariantOverrides>;
+  /**
+   * The component maps the variant prop to a range of different HTML element types.
+   * For instance, subtitle1 to `<h6>`.
+   * If you wish to change that mapping, you can provide your own.
+   * Alternatively, you can use the `component` prop.
+   * @default {
+   *   h1: 'h1',
+   *   h2: 'h2',
+   *   h3: 'h3',
+   *   h4: 'h4',
+   *   h5: 'h5',
+   *   h6: 'h6',
+   *   subtitle1: 'h6',
+   *   subtitle2: 'h6',
+   *   body1: 'p',
+   *   body2: 'p',
+   *   inherit: 'p',
+   * }
+   */
+  variantMapping?: Partial<Record<OverridableStringUnion<TypographyVariant | 'inherit', TypographyPropsVariantOverrides>, string>>;
+}
+export interface TypographyTypeMap<AdditionalProps = {}, RootComponent extends React.ElementType = 'span'> {
+  props: AdditionalProps & TypographyOwnProps;
+  defaultComponent: RootComponent;
+}
+
+/**
+ *
+ * Demos:
+ *
+ * - [Breadcrumbs](https://mui.com/material-ui/react-breadcrumbs/)
+ * - [Typography](https://mui.com/material-ui/react-typography/)
+ *
+ * API:
+ *
+ * - [Typography API](https://mui.com/material-ui/api/typography/)
+ */
+declare const Typography: OverridableComponent<TypographyTypeMap>;
+export type TypographyProps<RootComponent extends React.ElementType = TypographyTypeMap['defaultComponent'], AdditionalProps = {}> = OverrideProps<TypographyTypeMap<AdditionalProps, RootComponent>, RootComponent> & {
+  component?: React.ElementType;
+};
+export default Typography;

package/dist/node_modules/@mui/material/esm/Typography/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from './Typography.js';
+export * from './Typography.js';
+export { default as typographyClasses } from './typographyClasses.js';
+export * from './typographyClasses.js';

package/dist/node_modules/@mui/material/esm/Typography/typographyClasses.d.ts

@@ -0,0 +1,53 @@
+export interface TypographyClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the root element if `variant="body2"`. */
+  body2: string;
+  /** Styles applied to the root element if `variant="body1"`. */
+  body1: string;
+  /** Styles applied to the root element if `variant="caption"`. */
+  caption: string;
+  /** Styles applied to the root element if `variant="button"`. */
+  button: string;
+  /** Styles applied to the root element if `variant="h1"`. */
+  h1: string;
+  /** Styles applied to the root element if `variant="h2"`. */
+  h2: string;
+  /** Styles applied to the root element if `variant="h3"`. */
+  h3: string;
+  /** Styles applied to the root element if `variant="h4"`. */
+  h4: string;
+  /** Styles applied to the root element if `variant="h5"`. */
+  h5: string;
+  /** Styles applied to the root element if `variant="h6"`. */
+  h6: string;
+  /** Styles applied to the root element if `variant="subtitle1"`. */
+  subtitle1: string;
+  /** Styles applied to the root element if `variant="subtitle2"`. */
+  subtitle2: string;
+  /** Styles applied to the root element if `variant="overline"`. */
+  overline: string;
+  /** Styles applied to the root element if `variant="inherit"`. */
+  inherit: string;
+  /** Styles applied to the root element if `align="left"`. */
+  alignLeft: string;
+  /** Styles applied to the root element if `align="center"`. */
+  alignCenter: string;
+  /** Styles applied to the root element if `align="right"`. */
+  alignRight: string;
+  /** Styles applied to the root element if `align="justify"`. */
+  alignJustify: string;
+  /** Styles applied to the root element if `nowrap={true}`. */
+  noWrap: string;
+  /** Styles applied to the root element if `gutterBottom={true}`. */
+  gutterBottom: string;
+  /**
+   * Styles applied to the root element if `paragraph={true}`.
+   * @deprecated
+   */
+  paragraph: string;
+}
+export type TypographyClassKey = keyof TypographyClasses;
+export declare function getTypographyUtilityClass(slot: string): string;
+declare const typographyClasses: TypographyClasses;
+export default typographyClasses;

package/dist/node_modules/@mui/material/esm/Unstable_TrapFocus/FocusTrap.d.ts

@@ -0,0 +1,10 @@
+import { FocusTrapProps } from './FocusTrap.types.js';
+import * as React from 'react';
+/**
+ * @ignore - internal component.
+ */
+declare function FocusTrap(props: FocusTrapProps): React.JSX.Element;
+declare namespace FocusTrap {
+  var propTypes: any;
+}
+export default FocusTrap;

package/dist/node_modules/@mui/material/esm/Unstable_TrapFocus/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './FocusTrap.js';
+export { FocusTrapProps as TrapFocusProps } from './FocusTrap.types.js';

package/dist/node_modules/@mui/material/esm/styles/ThemeProvider.d.ts

@@ -0,0 +1,76 @@
+import { DefaultTheme } from '@mui/system';
+import { StorageManager } from '@mui/system/cssVars';
+import { CssThemeVariables } from './createThemeNoVars.js';
+import * as React from 'react';
+type ThemeProviderCssVariablesProps = CssThemeVariables extends {
+  enabled: true;
+} ? {
+  /**
+   * The node for attaching the `theme.colorSchemeSelector`.
+   * @default document
+   */
+  colorSchemeNode?: Element | null;
+  /**
+   * If `true`, the provider creates its own context and generate stylesheet as if it is a root `ThemeProvider`.
+   */
+  disableNestedContext?: boolean;
+  /**
+   * If `true`, the style sheet for CSS theme variables won't be generated.
+   *
+   * This is useful for controlling nested ThemeProvider behavior.
+   * @default false
+   */
+  disableStyleSheetGeneration?: boolean;
+  /**
+   * If `true`, theme values are recalculated when the mode changes.
+   * The `theme.colorSchemes.{mode}.*` nodes will be shallow merged to the top-level of the theme.
+   * @default false
+   */
+  forceThemeRerender?: boolean;
+} : {};
+export interface ThemeProviderProps<Theme = DefaultTheme> extends ThemeProviderCssVariablesProps {
+  children?: React.ReactNode;
+  theme: Partial<Theme> | ((outerTheme: Theme) => Theme);
+  /**
+   * The document used to perform `disableTransitionOnChange` feature
+   * @default document
+   */
+  documentNode?: Document | null;
+  /**
+   * The default mode when the local storage has no mode yet,
+   * requires the theme to have `colorSchemes` with light and dark.
+   * @default 'system'
+   */
+  defaultMode?: 'light' | 'dark' | 'system';
+  /**
+   * The window that attaches the 'storage' event listener
+   * @default window
+   */
+  storageWindow?: Window | null;
+  /**
+   * The storage manager to be used for storing the mode and color scheme
+   * @default using `window.localStorage`
+   */
+  storageManager?: StorageManager | null;
+  /**
+   * localStorage key used to store application `mode`
+   * @default 'mui-mode'
+   */
+  modeStorageKey?: string;
+  /**
+   * localStorage key used to store `colorScheme`
+   * @default 'mui-color-scheme'
+   */
+  colorSchemeStorageKey?: string;
+  noSsr?: boolean;
+  /**
+   * Disable CSS transitions when switching between modes or color schemes
+   * @default false
+   */
+  disableTransitionOnChange?: boolean;
+}
+export default function ThemeProvider<Theme = DefaultTheme>({
+  theme,
+  ...props
+}: ThemeProviderProps<Theme>): React.JSX.Element;
+export {};

package/dist/node_modules/@mui/material/esm/styles/ThemeProviderWithVars.d.ts

@@ -0,0 +1,51 @@
+import { SupportedColorScheme } from './createThemeWithVars.js';
+import * as React from 'react';
+declare const useColorScheme: () => import('@mui/system').ColorSchemeContextValue<SupportedColorScheme>, deprecatedGetInitColorSchemeScript: typeof import('@mui/system/InitColorSchemeScript').default;
+declare function Experimental_CssVarsProvider(props: any): React.JSX.Element;
+declare const getInitColorSchemeScript: typeof deprecatedGetInitColorSchemeScript;
+/**
+ * TODO: remove this export in v7
+ * @deprecated
+ * The `CssVarsProvider` component has been deprecated and ported into `ThemeProvider`.
+ *
+ * You should use `ThemeProvider` and `createTheme()` instead:
+ *
+ * ```diff
+ * - import { CssVarsProvider, extendTheme } from '@mui/material/styles';
+ * + import { ThemeProvider, createTheme } from '@mui/material/styles';
+ *
+ * - const theme = extendTheme();
+ * + const theme = createTheme({
+ * +   cssVariables: true,
+ * +   colorSchemes: { light: true, dark: true },
+ * + });
+ *
+ * - <CssVarsProvider theme={theme}>
+ * + <ThemeProvider theme={theme}>
+ * ```
+ *
+ * To see the full documentation, check out https://mui.com/material-ui/customization/css-theme-variables/usage/.
+ */
+export declare const CssVarsProvider: (props: React.PropsWithChildren<Partial<import('@mui/system').CssVarsProviderConfig<SupportedColorScheme>> & {
+  theme?: {
+    cssVariables?: false;
+    cssVarPrefix?: string;
+    colorSchemes: Partial<Record<SupportedColorScheme, any>>;
+    colorSchemeSelector?: "media" | "class" | "data" | string;
+  } | {
+    $$material: {
+      cssVariables?: false;
+      cssVarPrefix?: string;
+      colorSchemes: Partial<Record<SupportedColorScheme, any>>;
+      colorSchemeSelector?: "media" | "class" | "data" | string;
+    };
+  } | undefined;
+  defaultMode?: "light" | "dark" | "system";
+  documentNode?: Document | null;
+  colorSchemeNode?: Element | null;
+  storageManager?: import('@mui/system').StorageManager | null;
+  storageWindow?: Window | null;
+  disableNestedContext?: boolean;
+  disableStyleSheetGeneration?: boolean;
+}>) => React.JSX.Element;
+export { useColorScheme, getInitColorSchemeScript, Experimental_CssVarsProvider };

package/dist/node_modules/@mui/material/esm/styles/adaptV4Theme.d.ts

@@ -0,0 +1,36 @@
+import { BreakpointsOptions, ShapeOptions, SpacingOptions } from '@mui/system';
+import { MixinsOptions } from './createMixins.js';
+import { Palette, PaletteOptions } from './createPalette.js';
+import { TypographyVariantsOptions } from './createTypography.js';
+import { Shadows } from './shadows.js';
+import { TransitionsOptions } from './createTransitions.js';
+import { ZIndexOptions } from './zIndex.js';
+import { ComponentsOverrides } from './overrides.js';
+import { ComponentsVariants } from './variants.js';
+import { ComponentsProps } from './props.js';
+import { Theme } from './createTheme.js';
+export type Direction = 'ltr' | 'rtl';
+export interface DeprecatedThemeOptions {
+  shape?: ShapeOptions;
+  breakpoints?: BreakpointsOptions;
+  direction?: Direction;
+  mixins?: MixinsOptions;
+  overrides?: ComponentsOverrides;
+  palette?: PaletteOptions;
+  props?: ComponentsProps;
+  shadows?: Shadows;
+  spacing?: SpacingOptions;
+  transitions?: TransitionsOptions;
+  typography?: TypographyVariantsOptions | ((palette: Palette) => TypographyVariantsOptions);
+  variants?: ComponentsVariants;
+  zIndex?: ZIndexOptions;
+  unstable_strictMode?: boolean;
+}
+
+/**
+ * Generate a theme base on the V4 theme options received.
+ * @deprecated Follow the upgrade guide on https://mui.com/r/migration-v4#theme
+ * @param options Takes an incomplete theme object and adds the missing parts.
+ * @returns A complete, ready-to-use theme object.
+ */
+export default function adaptV4Theme(options?: DeprecatedThemeOptions): Theme;

package/dist/node_modules/@mui/material/esm/styles/createColorScheme.d.ts

@@ -0,0 +1,11 @@
+import { ColorSystemOptions } from './createThemeWithVars.js';
+export declare function getOpacity(mode: 'light' | 'dark'): {
+  inputPlaceholder: number;
+  inputUnderline: number;
+  switchTrackDisabled: number;
+  switchTrack: number;
+};
+export declare function getOverlays(mode: 'light' | 'dark'): string[];
+export default function createColorScheme(options: ColorSystemOptions & {
+  colorSpace?: string;
+}): ColorSystemOptions;

package/dist/node_modules/@mui/material/esm/styles/createMixins.d.ts

@@ -0,0 +1,32 @@
+import { Breakpoints } from '@mui/system';
+import * as CSS from 'csstype';
+export type NormalCssProperties = CSS.Properties<number | string>;
+export type Fontface = CSS.AtRule.FontFace & {
+  fallbacks?: CSS.AtRule.FontFace[];
+};
+
+/**
+ * Allows the user to augment the properties available
+ */
+export interface BaseCSSProperties extends NormalCssProperties {
+  '@font-face'?: Fontface | Fontface[];
+}
+export interface CSSProperties extends BaseCSSProperties {
+  // Allow pseudo selectors and media queries
+  // `unknown` is used since TS does not allow assigning an interface without
+  // an index signature to one with an index signature. This is to allow type safe
+  // module augmentation.
+  // Technically we want any key not typed in `BaseCSSProperties` to be of type
+  // `CSSProperties` but this doesn't work. The index signature needs to cover
+  // BaseCSSProperties as well. Usually you would use `BaseCSSProperties[keyof BaseCSSProperties]`
+  // but this would not allow assigning React.CSSProperties to CSSProperties
+  [k: string]: unknown | CSSProperties;
+}
+export interface Mixins {
+  toolbar: CSSProperties;
+  // ... use interface declaration merging to add custom mixins
+}
+export interface MixinsOptions extends Partial<Mixins> {
+  // ... use interface declaration merging to add custom mixin options
+}
+export default function createMixins(breakpoints: Breakpoints, mixins: MixinsOptions): Mixins;

package/dist/node_modules/@mui/material/esm/styles/createPalette.d.ts

@@ -0,0 +1,125 @@
+export type PaletteMode = 'light' | 'dark';
+export interface Color {
+  50: string;
+  100: string;
+  200: string;
+  300: string;
+  400: string;
+  500: string;
+  600: string;
+  700: string;
+  800: string;
+  900: string;
+  A100: string;
+  A200: string;
+  A400: string;
+  A700: string;
+}
+export {};
+// use standalone interface over typeof colors/commons
+// to enable module augmentation
+export interface CommonColors {
+  black: string;
+  white: string;
+}
+export type ColorPartial = Partial<Color>;
+export interface TypeText {
+  primary: string;
+  secondary: string;
+  disabled: string;
+}
+export interface TypeAction {
+  active: string;
+  hover: string;
+  hoverOpacity: number;
+  selected: string;
+  selectedOpacity: number;
+  disabled: string;
+  disabledOpacity: number;
+  disabledBackground: string;
+  focus: string;
+  focusOpacity: number;
+  activatedOpacity: number;
+}
+export interface TypeBackground {
+  default: string;
+  paper: string;
+}
+export type TypeDivider = string;
+export type PaletteColorOptions = SimplePaletteColorOptions | ColorPartial;
+export interface SimplePaletteColorOptions {
+  light?: string;
+  main: string;
+  dark?: string;
+  contrastText?: string;
+}
+export interface PaletteColor {
+  light: string;
+  main: string;
+  dark: string;
+  contrastText: string;
+}
+export interface TypeObject {
+  text: TypeText;
+  action: TypeAction;
+  divider: TypeDivider;
+  background: TypeBackground;
+}
+export type PaletteTonalOffset = number | {
+  light: number;
+  dark: number;
+};
+export const light: TypeObject;
+export const dark: TypeObject;
+export interface PaletteAugmentColorOptions {
+  color: PaletteColorOptions;
+  mainShade?: number | string;
+  lightShade?: number | string;
+  darkShade?: number | string;
+  name?: number | string;
+}
+export interface Palette {
+  common: CommonColors;
+  mode: PaletteMode;
+  contrastThreshold: number;
+  tonalOffset: PaletteTonalOffset;
+  primary: PaletteColor;
+  secondary: PaletteColor;
+  error: PaletteColor;
+  warning: PaletteColor;
+  info: PaletteColor;
+  success: PaletteColor;
+  grey: Color;
+  text: TypeText;
+  divider: TypeDivider;
+  action: TypeAction;
+  background: TypeBackground;
+  getContrastText: (background: string) => string;
+  augmentColor: (options: PaletteAugmentColorOptions) => PaletteColor;
+}
+export interface Channels {
+  mainChannel: string;
+  lightChannel: string;
+  darkChannel: string;
+  contrastTextChannel: string;
+}
+export type PartialTypeObject = { [P in keyof TypeObject]?: Partial<TypeObject[P]> };
+export interface PaletteOptions {
+  primary?: PaletteColorOptions;
+  secondary?: PaletteColorOptions;
+  error?: PaletteColorOptions;
+  warning?: PaletteColorOptions;
+  info?: PaletteColorOptions;
+  success?: PaletteColorOptions;
+  mode?: PaletteMode;
+  tonalOffset?: PaletteTonalOffset;
+  contrastThreshold?: number;
+  common?: Partial<CommonColors>;
+  grey?: ColorPartial;
+  text?: Partial<TypeText>;
+  divider?: string;
+  action?: Partial<TypeAction>;
+  background?: Partial<TypeBackground>;
+  getContrastText?: (background: string) => string;
+}
+export default function createPalette(palette: PaletteOptions): Palette;

package/dist/node_modules/@mui/material/esm/styles/createStyles.d.ts

@@ -0,0 +1 @@
+export default function createStyles(styles: any): never;

package/dist/node_modules/@mui/material/esm/styles/createTheme.d.ts

@@ -0,0 +1,22 @@
+import { PaletteOptions } from './createPalette.js';
+import { ColorSystemOptions } from './createThemeFoundation.js';
+import { CssVarsThemeOptions } from './createThemeWithVars.js';
+import { Theme, CssThemeVariables } from './createThemeNoVars.js';
+export type { Theme, CssThemeVariables } from './createThemeNoVars.js';
+type CssVarsOptions = CssThemeVariables extends {
+  enabled: true;
+} ? ColorSystemOptions : {};
+type CssVarsConfigList = 'colorSchemeSelector' | 'rootSelector' | 'disableCssColorScheme' | 'cssVarPrefix' | 'shouldSkipGeneratingVar' | 'nativeColor';
+export interface ThemeOptions extends CssVarsOptions, Omit<CssVarsThemeOptions, CssVarsConfigList> {
+  cssVariables?: boolean | Pick<CssVarsThemeOptions, CssVarsConfigList>;
+  palette?: PaletteOptions;
+}
+/**
+ * Generate a theme base on the options received.
+ * @param options Takes an incomplete theme object and adds the missing parts.
+ * @param args Deep merge the arguments with the about to be returned theme.
+ * @returns A complete, ready-to-use theme object.
+ */
+export default function createTheme(options?: ThemeOptions,
+// cast type to skip module augmentation test
+...args: object[]): Theme;

package/dist/node_modules/@mui/material/esm/styles/createThemeNoVars.d.ts

@@ -0,0 +1,73 @@
+import { ThemeOptions as SystemThemeOptions, Theme as SystemTheme, SxProps, CSSObject, SxConfig } from '@mui/system';
+import { Mixins, MixinsOptions } from './createMixins.js';
+import { Palette, PaletteOptions } from './createPalette.js';
+import { TypographyVariants, TypographyVariantsOptions } from './createTypography.js';
+import { Shadows } from './shadows.js';
+import { Transitions, TransitionsOptions } from './createTransitions.js';
+import { ZIndex, ZIndexOptions } from './zIndex.js';
+import { Components } from './components.js';
+import { CssVarsTheme, CssVarsPalette, ColorSystemOptions } from './createThemeFoundation.js';
+/**
+ * To disable custom properties, use module augmentation
+ *
+ * @example
+ * declare module '@mui/material/styles' {
+ *   interface CssThemeVariables {
+ *     enabled: true;
+ *   }
+ * }
+ */
+export interface CssThemeVariables {}
+type CssVarsOptions = CssThemeVariables extends {
+  enabled: true;
+} ? ColorSystemOptions : {};
+export interface ThemeOptions extends Omit<SystemThemeOptions, 'zIndex'>, CssVarsOptions {
+  mixins?: MixinsOptions;
+  components?: Components<Omit<Theme, 'components'>>;
+  palette?: PaletteOptions;
+  shadows?: Shadows;
+  transitions?: TransitionsOptions;
+  typography?: TypographyVariantsOptions | ((palette: Palette) => TypographyVariantsOptions);
+  zIndex?: ZIndexOptions;
+  unstable_strictMode?: boolean;
+  unstable_sxConfig?: SxConfig;
+  modularCssLayers?: boolean | string;
+}
+export interface BaseTheme extends SystemTheme {
+  mixins: Mixins;
+  palette: Palette & (CssThemeVariables extends {
+    enabled: true;
+  } ? CssVarsPalette : {});
+  shadows: Shadows;
+  transitions: Transitions;
+  typography: TypographyVariants;
+  zIndex: ZIndex;
+  unstable_strictMode?: boolean;
+}
+
+// shut off automatic exporting for the `BaseTheme` above
+export {};
+type CssVarsProperties = CssThemeVariables extends {
+  enabled: true;
+} ? Pick<CssVarsTheme, 'applyStyles' | 'colorSchemes' | 'colorSchemeSelector' | 'rootSelector' | 'cssVarPrefix' | 'defaultColorScheme' | 'getCssVar' | 'getColorSchemeSelector' | 'generateThemeVars' | 'generateStyleSheets' | 'generateSpacing' | 'shouldSkipGeneratingVar' | 'vars'> : Partial<Pick<CssVarsTheme, 'vars'>>;
+
+/**
+ * Our [TypeScript guide on theme customization](https://mui.com/material-ui/guides/typescript/#customization-of-theme) explains in detail how you would add custom properties.
+ */
+export interface Theme extends BaseTheme, CssVarsProperties {
+  cssVariables?: false;
+  components?: Components<BaseTheme>;
+  unstable_sx: (props: SxProps<Theme>) => CSSObject;
+  unstable_sxConfig: SxConfig;
+  alpha: (color: string, value: number | string) => string;
+  lighten: (color: string, coefficient: number | string) => string;
+  darken: (color: string, coefficient: number | string) => string;
+}
+
+/**
+ * Generate a theme base on the options received.
+ * @param options Takes an incomplete theme object and adds the missing parts.
+ * @param args Deep merge the arguments with the about to be returned theme.
+ * @returns A complete, ready-to-use theme object.
+ */
+export default function createThemeNoVars(options?: ThemeOptions, ...args: object[]): Theme;