@jetbrains/ring-ui 4.1.3 → 5.0.0-beta.0

package/dist/global/conic-gradient.js

@@ -22,7 +22,7 @@ const conicGradientWithMask = (mask, stops, size) => {
   if (!mask.supports && gradient instanceof ConicGradient) {
     Object.defineProperty(gradient, 'svg', {
       value: gradient.svg.replace('<image ', `
-        ${mask.svgDefs}    
+        ${mask.svgDefs}
         <image mask="url(#${mask.maskId})" `)
     });
   }

package/dist/global/create-stateful-context.d.ts

@@ -0,0 +1,27 @@
+import React, { ReactNode } from 'react';
+import PropTypes from 'prop-types';
+declare type Update<T> = (value: T) => void;
+export interface ProviderProps {
+    children: ReactNode;
+}
+export interface UpdaterProps<T> {
+    value: T;
+    skipUpdate?: boolean;
+}
+export default function createStatefulContext<T>(initialValue: T, name?: string): {
+    ValueContext: React.Context<T>;
+    UpdateContext: React.Context<Update<T>>;
+    Provider: {
+        ({ children }: ProviderProps): JSX.Element;
+        propTypes: {
+            children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        };
+        displayName: string;
+    };
+    useUpdate: (value: T, skipUpdate?: boolean | undefined) => void;
+    Updater: React.MemoExoticComponent<{
+        ({ value, skipUpdate }: UpdaterProps<T>): null;
+        displayName: string;
+    }>;
+};
+export {};

package/dist/global/data-tests.d.ts

@@ -0,0 +1,3 @@
+declare type AttrsMap = Record<string, boolean | null | undefined>;
+export default function joinDataTestAttributes(...attrs: Array<string | AttrsMap | null | undefined>): string;
+export {};

package/dist/global/data-tests.js

@@ -10,7 +10,11 @@ function joinDataTestAttributes() {
     attrs[_key] = arguments[_key];
   }
 
-  return attrs.filter(attr => !!attr).reduce((result, attr) => {
+  return attrs.reduce((result, attr) => {
+    if (!attr) {
+      return result;
+    }
+
     if (typeof attr === 'object') {
       return [...result, ...expandMap(attr)];
     }

package/dist/global/dom.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @name DOM
+ */
+import { SyntheticEvent } from 'react';
+import type { PropertiesHyphen } from 'csstype';
+export declare const getStyles: ((elt: Element, pseudoElt?: string | null | undefined) => CSSStyleDeclaration) & typeof getComputedStyle;
+export declare function isMounted(node: Node | Range | null | undefined): boolean;
+export interface Rect {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export declare function getRect(node: Element | Range | null | undefined): Rect;
+export declare function getPixelRatio(): number;
+export declare function getWindowHeight(): number;
+export declare function getWindowWidth(): number;
+export declare function isNodeInVisiblePartOfPage(node: Element | Range): boolean;
+export declare function getDocumentScrollTop(): number;
+export declare function getDocumentScrollLeft(): number;
+export declare const applyMethodToClasses: (method: 'add' | 'remove') => (classList: DOMTokenList, classes?: string) => void;
+export declare const addClasses: (classList: DOMTokenList, classes?: string) => void;
+export declare const removeClasses: (classList: DOMTokenList, classes?: string) => void;
+export declare const toggleClasses: (classList: DOMTokenList, classes: Record<string, boolean>) => void;
+export declare function setRootStyleProperties(properties?: PropertiesHyphen): void;
+export declare function resetRootStyleProperties(properties?: Partial<Record<keyof PropertiesHyphen, unknown>>): void;
+export declare class Listeners {
+    private _all;
+    add<K extends keyof HTMLElementEventMap>(el: HTMLElement, event: K, handler: (this: HTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+    add<K extends keyof WindowEventMap>(el: Window, event: K, handler: (this: Window, ev: WindowEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+    add<K extends keyof DocumentEventMap>(el: Document, event: K, handler: (this: Window, ev: DocumentEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+    remove(fn: () => void): void;
+    removeAll(): void;
+}
+export declare function preventDefault(e: Event | SyntheticEvent): void;

package/dist/global/dom.js

@@ -20,7 +20,7 @@ const rectStub = {
   height: 0
 };
 function getRect(node) {
-  if (node instanceof Range || isMounted(node)) {
+  if (node instanceof Range || node != null && isMounted(node)) {
     const {
       top,
       right,
@@ -93,10 +93,10 @@ class Listeners {
     _defineProperty(this, "_all", new Set());
   }
 
-  add(el, event, handler, useCapture) {
-    el.addEventListener(event, handler, useCapture);
+  add(el, event, handler, options) {
+    el.addEventListener(event, handler, options);
 
-    const dispatchFn = () => el.removeEventListener(event, handler, useCapture);
+    const dispatchFn = () => el.removeEventListener(event, handler, options);
 
     this._all.add(dispatchFn);
 

package/dist/global/focus-sensor-hoc.d.ts

@@ -0,0 +1,18 @@
+import { ComponentType, Ref } from 'react';
+export interface FocusSensorOuterProps<T extends HTMLElement> {
+    focused?: boolean | undefined;
+    autofocus?: boolean | undefined;
+    onFocus?: (() => void) | undefined;
+    onBlur?: (() => void) | undefined;
+    innerRef?: Ref<T> | null | undefined;
+}
+export interface FocusSensorAddProps<T extends HTMLElement> {
+    innerRef: Ref<T>;
+    focused: boolean;
+    onFocusReset: () => void;
+    onFocusRestore: () => void;
+}
+declare type RestProps<P, T extends HTMLElement> = Omit<P, keyof FocusSensorAddProps<T>>;
+export declare type FocusSensorProps<P extends FocusSensorAddProps<T>, T extends HTMLElement, C extends ComponentType<P>> = RestProps<JSX.LibraryManagedAttributes<C, P>, T> & FocusSensorOuterProps<T>;
+export default function focusSensorHOC<T extends HTMLElement, P extends FocusSensorAddProps<T>, C extends ComponentType<P>>(ComposedComponent: C): ComponentType<FocusSensorProps<P, T, typeof ComposedComponent>>;
+export {};

package/dist/global/focus-sensor-hoc.js

@@ -1,12 +1,30 @@
 import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
+import { refObject } from './prop-types.js';
 import composeRefs from './composeRefs.js';
 
-function focusSensorHOC(ComposedComponent) {
-  var _class, _temp;
+function extractPropTypes(_ref) {
+  let {
+    propTypes
+  } = _ref;
+
+  if (propTypes == null) {
+    return propTypes;
+  }
+
+  const {
+    innerRef,
+    focused,
+    onFocusReset,
+    onFocusRestore,
+    ...restPropTypes
+  } = propTypes;
+  return restPropTypes;
+}
 
-  return _temp = _class = class FocusSensor extends Component {
+function focusSensorHOC(ComposedComponent) {
+  class FocusSensor extends Component {
     constructor() {
       super(...arguments);
 
@@ -14,6 +32,8 @@ function focusSensorHOC(ComposedComponent) {
         focused: this.props.focused
       });
 
+      _defineProperty(this, "node", void 0);
+
       _defineProperty(this, "_skipNextCapture", false);
 
       _defineProperty(this, "onRefUpdate", node => {
@@ -22,30 +42,34 @@ function focusSensorHOC(ComposedComponent) {
         }
       });
 
-      _defineProperty(this, "onFocusCapture", _ref => {
+      _defineProperty(this, "onFocusCapture", _ref2 => {
+        var _this$node;
+
         let {
           target
-        } = _ref;
+        } = _ref2;
 
         if (this._skipNextCapture) {
           this._skipNextCapture = false;
           return;
         }
 
-        const focused = this.node.contains(target);
+        const focused = target instanceof Node && ((_this$node = this.node) === null || _this$node === void 0 ? void 0 : _this$node.contains(target));
 
         if (focused && !this.state.focused) {
+          var _this$props$onFocus, _this$props;
+
           this.setState({
             focused: true
           });
-          this.props.onFocus();
+          (_this$props$onFocus = (_this$props = this.props).onFocus) === null || _this$props$onFocus === void 0 ? void 0 : _this$props$onFocus.call(_this$props);
         }
       });
 
-      _defineProperty(this, "onBlurCapture", _ref2 => {
+      _defineProperty(this, "onBlurCapture", _ref3 => {
         let {
           target
-        } = _ref2;
+        } = _ref3;
         const {
           state: {
             focused
@@ -55,25 +79,31 @@ function focusSensorHOC(ComposedComponent) {
 
         if (focused) {
           setTimeout(() => {
-            const blurred = node.contains(target) && !node.contains(document.activeElement);
+            const blurred = target instanceof Node && (node === null || node === void 0 ? void 0 : node.contains(target)) && !node.contains(document.activeElement);
 
             if (blurred) {
+              var _this$props$onBlur, _this$props2;
+
               this.setState({
                 focused: false
               });
-              this.props.onBlur();
+              (_this$props$onBlur = (_this$props2 = this.props).onBlur) === null || _this$props$onBlur === void 0 ? void 0 : _this$props$onBlur.call(_this$props2);
             }
           }, 1);
         }
       });
 
       _defineProperty(this, "onFocusRestore", () => {
+        var _this$node2;
+
         this._skipNextCapture = true;
-        this.node.focus();
+        (_this$node2 = this.node) === null || _this$node2 === void 0 ? void 0 : _this$node2.focus();
       });
 
       _defineProperty(this, "onFocusReset", () => {
-        this.node.blur();
+        var _this$node3;
+
+        (_this$node3 = this.node) === null || _this$node3 === void 0 ? void 0 : _this$node3.blur();
       });
     }
 
@@ -84,13 +114,17 @@ function focusSensorHOC(ComposedComponent) {
         },
         node
       } = this;
-      node.setAttribute('tabindex', '0');
-      node.style.outline = 'none';
+      node === null || node === void 0 ? void 0 : node.setAttribute('tabindex', '0');
+
+      if (node != null) {
+        node.style.outline = 'none';
+      }
+
       document.addEventListener('focus', this.onFocusCapture, true);
       document.addEventListener('blur', this.onBlurCapture, true);
 
       if (autofocus) {
-        node.focus();
+        node === null || node === void 0 ? void 0 : node.focus();
       }
     }
 
@@ -128,18 +162,22 @@ function focusSensorHOC(ComposedComponent) {
       }));
     }
 
-  }, _defineProperty(_class, "propTypes", { ...ComposedComponent.propTypes,
+  }
+
+  FocusSensor.propTypes = { ...extractPropTypes(ComposedComponent),
     focused: PropTypes.bool,
     autofocus: PropTypes.bool,
     onFocus: PropTypes.func,
     onBlur: PropTypes.func,
-    innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
-  }), _defineProperty(_class, "defaultProps", { ...ComposedComponent.defaultProps,
+    innerRef: PropTypes.oneOfType([PropTypes.func, refObject(PropTypes.instanceOf(HTMLElement))])
+  };
+  FocusSensor.defaultProps = { ...ComposedComponent.defaultProps,
     focused: false,
     autofocus: false,
     onFocus: () => {},
     onBlur: () => {}
-  }), _temp;
+  };
+  return FocusSensor;
 }
 
 export { focusSensorHOC as default };

package/dist/global/fuzzy-highlight.d.ts

@@ -0,0 +1,5 @@
+/** https://github.com/bevacqua/fuzzysearch + highlighting with Markdown */
+export default function fuzzyHighlight(needle: string, haystack: string, caseSensitive?: boolean): {
+    matched: boolean;
+    highlight: string;
+};

package/dist/global/get-event-key.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function getEventKey(nativeEvent: KeyboardEvent | React.KeyboardEvent): string;

package/dist/global/get-event-key.js

@@ -1,4 +1,3 @@
-// react-dom getEventKey function extracted
 const normalizeKey = {
   Esc: 'Escape',
   Spacebar: ' ',

package/dist/global/get-uid.d.ts

@@ -0,0 +1 @@
+export default function getUID(name: string): string;

package/dist/global/inject-styles.d.ts

@@ -0,0 +1,3 @@
+import type { PropertiesHyphen } from 'csstype';
+export declare const injectStyleSheet: (styles: string) => HTMLStyleElement;
+export declare const injectRuleSet: (selector: string, declarations: PropertiesHyphen) => HTMLStyleElement;

package/dist/global/linear-function.d.ts

@@ -0,0 +1,6 @@
+export interface LinearFunction {
+    y(x: number): number;
+    x(y: number): number;
+}
+export default function linearFunction(x0: number, y0: number, a: number): LinearFunction;
+export declare function interpolateLinear(x0: number, x1: number, phase: number): number;

package/dist/global/listeners.d.ts

@@ -0,0 +1,8 @@
+export declare type Handler<PM extends Record<string, [unknown, unknown]>, E extends keyof PM> = (data: PM[E][0]) => PM[E][1] | Promise<PM[E][1]>;
+export default class Listeners<PM extends Record<string, [unknown, unknown]> = Record<string, [void, unknown]>> {
+    _all: Map<keyof PM, Set<Handler<PM, keyof PM>>>;
+    trigger<E extends keyof PM>(...[event, data]: PM[E][0] extends void ? [E] : [E, PM[E][0]]): Promise<PM[E][1][]>;
+    add<E extends keyof PM>(event: E, handler: Handler<PM, E>): void;
+    remove<E extends keyof PM>(event: E, handler: Handler<PM, E>): void;
+    removeAll(): void;
+}

package/dist/global/listeners.js

@@ -1,9 +1,17 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+
 class Listeners {
   constructor() {
-    this.removeAll();
+    _defineProperty(this, "_all", new Map());
   }
 
-  trigger(event, data) {
+  trigger() {
+    for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+      _ref[_key] = arguments[_key];
+    }
+
+    let [event, data] = _ref;
+
     const handlers = this._all.get(event);
 
     if (handlers) {

package/dist/global/memoize.d.ts

@@ -0,0 +1 @@
+export default function memoize<A = void, T = void>(fn: (arg: A) => T): (arg: A) => T;

package/dist/global/memoize.js

@@ -1,16 +1,17 @@
 function memoize(fn) {
   const primitiveCache = new Map();
   const objectCache = new WeakMap();
-  return function memoized() {
-    let arg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '__singleValue__';
-    const cache = arg instanceof Object ? objectCache : primitiveCache;
+  return function memoized(arg) {
+    const key = arg !== null && arg !== void 0 ? arg : '__singleValue__';
+    const cache = key instanceof Object ? objectCache : primitiveCache;
+    const cached = cache.get(key);
 
-    if (cache.has(arg)) {
-      return cache.get(arg);
+    if (cached != null) {
+      return cached;
     }
 
     const value = fn(arg);
-    cache.set(arg, value);
+    cache.set(key, value);
     return value;
   };
 }

package/dist/global/normalize-indent.d.ts

@@ -0,0 +1 @@
+export default function normalizeIndent(string: string): string;

package/dist/global/normalize-indent.js

@@ -20,7 +20,11 @@ function normalizeIndent(string) {
     }
   }
 
-  const indents = lines.filter(line => nonemptyRE.test(line)).map(line => line.match(indentRE)[0].length);
+  const indents = lines.filter(line => nonemptyRE.test(line)).map(line => {
+    var _line$match$0$length, _line$match;
+
+    return (_line$match$0$length = (_line$match = line.match(indentRE)) === null || _line$match === void 0 ? void 0 : _line$match[0].length) !== null && _line$match$0$length !== void 0 ? _line$match$0$length : 0;
+  });
   const minIndent = Math.min(...indents);
   return lines.map(line => line.slice(minIndent)).join('\n');
 }

package/dist/global/promise-with-timeout.d.ts

@@ -0,0 +1,4 @@
+export interface PromiseWithTimeoutConfig {
+    error?: Error | null | undefined;
+}
+export default function promiseWithTimeout<T>(promise: Promise<T>, timeout: number, { error }: PromiseWithTimeoutConfig): Promise<unknown>;

package/dist/global/prop-types.d.ts

@@ -0,0 +1,4 @@
+import PropTypes from 'prop-types';
+export declare const refObject: <T>(value: PropTypes.Validator<T>) => PropTypes.Requireable<PropTypes.InferProps<{
+    current: PropTypes.Validator<T>;
+}>>;

package/dist/global/prop-types.js

@@ -0,0 +1,7 @@
+import PropTypes from 'prop-types';
+
+const refObject = value => PropTypes.shape({
+  current: value
+});
+
+export { refObject };

package/dist/global/radial-gradient-mask.d.ts

@@ -0,0 +1,9 @@
+import type { PropertiesHyphen } from 'csstype';
+export interface RadialGradientMask {
+    supports: boolean;
+    css: PropertiesHyphen;
+    maskId?: string;
+    svgDefs?: string;
+}
+declare const _default: (length: string, stops: Record<string, string>) => RadialGradientMask;
+export default _default;

package/dist/global/react-dom-renderer.d.ts

@@ -0,0 +1,16 @@
+import { Component } from 'react';
+import PropTypes from 'prop-types';
+export interface RendererProps {
+    className?: string | undefined;
+    nodes: readonly Node[];
+}
+export default class Renderer extends Component<RendererProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        nodes: PropTypes.Requireable<any[]>;
+    };
+    componentDidMount(): void;
+    node?: HTMLElement | null;
+    nodeRef: (node: HTMLElement | null) => void;
+    render(): JSX.Element;
+}

package/dist/global/react-dom-renderer.js

@@ -6,6 +6,8 @@ class Renderer extends Component {
   constructor() {
     super(...arguments);
 
+    _defineProperty(this, "node", void 0);
+
     _defineProperty(this, "nodeRef", node => {
       this.node = node;
     });

package/dist/global/rerender-hoc.d.ts

@@ -0,0 +1,45 @@
+import { Component } from 'react';
+export interface RerenderableComponent<P, S> extends Component<P, S> {
+    node?: HTMLElement | null;
+}
+export interface RerenderableComponentClass<P, S> {
+    new (props: P): RerenderableComponent<P, S>;
+}
+/**
+ * Wraps a component to add a "rerender" method
+ * @param ComposedComponent
+ * @param captureNode, whether the wrapper should capture this.node itself. Set to false if the component already has "node" property captured
+ * @returns {Rerenderer}
+ */
+export default function rerenderHOC<P, S>(ComposedComponent: RerenderableComponentClass<P, S>): {
+    new (props: P): {
+        _propsCache: Readonly<P> & Readonly<{
+            children?: import("react").ReactNode;
+        }>;
+        rerender(props?: Partial<P>, callback?: (() => void) | undefined): void | Element | Component<P, any, any>;
+        node?: HTMLElement | null | undefined;
+        context: any;
+        setState<K extends keyof S>(state: S | ((prevState: Readonly<S>, props: Readonly<P>) => S | Pick<S, K> | null) | Pick<S, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        render(): import("react").ReactNode;
+        readonly props: Readonly<P> & Readonly<{
+            children?: import("react").ReactNode;
+        }>;
+        state: Readonly<S>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>): any;
+        componentDidUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
+    };
+};

package/dist/global/rerender-hoc.js

@@ -10,22 +10,11 @@ import { render } from 'react-dom';
  */
 
 function rerenderHOC(ComposedComponent) {
-  let {
-    captureNode
-  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-    captureNode: false
-  };
-
-  if (captureNode) {
-    // TODO remove in 5.0
-    throw new Error('rerenderHOC: captureNode={true} is deprecated. Wrapped component must have "node" property captured itself');
-  }
-
   return class Rerenderer extends ComposedComponent {
     constructor() {
       super(...arguments);
 
-      _defineProperty(this, "_propsCache", {});
+      _defineProperty(this, "_propsCache", this.props);
     }
 
     rerender() {
@@ -34,9 +23,11 @@ function rerenderHOC(ComposedComponent) {
       let container;
 
       try {
-        container = this.node.parentNode;
+        var _this$node;
+
+        container = (_this$node = this.node) === null || _this$node === void 0 ? void 0 : _this$node.parentNode;
       } finally {
-        if (!container) {
+        if (!container || !(container instanceof Element)) {
           throw new Error(`${this.constructor.name} component isn't mounted`);
         }
       }

package/dist/global/schedule-raf.d.ts

@@ -0,0 +1 @@
+export default function scheduleRAF(trailingCall?: boolean): (cb: () => void) => void;

package/dist/global/schedule-raf.js

@@ -5,7 +5,9 @@ function scheduleRAF(trailingCall) {
 
   function doSchedule() {
     RAF = window.requestAnimationFrame(() => {
-      scheduledCb();
+      var _scheduledCb;
+
+      (_scheduledCb = scheduledCb) === null || _scheduledCb === void 0 ? void 0 : _scheduledCb();
 
       if (trailingCallScheduled) {
         trailingCallScheduled = false;

package/dist/global/sniffer.d.ts

@@ -0,0 +1,3 @@
+import Sniffr from 'sniffr';
+declare const sniffr: Sniffr;
+export default sniffr;

package/dist/global/supports-css.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (arg: string) => boolean;
+export default _default;

package/dist/global/theme.d.ts

@@ -0,0 +1,26 @@
+import React, { RefAttributes, ExoticComponent, PropsWithoutRef, FunctionComponent } from 'react';
+declare enum Theme {
+    LIGHT = "light",
+    DARK = "dark"
+}
+export declare const ThemeContext: React.Context<Theme | null>;
+export interface ThemeOuterProps {
+    theme?: Theme | null | undefined;
+}
+export interface ThemeProps {
+    theme: Theme;
+}
+declare type ClassComponentType<T, P> = T extends React.Component<P> ? new (props: P) => T : never;
+declare type ExoticComponentType<T, P> = ExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;
+declare type AnyComponentType<T, P> = ClassComponentType<T, P> | FunctionComponent<P> | ExoticComponentType<T, P>;
+export declare const withTheme: (defaultTheme?: Theme) => <T, P extends ThemeProps, S>(ComposedComponent: AnyComponentType<T, P> & S) => React.NamedExoticComponent<React.PropsWithRef<React.PropsWithoutRef<Omit<JSX.LibraryManagedAttributes<ClassComponentType<T, P> & S, P> | JSX.LibraryManagedAttributes<React.FunctionComponent<P> & S, P> | JSX.LibraryManagedAttributes<ExoticComponentType<T, P> & S, P>, "theme"> & ThemeOuterProps> & React.RefAttributes<T>>> & {
+    readonly type: React.ForwardRefExoticComponent<React.PropsWithoutRef<Omit<JSX.LibraryManagedAttributes<ClassComponentType<T, P> & S, P> | JSX.LibraryManagedAttributes<React.FunctionComponent<P> & S, P> | JSX.LibraryManagedAttributes<ExoticComponentType<T, P> & S, P>, "theme"> & ThemeOuterProps> & React.RefAttributes<T>>;
+} & { [K in keyof S]: S[K]; };
+export interface ApplyThemeParams {
+    element?: Element | null | undefined;
+    prevTheme?: string | null | undefined;
+    currentTheme?: string | null | undefined;
+}
+declare function applyTheme(params: ApplyThemeParams): void;
+export { applyTheme };
+export default Theme;