import * as React$1 from 'react';
import React__default, { Component, InputHTMLAttributes, ReactElement, AriaRole, CSSProperties, ReactNode, PureComponent, ChangeEvent, ButtonHTMLAttributes, AnchorHTMLAttributes, HTMLAttributes, PropsWithChildren, RefCallback, HTMLProps, FC, ComponentType, ErrorInfo, MouseEvent as MouseEvent$1, ElementType, UIEventHandler, FormEvent, DetailedHTMLProps } from 'react';
import * as _popperjs_core from '@popperjs/core';
import { Placement as Placement$1 } from '@popperjs/core';
import * as react_select from 'react-select';
import { NoticeProps, GroupBase, ActionMeta as ActionMeta$1, OptionsOrGroups, CommonProps as CommonProps$2, CSSObjectWithLabel, ContainerProps as ContainerProps$1 } from 'react-select';
import * as _grafana_data from '@grafana/data';
import { SelectableValue, GrafanaTheme, GrafanaTheme2, Field as Field$1, IconName, FieldType, LinkTarget, LinkModel, ThemeContext, FieldReducerInfo, BootData, TimeRange, TimeZone, TimeOption, DateTime, InternalTimeZones, VariableSuggestion, NavModelItem, DataFrame, FieldConfigSource, InterpolateFunction, ActionModel, KeyValue, CSVConfig, DisplayValue, FieldSparkline, DisplayValueAlignmentFactors, DecimalCount, ThresholdsConfig, FieldColorMode, DataFrameFieldIndex, FieldConfig, DisplayProcessor, VizOrientation as VizOrientation$1, Dimensions, GraphSeriesValue, LoadingState, EventBus, DashboardCursorSync, CoreApp, AnnotationEventUIModel, DataLinkPostProcessor, GraphSeriesXY, ReduceDataOptions, PanelModel, ValueMapping, DataLink, Action, FeatureState, DataSourceJsonData, DataSourceSettings, DataSourcePluginOptionsEditorProps, SliderMarks, RegistryItem, FieldMatcherInfo, Registry, ThemeTypographyVariantTypes, ThemeSpacingTokens, ThemeShape, ThemeShadows, RelativeTimeRange, FormattedValue, PluginSignatureStatus, PluginSignatureType, DateTimeInput, Dimension, FlotDataPoint, FieldMatcher, DataHoverEvent, LegacyGraphHoverEvent, PanelOptionsEditorBuilder, StandardEditorProps, FieldConfigEditorBuilder } from '@grafana/data';
export { IconName, ThemeContext, toIconName } from '@grafana/data';
import { Placement, Side } from '@floating-ui/react';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { Editor, Plugin, EventHook } from 'slate-react';
import { SchemaProperties, Document as Document$1, Value, Node, Mark } from 'slate';
import * as react_hook_form from 'react-hook-form';
import { FieldValues, UseFormReturn, FieldErrors, FieldArrayMethodProps, Mode, DefaultValues, SubmitHandler, UseFieldArrayProps } from 'react-hook-form';
export { FieldErrors as FormFieldErrors, SubmitHandler as FormsOnSubmit } from 'react-hook-form';
import { Row, IdType, CellProps, DefaultSortTypes, SortByFn, SortingRule, TableOptions } from 'react-table';
export { CellProps, SortByFn } from 'react-table';
import * as micro_memoize from 'micro-memoize';
import * as schema from '@grafana/schema';
import { VizTextDisplayOptions, PercentChangeColorMode, AxisPlacement, ScaleDistribution, ScaleOrientation, ScaleDirection, StackingMode, LineConfig, BarConfig, FillConfig, PointsConfig, GraphGradientMode, GraphDrawStyle, GraphThresholdsStyleConfig, VizOrientation, GraphFieldConfig, BarGaugeDisplayMode, BarGaugeValueMode, BarGaugeNamePlacement, TooltipDisplayMode, LegendPlacement, LineStyle, LegendDisplayMode, OptionsWithTextFormatting, LineInterpolation, BarAlignment, VisibilityMode, GraphThresholdsStyleMode, VizLegendOptions, DashboardCursorSync as DashboardCursorSync$1, OptionsWithTooltip, StackingConfig, HideableFieldConfig, AxisConfig, ScaleDistributionConfig, SortOrder, OptionsWithLegend } from '@grafana/schema';
export { AxisConfig, AxisPlacement, BarAlignment, BarConfig, BarGaugeDisplayMode, VisibilityMode as BarValueVisibility, GraphDrawStyle as DrawStyle, FieldTextAlignment, FillConfig, GraphFieldConfig, GraphGradientMode, GraphThresholdsStyleConfig, GraphThresholdsStyleMode, HideSeriesConfig, HideableFieldConfig, LegendDisplayMode, LegendPlacement, LineConfig, LineInterpolation, LineStyle, OptionsWithLegend, OptionsWithTextFormatting, OptionsWithTooltip, VisibilityMode as PointVisibility, PointsConfig, ScaleDirection, ScaleDistribution, ScaleDistributionConfig, ScaleOrientation, StackableFieldConfig, StackingConfig, StackingMode, TableAutoCellOptions, TableBarGaugeCellOptions, TableCellDisplayMode, TableColorTextCellOptions, TableColoredBackgroundCellOptions, TableImageCellOptions, TableJsonViewCellOptions, TableSparklineCellOptions, TooltipDisplayMode, VizLegendOptions, VizTextDisplayOptions, VizTooltipOptions } from '@grafana/schema';
import { LanguageMap } from 'prismjs';
import * as _emotion_serialize from '@emotion/serialize';
import * as csstype from 'csstype';
import { Property } from 'csstype';
import { positionValues } from 'react-custom-scrollbars-2';
import { FieldNames } from 'rc-cascader';
import { PickerProps } from 'rc-picker';
import { EditorProps } from '@monaco-editor/react';
import * as monacoType from 'monaco-editor/esm/vs/editor/editor.api';
export { monacoType as monacoTypes };
import uPlot, { Options, AlignedData, Axis, Scale, Series, Hooks, Cursor, Select as Select$2, Band, Padding, Range } from 'uplot';
import { AsyncState } from 'react-use/lib/useAsync';
import { DropzoneOptions, Accept } from 'react-dropzone';

type Props$1h<T> = NoticeProps<SelectableValue<T>, boolean, GroupBase<SelectableValue<T>>>;

interface PopoverContentProps {
    /**
     * @deprecated
     * This prop is deprecated and no longer has any effect as popper position updates automatically.
     * It will be removed in a future release.
     */
    updatePopperPosition?: () => void;
    hidePopper?: () => void;
}
type PopoverContent = string | React.ReactElement | ((props: PopoverContentProps) => JSX.Element);
type TooltipPlacement = Placement | 'auto' | 'auto-start' | 'auto-end';

interface TooltipProps {
    theme?: 'info' | 'error' | 'info-alt';
    show?: boolean;
    placement?: TooltipPlacement;
    content: PopoverContent;
    children: JSX.Element;
    /**
     * Set to true if you want the tooltip to stay long enough so the user can move mouse over content to select text or click a link
     */
    interactive?: boolean;
}
declare const Tooltip: React$1.ForwardRefExoticComponent<TooltipProps & React$1.RefAttributes<HTMLElement>>;

type PopperControllerRenderProp = (showPopper: () => void, hidePopper: () => void, popperProps: {
    show: boolean;
    placement: Placement$1;
    content: PopoverContent;
}) => JSX.Element;
interface Props$1g {
    placement?: Placement$1;
    content: PopoverContent;
    className?: string;
    children: PopperControllerRenderProp;
    hideAfter?: number;
}
interface State$6 {
    show: boolean;
}
declare class PopoverController extends Component<Props$1g, State$6> {
    private hideTimeout;
    state: {
        show: boolean;
    };
    showPopper: () => void;
    hidePopper: () => void;
    render(): JSX.Element;
}

interface Props$1f extends InputHTMLAttributes<HTMLInputElement> {
    label: string;
    tooltip?: PopoverContent;
    labelWidth?: number;
    inputWidth?: number | null;
    inputEl?: React$1.ReactNode;
    /** Make tooltip interactive */
    interactive?: boolean;
}

interface Props$1e extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onReset'> {
    onReset: (event: React$1.SyntheticEvent<HTMLButtonElement>) => void;
    isConfigured: boolean;
    label?: string;
    tooltip?: PopoverContent;
    labelWidth?: number;
    inputWidth?: number;
    placeholder?: string;
    interactive?: boolean;
}

interface Themeable {
    theme: GrafanaTheme;
}
interface Themeable2 {
    theme: GrafanaTheme2;
}

interface ValidationRule {
    rule: (valueToValidate: string) => boolean;
    errorMessage: string;
}
interface ValidationEvents {
    [eventName: string]: ValidationRule[];
}

declare function getPreviousCousin(node: HTMLElement, selector: string): Element | undefined;
declare function getNextCharacter(global?: typeof globalThis): string | null;

declare const dom_d_getNextCharacter: typeof getNextCharacter;
declare const dom_d_getPreviousCousin: typeof getPreviousCousin;
declare namespace dom_d {
  export { dom_d_getNextCharacter as getNextCharacter, dom_d_getPreviousCousin as getPreviousCousin };
}

/** Returns the ID value of the first, and only, child element  */
declare function getChildId(children: ReactElement): string | undefined;
/**
 * Given react node or function returns element accordingly
 *
 * @param itemToRender
 * @param props props to be passed to the function if item provided as such
 */
declare function renderOrCallToRender<TProps = {}>(itemToRender: ((props: TProps) => React$1.ReactNode) | React$1.ReactNode, props?: TProps): React$1.ReactNode;

declare const reactUtils_d_getChildId: typeof getChildId;
declare const reactUtils_d_renderOrCallToRender: typeof renderOrCallToRender;
declare namespace reactUtils_d {
  export { reactUtils_d_getChildId as getChildId, reactUtils_d_renderOrCallToRender as renderOrCallToRender };
}

/**
 * @alpha
 */
declare const DEFAULT_ANNOTATION_COLOR = "rgba(0, 211, 255, 1)";
/**
 * @alpha
 */
declare const OK_COLOR = "rgba(11, 237, 50, 1)";
/**
 * @alpha
 */
declare const ALERTING_COLOR = "rgba(237, 46, 24, 1)";
/**
 * @alpha
 */
declare const NO_DATA_COLOR = "rgba(150, 150, 150, 1)";
/**
 * @alpha
 */
declare const PENDING_COLOR = "rgba(247, 149, 32, 1)";
/**
 * @alpha
 */
declare const REGION_FILL_ALPHA = 0.09;
declare const colors: string[];
declare function getTextColorForBackground(color: string): "rgb(32, 34, 38)" | "rgb(247, 248, 250)";
declare function getTextColorForAlphaBackground(color: string, themeIsDark: boolean): "rgb(32, 34, 38)" | "rgb(247, 248, 250)";
declare let sortedColors: boolean[];

declare enum EventsWithValidation {
    onBlur = "onBlur",
    onFocus = "onFocus",
    onChange = "onChange"
}
declare const validate: (value: string, validationRules: ValidationRule[]) => string[] | null;
declare const hasValidationEvent: (event: EventsWithValidation, validationEvents: ValidationEvents | undefined) => ValidationRule[] | undefined;
declare const regexValidation: (pattern: string | RegExp, errorMessage?: string) => ValidationRule;

declare const SCHEMA: SchemaProperties;
declare const makeFragment: (text: string, syntax?: string) => Document$1;
declare const makeValue: (text: string, syntax?: string) => Value;

type ComponentSize = 'xs' | 'sm' | 'md' | 'lg';

type IconType = 'mono' | 'default' | 'solid';
type IconSize = ComponentSize | 'xl' | 'xxl' | 'xxxl';
declare const isIconSize: (value: string) => value is IconSize;
declare const getAvailableIcons: () => string[];
/**
 * Get the icon for a given field
 */
declare function getFieldTypeIcon(field?: Field$1): IconName;
/** Get an icon for a given field type  */
declare function getFieldTypeIconName(type?: FieldType): IconName;

/** @internal */
type MenuItemElement = HTMLAnchorElement & HTMLButtonElement & HTMLDivElement;
/** @internal */
interface MenuItemProps<T = unknown> {
    /** Label of the menu item */
    label: string;
    /** Description of item */
    description?: string;
    /** Aria label for accessibility support */
    ariaLabel?: string;
    /** Aria checked for accessibility support */
    ariaChecked?: boolean;
    /** Target of the menu item (i.e. new window)  */
    target?: LinkTarget;
    /** Icon of the menu item */
    icon?: IconName;
    /** Role of the menu item */
    role?: AriaRole;
    /** Url of the menu item */
    url?: string;
    /** Handler for the click behaviour */
    onClick?: (event: React$1.MouseEvent<HTMLElement>, payload?: T) => void;
    /** Custom MenuItem styles*/
    className?: string;
    /** Active */
    active?: boolean;
    /** Disabled */
    disabled?: boolean;
    /** Show in destructive style (error color) */
    destructive?: boolean;
    tabIndex?: number;
    /** List of menu items for the subMenu */
    childItems?: Array<ReactElement<MenuItemProps>>;
    /** Custom style for SubMenu */
    customSubMenuContainerStyles?: CSSProperties;
    /** Shortcut key combination */
    shortcut?: string;
    /** Test id for e2e tests and fullstory*/
    testId?: string;
    component?: React$1.ComponentType;
}
/** @internal */
declare const MenuItem: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<MenuItemProps<unknown> & React$1.RefAttributes<MenuItemElement>>>;

/**
 * Delays creating links until we need to open the ContextMenu
 */
declare const linkModelToContextMenuItems: (links: () => LinkModel[]) => MenuItemProps[];

declare function getTagColorIndexFromName(name?: string): number;
/**
 * Returns tag badge background and border colors based on hashed tag name.
 * @param name tag name
 */
declare function getTagColorsFromName(name?: string): {
    color: string;
    borderColor: string;
};
declare function getTagColor(index: number): {
    color: string;
    borderColor: string;
};

declare function getScrollbarWidth(): number;

/**
 * @internal
 */
declare const getCellLinks: (field: Field$1, row: Row) => LinkModel<unknown>[] | undefined;

/**
 * @internal
 */
declare function getCanvasContext(): CanvasRenderingContext2D;
/**
 * @beta
 */
declare function measureText(text: string, fontSize: number, fontWeight?: number): TextMetrics;
/**
 * @beta
 */
declare function calculateFontSize(text: string, width: number, height: number, lineHeight: number, maxSize?: number, fontWeight?: number): number;

type PointerOrMouseEvent = React__default.PointerEvent | React__default.MouseEvent | PointerEvent | MouseEvent;
type PointerDistanceSet = (evt: PointerOrMouseEvent) => void;
type PointerDistanceCheck = (evt: PointerOrMouseEvent, distance?: number) => boolean;
interface PointerDistance {
    set: PointerDistanceSet;
    check: PointerDistanceCheck;
}
declare function createPointerDistance(distance?: number): PointerDistance;
declare function usePointerDistance(distance?: number): PointerDistance;

/** @internal */
declare function useForceUpdate(): () => void;

/**
 * List of auto-complete search function used by SuggestionsPlugin.handleTypeahead()
 * @alpha
 */
declare enum SearchFunctionType {
    Word = "Word",
    Prefix = "Prefix",
    Fuzzy = "Fuzzy"
}

type Args = Parameters<typeof console.log>;
/**
 * @internal
 */
interface Logger {
    logger: (...t: Args) => void;
    enable: () => void;
    disable: () => void;
    isEnabled: () => boolean;
}
/** @internal */
declare const createLogger: (name: string) => Logger;

/**
 * Allows debug helpers attachement to the window object
 * @internal
 */
declare function attachDebugger(key: string, thebugger?: any, logger?: Logger): void;

/**
 * @deprecated use it from @grafana/data. Kept here for backward compatibility.
 */
declare enum NodeGraphDataFrameFieldNames {
    id = "id",
    title = "title",
    subTitle = "subTitle",
    mainStat = "mainStat",
    secondaryStat = "secondaryStat",
    source = "source",
    target = "target",
    detail = "detail__",
    arc = "arc__",
    color = "color"
}

type FuzzyMatch = {
    /**
     * Total number of unmatched letters between matched letters
     */
    distance: number;
    ranges: HighlightPart[];
    found: boolean;
};
/**
 * Attempts to do a partial input search, e.g. allowing to search for a text (needle)
 * in another text (stack) by skipping some letters in-between. All letters from
 * the needle must exist in the stack in the same order to find a match.
 *
 * The search is case sensitive. Convert stack and needle to lower case
 * to make it case insensitive.
 *
 * @param stack - main text to be searched
 * @param needle - partial text to find in the stack
 *
 * @internal
 */
declare function fuzzyMatch(stack: string, needle: string): FuzzyMatch;

/**
 * This function logs a warning if the amount of items exceeds the recommended amount.
 *
 * @param amount
 * @param id
 * @param ariaLabelledBy
 */
declare function logOptions(amount: number, recommendedAmount: number, id: string | undefined, ariaLabelledBy: string | undefined): void;

/**
 * @internal
 */
type SearchFunction = (items: CompletionItem[], prefix: string) => CompletionItem[];
interface CompletionItemGroup {
    /**
     * Label that will be displayed for all entries of this group.
     */
    label: string;
    /**
     * List of suggestions of this group.
     */
    items: CompletionItem[];
    /**
     * If true, match only by prefix (and not mid-word).
     * @deprecated use searchFunctionType instead
     */
    prefixMatch?: boolean;
    /**
     * Function type used to create auto-complete list
     * @alpha
     */
    searchFunctionType?: SearchFunctionType;
    /**
     * If true, do not filter items in this group based on the search.
     */
    skipFilter?: boolean;
    /**
     * If true, do not sort items.
     */
    skipSort?: boolean;
}
declare enum CompletionItemKind {
    GroupTitle = "GroupTitle"
}
/**
 * @internal
 */
type HighlightPart = {
    start: number;
    end: number;
};
interface CompletionItem {
    /**
     * The label of this completion item. By default
     * this is also the text that is inserted when selecting
     * this completion.
     */
    label: string;
    /**
     * The kind of this completion item. An icon is chosen
     * by the editor based on the kind.
     */
    kind?: CompletionItemKind | string;
    /**
     * A human-readable string with additional information
     * about this item, like type or symbol information.
     */
    detail?: string;
    /**
     * A human-readable string, can be Markdown, that represents a doc-comment.
     */
    documentation?: string;
    /**
     * A string that should be used when comparing this item
     * with other items. When `falsy` the `label` is used.
     * @deprecated use sortValue instead
     */
    sortText?: string;
    /**
     * A string or number that should be used when comparing this
     * item with other items. When `undefined` then `label` is used.
     * @alpha
     */
    sortValue?: string | number;
    /**
     * Parts of the label to be highlighted
     * @internal
     */
    highlightParts?: HighlightPart[];
    /**
     * A string that should be used when filtering a set of
     * completion items. When `falsy` the `label` is used.
     */
    filterText?: string;
    /**
     * A string or snippet that should be inserted in a document when selecting
     * this completion. When `falsy` the `label` is used.
     */
    insertText?: string;
    /**
     * Delete number of characters before the caret position,
     * by default the letters from the beginning of the word.
     */
    deleteBackwards?: number;
    /**
     * Number of steps to move after the insertion, can be negative.
     */
    move?: number;
}
interface TypeaheadOutput {
    context?: string;
    suggestions: CompletionItemGroup[];
}
interface TypeaheadInput {
    text: string;
    prefix: string;
    wrapperClasses: string[];
    labelKey?: string;
    value?: Value;
    editor?: Editor;
}
interface SuggestionsState {
    groupedItems: CompletionItemGroup[];
    typeaheadPrefix: string;
    typeaheadContext: string;
    typeaheadText: string;
}

/**
 * @deprecated use the types from react-hook-form instead
 */
type FormAPI<T extends FieldValues> = Omit<UseFormReturn<T>, 'handleSubmit'> & {
    errors: FieldErrors<T>;
};
type FieldArrayValue = Partial<FieldValues> | Array<Partial<FieldValues>>;
/**
 * @deprecated use the types from react-hook-form instead
 */
interface FieldArrayApi {
    fields: Array<Record<string, any>>;
    append: (value: FieldArrayValue, options?: FieldArrayMethodProps) => void;
    prepend: (value: FieldArrayValue) => void;
    remove: (index?: number | number[]) => void;
    swap: (indexA: number, indexB: number) => void;
    move: (from: number, to: number) => void;
    insert: (index: number, value: FieldArrayValue) => void;
}

type SelectValue<T> = T | SelectableValue<T> | T[] | Array<SelectableValue<T>>;
type ActionMeta = ActionMeta$1<{}>;
type InputActionMeta = {
    action: 'set-value' | 'input-change' | 'input-blur' | 'menu-close';
};
type LoadOptionsCallback<T> = (options: Array<SelectableValue<T>>) => void;
declare enum ToggleAllState {
    allSelected = "allSelected",
    indeterminate = "indeterminate",
    noneSelected = "noneSelected"
}
interface SelectCommonProps<T> {
    /** Aria label applied to the input field */
    ['aria-label']?: string;
    ['data-testid']?: string;
    allowCreateWhileLoading?: boolean;
    allowCustomValue?: boolean;
    /** Focus is set to the Select when rendered*/
    autoFocus?: boolean;
    backspaceRemovesValue?: boolean;
    blurInputOnSelect?: boolean;
    captureMenuScroll?: boolean;
    className?: string;
    closeMenuOnSelect?: boolean;
    /** Used for custom components. For more information, see `react-select` */
    components?: any;
    /** Sets the position of the createOption element in your options list. Defaults to 'last' */
    createOptionPosition?: 'first' | 'last';
    defaultValue?: any;
    disabled?: boolean;
    filterOption?: (option: SelectableValue<T>, searchQuery: string) => boolean;
    formatOptionLabel?: (item: SelectableValue<T>, formatOptionMeta: FormatOptionLabelMeta<T>) => React$1.ReactNode;
    /** Function for formatting the text that is displayed when creating a new value*/
    formatCreateLabel?: (input: string) => React$1.ReactNode;
    getOptionLabel?: (item: SelectableValue<T>) => React$1.ReactNode;
    getOptionValue?: (item: SelectableValue<T>) => T | undefined;
    hideSelectedOptions?: boolean;
    inputValue?: string;
    invalid?: boolean;
    isClearable?: boolean;
    /** The id to set on the SelectContainer component. To set the id for a label (with htmlFor), @see inputId instead */
    id?: string;
    isLoading?: boolean;
    isMulti?: boolean;
    /** The id of the search input. Use this to set a matching label with htmlFor */
    inputId?: string;
    isOpen?: boolean;
    /** Disables the possibility to type into the input*/
    isSearchable?: boolean;
    showAllSelectedWhenOpen?: boolean;
    maxMenuHeight?: number;
    minMenuHeight?: number;
    maxVisibleValues?: number;
    menuPlacement?: 'auto' | 'bottom' | 'top';
    menuPosition?: 'fixed' | 'absolute';
    /**
     * Setting to false will prevent the menu from portalling to the body.
     */
    menuShouldPortal?: boolean;
    /** The message to display when no options could be found */
    noOptionsMessage?: string;
    onBlur?: () => void;
    onChange: (value: SelectableValue<T>, actionMeta: ActionMeta) => {} | void;
    onCloseMenu?: () => void;
    /** allowCustomValue must be enabled. Function decides what to do with that custom value. */
    onCreateOption?: (value: string) => void;
    onInputChange?: (value: string, actionMeta: InputActionMeta) => void;
    onKeyDown?: (event: React$1.KeyboardEvent) => void;
    /** Callback which fires when the user scrolls to the bottom of the menu */
    onMenuScrollToBottom?: (event: WheelEvent | TouchEvent) => void;
    /** Callback which fires when the user scrolls to the top of the menu */
    onMenuScrollToTop?: (event: WheelEvent | TouchEvent) => void;
    onOpenMenu?: () => void;
    onFocus?: () => void;
    toggleAllOptions?: {
        enabled: boolean;
        optionsFilter?: (v: SelectableValue<T>) => boolean;
        determineToggleAllState?: (selectedValues: Array<SelectableValue<T>>, options: Array<SelectableValue<T>>) => ToggleAllState;
    };
    openMenuOnFocus?: boolean;
    options?: Array<SelectableValue<T>>;
    placeholder?: string;
    /** item to be rendered in front of the input */
    prefix?: JSX.Element | string | null;
    /** Use a custom element to control Select. A proper ref to the renderControl is needed if 'portal' isn't set to null*/
    renderControl?: ControlComponent<T>;
    tabSelectsValue?: boolean;
    value?: T | SelectValue<T> | null;
    /** Will wrap the MenuList in a react-window FixedSizeVirtualList for improved performance, does not support options with "description" properties */
    virtualized?: boolean;
    /** Sets the width to a multiple of 8px. Should only be used with inline forms. Setting width of the container is preferred in other cases.*/
    width?: number | 'auto';
    isOptionDisabled?: (option: SelectableValue<T>) => boolean;
    /** allowCustomValue must be enabled. Determines whether the "create new" option should be displayed based on the current input value, select value and options array. */
    isValidNewOption?: (inputValue: string, value: SelectableValue<T> | null, options: OptionsOrGroups<SelectableValue<T>, GroupBase<SelectableValue<T>>>) => boolean;
    /** Message to display isLoading=true*/
    loadingMessage?: string;
    /** Disables wrapping of multi value values when closed */
    noMultiValueWrap?: boolean;
}
interface SelectAsyncProps<T> {
    /** When specified as boolean the loadOptions will execute when component is mounted */
    defaultOptions?: boolean | Array<SelectableValue<T>>;
    /** Asynchronously load select options */
    loadOptions?: (query: string, cb?: LoadOptionsCallback<T>) => Promise<Array<SelectableValue<T>>> | void;
    /** If cacheOptions is true, then the loaded data will be cached. The cache will remain until cacheOptions changes value. */
    cacheOptions?: boolean;
    /** Message to display when options are loading */
    loadingMessage?: string;
}
/** The VirtualizedSelect component uses a slightly different SelectableValue, description and other props are not supported */
interface VirtualizedSelectProps<T> extends Omit<SelectCommonProps<T>, 'virtualized'> {
    options?: Array<Pick<SelectableValue<T>, 'label' | 'value'>>;
}
/** The AsyncVirtualizedSelect component uses a slightly different SelectableValue, description and other props are not supported */
interface VirtualizedSelectAsyncProps<T> extends Omit<SelectCommonProps<T>, 'virtualized'>, SelectAsyncProps<T> {
}
interface MultiSelectCommonProps<T> extends Omit<SelectCommonProps<T>, 'onChange' | 'isMulti' | 'value'> {
    value?: Array<SelectableValue<T>> | T[];
    onChange: (item: Array<SelectableValue<T>>, actionMeta: ActionMeta) => {} | void;
}
interface SelectBaseProps<T> extends SelectCommonProps<T>, SelectAsyncProps<T> {
    invalid?: boolean;
}
interface CustomControlProps<T> {
    ref: React$1.Ref<any>;
    isOpen: boolean;
    /** Currently selected value */
    value?: SelectableValue<T>;
    /** onClick will be automatically passed to custom control allowing menu toggle */
    onClick: () => void;
    /** onBlur will be automatically passed to custom control closing the menu on element blur */
    onBlur: () => void;
    disabled: boolean;
    invalid: boolean;
}
type ControlComponent<T> = React$1.ComponentType<CustomControlProps<T>>;
interface SelectableOptGroup<T = any> {
    label: string;
    options: Array<SelectableValue<T>>;
    [key: string]: any;
}
type SelectOptions<T = any> = SelectableValue<T> | Array<SelectableValue<T> | SelectableOptGroup<T> | Array<SelectableOptGroup<T>>>;
type FormatOptionLabelMeta<T> = {
    context: string;
    inputValue: string;
    selectValue: Array<SelectableValue<T>>;
};
type ReactSelectProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = CommonProps$2<Option, IsMulti, Group>['selectProps'] & {
    invalid: boolean;
};
interface CustomComponentProps<Option, isMulti extends boolean, Group extends GroupBase<Option>> {
    selectProps: ReactSelectProps<Option, isMulti, Group>;
}

interface Column<TableData extends object> {
    /**
     * ID of the column. Must be unique among all other columns
     */
    id: IdType<TableData>;
    /**
     * Custom render function for te cell
     */
    cell?: (props: CellProps<TableData>) => ReactNode;
    /**
     * Header name. if `undefined` the header will be empty. Useful for action columns.
     */
    header?: string;
    /**
     * Column sort type. If `undefined` the column will not be sortable.
     * */
    sortType?: DefaultSortTypes | SortByFn<TableData>;
    /**
     * If `true` prevents the column from growing more than its content.
     */
    disableGrow?: boolean;
    /**
     * If the provided function returns `false` the column will be hidden.
     */
    visible?: (data: TableData[]) => boolean;
}

/** @deprecated Please use the `Input` component, which does not require this enum. */
declare enum LegacyInputStatus {
    Invalid = "invalid",
    Valid = "valid"
}
interface Props$1d extends React$1.HTMLProps<HTMLInputElement> {
    validationEvents?: ValidationEvents;
    hideErrorMessage?: boolean;
    inputRef?: React$1.LegacyRef<HTMLInputElement>;
    onBlur?: (event: React$1.FocusEvent<HTMLInputElement>, status?: LegacyInputStatus) => void;
    onFocus?: (event: React$1.FocusEvent<HTMLInputElement>, status?: LegacyInputStatus) => void;
    onChange?: (event: React$1.ChangeEvent<HTMLInputElement>, status?: LegacyInputStatus) => void;
}
interface State$5 {
    error: string | null;
}
/** @deprecated Please use the `Input` component. {@link https://developers.grafana.com/ui/latest/index.html?path=/story/forms-input--simple See Storybook for example.} */
declare class Input$1 extends PureComponent<Props$1d, State$5> {
    static defaultProps: {
        className: string;
    };
    state: State$5;
    get status(): LegacyInputStatus;
    get isInvalid(): boolean;
    validatorAsync: (validationRules: ValidationRule[]) => (evt: ChangeEvent<HTMLInputElement>) => void;
    populateEventPropsWithStatus: (restProps: any, validationEvents: ValidationEvents | undefined) => any;
    render(): react_jsx_runtime.JSX.Element;
}

/**
 * Changes in new selects:
 * - noOptionsMessage & loadingMessage is of string type
 * - isDisabled is renamed to disabled
 */
type LegacyCommonProps<T> = Omit<SelectCommonProps<T>, 'noOptionsMessage' | 'disabled' | 'value' | 'loadingMessage'>;
interface AsyncProps<T> extends LegacyCommonProps<T>, Omit<SelectAsyncProps<T>, 'loadingMessage'> {
    loadingMessage?: () => string;
    noOptionsMessage?: () => string;
    tooltipContent?: PopoverContent;
    isDisabled?: boolean;
    value?: SelectableValue<T>;
}
interface LegacySelectProps<T> extends LegacyCommonProps<T> {
    tooltipContent?: PopoverContent;
    noOptionsMessage?: () => string;
    isDisabled?: boolean;
    value?: SelectableValue<T>;
}
/** @deprecated Please use the `Select` component, as seen {@link https://developers.grafana.com/ui/latest/index.html?path=/story/forms-select--basic in Storybook}. */
declare class Select$1<T> extends PureComponent<LegacySelectProps<T>> {
    context: React$1.ContextType<typeof ThemeContext>;
    static contextType: React$1.Context<_grafana_data.GrafanaTheme2>;
    static defaultProps: Partial<LegacySelectProps<unknown>>;
    render(): react_jsx_runtime.JSX.Element;
}
/** @deprecated Please use the `Select` component with async functionality, as seen {@link https://developers.grafana.com/ui/latest/index.html?path=/story/forms-select--basic-select-async in Storybook}. */
declare class AsyncSelect$1<T> extends PureComponent<AsyncProps<T>> {
    static contextType: React$1.Context<_grafana_data.GrafanaTheme2>;
    static defaultProps: Partial<AsyncProps<unknown>>;
    render(): react_jsx_runtime.JSX.Element;
}

interface IconProps extends Omit<React$1.SVGProps<SVGElement>, 'onLoad' | 'onError' | 'ref'> {
    name: IconName;
    size?: IconSize;
    type?: IconType;
    /**
     * Give your icon a semantic meaning. The icon will be hidden from screen readers, unless this prop or an aria-label is provided.
     */
    title?: string;
}
declare const Icon: React$1.ForwardRefExoticComponent<IconProps & React$1.RefAttributes<SVGElement>>;

type IconButtonVariant = 'primary' | 'secondary' | 'destructive';
interface BaseProps$3 extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, 'aria-label'> {
    /** Name of the icon **/
    name: IconName;
    /** Icon size - sizes xxl and xxxl are deprecated and when used being decreased to xl*/
    size?: IconSize;
    /** Type of the icon - mono or default */
    iconType?: IconType;
    /** Variant to change the color of the Icon */
    variant?: IconButtonVariant;
}
interface BasePropsWithTooltip extends BaseProps$3 {
    /** Tooltip content to display on hover and as the aria-label */
    tooltip: PopoverContent;
    /** Position of the tooltip */
    tooltipPlacement?: TooltipPlacement;
}
interface BasePropsWithAriaLabel extends BaseProps$3 {
    /** @deprecated use aria-label instead*/
    ariaLabel?: string;
    /** Text available only for screen readers. No tooltip will be set in this case. */
    ['aria-label']: string;
}
type Props$1c = BasePropsWithTooltip | BasePropsWithAriaLabel;
declare const IconButton: React$1.ForwardRefExoticComponent<Props$1c & React$1.RefAttributes<HTMLButtonElement>>;

type ButtonVariant = 'primary' | 'secondary' | 'destructive' | 'success';
type ButtonFill = 'solid' | 'outline' | 'text';
type CommonProps$1 = {
    size?: ComponentSize;
    variant?: ButtonVariant;
    fill?: ButtonFill;
    icon?: IconName | React$1.ReactElement;
    className?: string;
    children?: React$1.ReactNode;
    fullWidth?: boolean;
    type?: string;
    /** Tooltip content to display on hover */
    tooltip?: PopoverContent;
    /** Position of the tooltip */
    tooltipPlacement?: TooltipPlacement;
};
type ButtonProps = CommonProps$1 & ButtonHTMLAttributes<HTMLButtonElement>;
declare const Button: React$1.ForwardRefExoticComponent<CommonProps$1 & ButtonHTMLAttributes<HTMLButtonElement> & React$1.RefAttributes<HTMLButtonElement>>;
declare const LinkButton: React$1.ForwardRefExoticComponent<CommonProps$1 & ButtonHTMLAttributes<HTMLButtonElement> & AnchorHTMLAttributes<HTMLAnchorElement> & React$1.RefAttributes<HTMLAnchorElement>>;
declare const clearButtonStyles: (theme: GrafanaTheme2) => string;

interface Props$1b extends HTMLAttributes<HTMLDivElement> {
    className?: string;
}
declare const ButtonGroup: React$1.ForwardRefExoticComponent<Props$1b & React$1.RefAttributes<HTMLDivElement>>;

interface Props$1a {
    /** Confirm action callback */
    onConfirm(): void;
    children: string | ReactElement;
    /** Custom button styles */
    className?: string;
    /** Button size */
    size?: ComponentSize;
    /** Text for the Confirm button */
    confirmText?: string;
    /** Disable button click action */
    disabled?: boolean;
    /** Variant of the Confirm button */
    confirmVariant?: ButtonVariant;
    /** Hide confirm actions when after of them is clicked */
    closeOnConfirm?: boolean;
    /** Optional on click handler for the original button */
    onClick?(): void;
    /** Callback for the cancel action */
    onCancel?(): void;
}
declare const ConfirmButton: {
    ({ children, className, closeOnConfirm, confirmText, confirmVariant, disabled, onCancel, onClick, onConfirm, size, }: Props$1a): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface Props$19 {
    /** Confirm action callback */
    onConfirm(): void;
    /** Button size */
    size?: ComponentSize;
    /** Disable button click action */
    disabled?: boolean;
    'aria-label'?: string;
    /** Close after delete button is clicked */
    closeOnConfirm?: boolean;
}
declare const DeleteButton: ({ size, disabled, onConfirm, "aria-label": ariaLabel, closeOnConfirm }: Props$19) => react_jsx_runtime.JSX.Element;

interface Props$18 extends Omit<React$1.HTMLAttributes<HTMLDivElement>, 'content'> {
    show: boolean;
    placement?: TooltipPlacement;
    content: PopoverContent;
    referenceElement: HTMLElement;
    wrapperClassName?: string;
    renderArrow?: boolean;
    hidePopper?: () => void;
}
declare function Popover({ content, show, placement, className, wrapperClassName, referenceElement, renderArrow, hidePopper, ...rest }: Props$18): react_jsx_runtime.JSX.Element | undefined;

interface ToggletipContentProps {
    /**
     * @deprecated
     * This prop is deprecated and no longer has any effect as popper position updates automatically.
     * It will be removed in a future release.
     */
    update?: () => void;
}
type ToggletipContent = string | React.ReactElement | ((props: ToggletipContentProps) => JSX.Element);

interface ToggletipProps {
    /** The theme used to display the toggletip */
    theme?: 'info' | 'error';
    /** The title to be displayed on the header */
    title?: JSX.Element | string;
    /** determine whether to show or not the close button **/
    closeButton?: boolean;
    /** Callback function to be called when the toggletip is closed */
    onClose?: () => void;
    /** The preferred placement of the toggletip */
    placement?: Placement$1;
    /** The text or component that houses the content of the toggleltip */
    content: ToggletipContent;
    /** The text or component to be displayed on the toggletip's bottom */
    footer?: JSX.Element | string;
    /** The UI control users interact with to display toggletips */
    children: JSX.Element;
    /** Determine whether the toggletip should fit its content or not */
    fitContent?: boolean;
    /** Determine whether the toggletip should be shown or not */
    show?: boolean;
    /** Callback function to be called when the toggletip is opened */
    onOpen?: () => void;
}
declare const Toggletip: React$1.MemoExoticComponent<({ children, theme, placement, content, title, closeButton, onClose, footer, fitContent, onOpen, show, }: ToggletipProps) => react_jsx_runtime.JSX.Element>;

interface Props$17 {
    className?: string;
    root?: HTMLElement;
    forwardedRef?: React$1.ForwardedRef<HTMLDivElement>;
}
declare function Portal(props: PropsWithChildren<Props$17>): React$1.ReactPortal;
/** @internal */
declare function getPortalContainer(): HTMLElement;
/** @internal */
declare function PortalContainer(): react_jsx_runtime.JSX.Element;

type ScrollbarPosition = positionValues;
interface Props$16 {
    className?: string;
    testId?: string;
    autoHide?: boolean;
    autoHideTimeout?: number;
    autoHeightMax?: string;
    hideTracksWhenNotNeeded?: boolean;
    hideHorizontalTrack?: boolean;
    hideVerticalTrack?: boolean;
    scrollRefCallback?: RefCallback<HTMLDivElement>;
    scrollTop?: number;
    setScrollTop?: (position: ScrollbarPosition) => void;
    showScrollIndicators?: boolean;
    autoHeightMin?: number | string;
    updateAfterMountMs?: number;
    onScroll?: React$1.UIEventHandler;
    divId?: string;
}
/**
 * Wraps component into <Scrollbars> component from `react-custom-scrollbars`
 * @deprecated Use `ScrollContainer` from `@grafana/ui` instead. It uses native scrollbars and has a simpler API.
 */
declare const CustomScrollbar: ({ autoHide, autoHideTimeout, setScrollTop, className, testId, autoHeightMin, autoHeightMax, hideTracksWhenNotNeeded, hideHorizontalTrack, hideVerticalTrack, scrollRefCallback, showScrollIndicators, updateAfterMountMs, scrollTop, onScroll, children, divId, }: React$1.PropsWithChildren<Props$16>) => react_jsx_runtime.JSX.Element;

interface TabConfig {
    label: string;
    value: string;
    content: React$1.ReactNode;
    icon: IconName;
}
interface TabbedContainerProps {
    tabs: TabConfig[];
    defaultTab?: string;
    closeIconTooltip?: string;
    onClose: () => void;
    testId?: string;
}
declare function TabbedContainer({ tabs, defaultTab, closeIconTooltip, onClose, testId }: TabbedContainerProps): react_jsx_runtime.JSX.Element;

interface Props$15 extends ButtonProps {
    /** A function that returns text to be copied */
    getText(): string;
    /** Callback when the text has been successfully copied */
    onClipboardCopy?(copiedText: string): void;
    /** Callback when there was an error copying the text */
    onClipboardError?(copiedText: string, error: unknown): void;
}
declare function ClipboardButton({ onClipboardCopy, onClipboardError, children, getText, icon, variant, ...buttonProps }: Props$15): react_jsx_runtime.JSX.Element;

interface CascaderOption {
    /**
     *  The value used under the hood
     */
    value: string;
    /**
     *  The label to display in the UI
     */
    label: string;
    /** Items will be just flattened into the main list of items recursively. */
    items?: CascaderOption[];
    disabled?: boolean;
    /** Avoid using */
    title?: string;
    /**  Children will be shown in a submenu. Use 'items' instead, as 'children' exist to ensure backwards compatibility.*/
    children?: CascaderOption[];
}
declare const Cascader: React$1.FunctionComponent<{
    width?: number | undefined;
    allowCustomValue?: boolean | undefined;
    options: CascaderOption[];
    id?: string | undefined;
    onBlur?: (() => void) | undefined;
    disabled?: boolean | undefined;
    onSelect: (val: string) => void;
    separator?: string | undefined;
    placeholder?: string | undefined;
    autoFocus?: boolean | undefined;
    formatCreateLabel?: ((val: string) => string) | undefined;
    isClearable?: boolean | undefined;
    changeOnSelect?: boolean | undefined;
    initialValue?: string | undefined;
    displayAllSelectedLevels?: boolean | undefined;
    alwaysOpen?: boolean | undefined;
    hideActiveLevelLabel?: boolean | undefined;
}>;

interface CarouselImage {
    path: string;
    name: string;
}
interface CarouselProps {
    images: CarouselImage[];
}
declare const Carousel: React.FC<CarouselProps>;

interface ButtonCascaderProps {
    options: CascaderOption[];
    children?: string;
    icon?: IconName;
    disabled?: boolean;
    value?: string[];
    fieldNames?: FieldNames<CascaderOption, keyof CascaderOption>;
    loadData?: (selectedOptions: CascaderOption[]) => void;
    onChange?: (value: string[], selectedOptions: CascaderOption[]) => void;
    onPopupVisibleChange?: (visible: boolean) => void;
    className?: string;
    variant?: ButtonProps['variant'];
    buttonProps?: ButtonProps;
    hideDownIcon?: boolean;
}
declare const ButtonCascader: {
    (props: ButtonCascaderProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface InlineToastProps {
    children: React$1.ReactNode;
    suffixIcon?: IconName;
    referenceElement: HTMLElement | null;
    placement: Side;
    /**
     * @deprecated
     * Placement to use if there is not enough space to show the full toast with the original placement
     * This is now done automatically.
     */
    alternativePlacement?: Side;
}
declare function InlineToast({ referenceElement, children, suffixIcon, placement }: InlineToastProps): react_jsx_runtime.JSX.Element;

/**
 * @public
 */
interface LoadingPlaceholderProps extends HTMLAttributes<HTMLDivElement> {
    text: React$1.ReactNode;
}
/**
 * @public
 */
declare const LoadingPlaceholder: ({ text, className, ...rest }: LoadingPlaceholderProps) => react_jsx_runtime.JSX.Element;

interface LoadingBarProps {
    width: number;
    delay?: number;
    ariaLabel?: string;
}
declare function LoadingBar({ width, delay, ariaLabel }: LoadingBarProps): react_jsx_runtime.JSX.Element;

type ColorPickerChangeHandler = (color: string) => void;
interface ColorPickerProps extends Themeable2 {
    color: string;
    onChange: ColorPickerChangeHandler;
    enableNamedColors?: boolean;
}

/**
 * If you need custom trigger for the color picker you can do that with a render prop pattern and supply a function
 * as a child. You will get show/hide function which you can map to desired interaction (like onClick or onMouseLeave)
 * and a ref which needs to be passed to an HTMLElement for correct positioning. If you want to use class or functional
 * component as a custom trigger you will need to forward the reference to first HTMLElement child.
 */
type ColorPickerTriggerRenderer = (props: {
    ref: React$1.RefObject<any>;
    showColorPicker: () => void;
    hideColorPicker: () => void;
}) => React$1.ReactNode;
declare const ColorPicker: React$1.FunctionComponent<{
    color: string;
    onChange: ColorPickerChangeHandler;
    children?: ColorPickerTriggerRenderer | undefined;
    enableNamedColors?: boolean | undefined;
}>;
declare const SeriesColorPicker: React$1.FunctionComponent<{
    color: string;
    onChange: ColorPickerChangeHandler;
    children?: ColorPickerTriggerRenderer | undefined;
    hidePopper?: (() => void) | undefined;
    enableNamedColors?: boolean | undefined;
    updatePopperPosition?: (() => void) | undefined;
    yaxis?: number | undefined;
    onToggleAxis?: (() => void) | undefined;
}>;

interface Props$14 extends Omit<HTMLProps<HTMLInputElement>, 'prefix' | 'size'> {
    /** Sets the width to a multiple of 8px. Should only be used with inline forms. Setting width of the container is preferred in other cases.*/
    width?: number;
    /** Show an invalid state around the input */
    invalid?: boolean;
    /** Show an icon as a prefix in the input */
    prefix?: ReactNode;
    /** Show an icon as a suffix in the input */
    suffix?: ReactNode;
    /** Show a loading indicator as a suffix in the input */
    loading?: boolean;
    /** Add a component as an addon before the input  */
    addonBefore?: ReactNode;
    /** Add a component as an addon after the input */
    addonAfter?: ReactNode;
}
interface StyleDeps {
    theme: GrafanaTheme2;
    invalid?: boolean;
    width?: number;
}
declare const Input: React$1.ForwardRefExoticComponent<Omit<Props$14, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
declare const getInputStyles: micro_memoize.Memoized<({ theme, invalid, width }: StyleDeps) => {
    wrapper: string;
    inputWrapper: string;
    input: string;
    inputDisabled: string;
    addon: string;
    prefix: string;
    suffix: string;
    loadingIndicator: string;
}>;

interface ColorPickerInputProps extends Omit<Props$14, 'value' | 'onChange'> {
    value?: string;
    onChange: (color: string) => void;
    /** Format for returning the color in onChange callback, defaults to 'rgb' */
    returnColorAs?: 'rgb' | 'hex';
}
declare const ColorPickerInput: React$1.ForwardRefExoticComponent<Omit<ColorPickerInputProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;

interface SeriesColorPickerPopoverProps extends ColorPickerProps, PopoverContentProps {
    yaxis?: number;
    onToggleAxis?: () => void;
}
declare const SeriesColorPickerPopover: (props: SeriesColorPickerPopoverProps) => react_jsx_runtime.JSX.Element;
declare const SeriesColorPickerPopoverWithTheme: React$1.FunctionComponent<{
    color: string;
    onChange: ColorPickerChangeHandler;
    hidePopper?: (() => void) | undefined;
    enableNamedColors?: boolean | undefined;
    updatePopperPosition?: (() => void) | undefined;
    yaxis?: number | undefined;
    onToggleAxis?: (() => void) | undefined;
}>;

interface Props$13 {
    children: JSX.Element | string;
}
declare const EmptySearchResult: ({ children }: Props$13) => react_jsx_runtime.JSX.Element;

interface Props$12 {
    /**
     * Provide a button to render below the message
     */
    button?: ReactNode;
    hideImage?: boolean;
    /**
     * Override the default image for the variant
     */
    image?: ReactNode;
    /**
     * Message to display to the user
     */
    message: string;
    /**
     * Which variant to use. Affects the default image shown.
     */
    variant: 'call-to-action' | 'not-found' | 'completed';
    /**
     * Use to set `alert` when needed. See documentation for the use case
     */
    role?: AriaRole;
}
declare const EmptyState: ({ button, children, image, message, hideImage, variant, role, }: React$1.PropsWithChildren<Props$12>) => react_jsx_runtime.JSX.Element;

interface UnitPickerProps {
    onChange: (item?: string) => void;
    value?: string;
    width?: number;
}
declare class UnitPicker extends PureComponent<UnitPickerProps> {
    onChange: (value: SelectableValue<string>) => void;
    render(): react_jsx_runtime.JSX.Element;
}

interface Props$11 {
    placeholder?: string;
    onChange: (stats: string[]) => void;
    stats: string[];
    allowMultiple?: boolean;
    defaultStat?: string;
    className?: string;
    width?: number;
    menuPlacement?: 'auto' | 'bottom' | 'top';
    inputId?: string;
    filterOptions?: (ext: FieldReducerInfo) => boolean;
}
declare class StatsPicker extends PureComponent<Props$11> {
    static defaultProps: Partial<Props$11>;
    componentDidMount(): void;
    componentDidUpdate(prevProps: Props$11): void;
    checkInput: () => void;
    onSelectionChange: (item: SelectableValue<string>) => void;
    render(): react_jsx_runtime.JSX.Element;
}

type CommonProps = {
    /** Icon name */
    icon?: IconName | React$1.ReactNode;
    /** Icon size */
    iconSize?: IconSize;
    /** Tooltip */
    tooltip?: string;
    /** For image icons */
    imgSrc?: string;
    /** Alt text for imgSrc */
    imgAlt?: string;
    /** if true or false will show angle-down/up */
    isOpen?: boolean;
    /** Controls flex-grow: 1 */
    fullWidth?: boolean;
    /** reduces padding to xs */
    narrow?: boolean;
    /** variant */
    variant?: ToolbarButtonVariant;
    /** Hide any children and only show icon */
    iconOnly?: boolean;
    /** Show highlight dot */
    isHighlighted?: boolean;
};
type ToolbarButtonVariant = 'default' | 'primary' | 'destructive' | 'active' | 'canvas';
declare const ToolbarButton: React$1.ForwardRefExoticComponent<CommonProps & ButtonHTMLAttributes<HTMLButtonElement> & React$1.RefAttributes<HTMLButtonElement>>;

interface Props$10 extends HTMLAttributes<HTMLDivElement> {
    className?: string;
    /** Determine flex-alignment of child buttons. Needed for overflow behaviour. */
    alignment?: 'left' | 'right';
}
declare const ToolbarButtonRow: React$1.ForwardRefExoticComponent<Props$10 & React$1.RefAttributes<HTMLDivElement>>;

declare const defaultIntervals: string[];
interface Props$$ {
    intervals?: string[];
    onRefresh?: () => void;
    onIntervalChanged: (interval: string) => void;
    value?: string;
    tooltip?: string;
    isLoading?: boolean;
    isLive?: boolean;
    text?: string;
    noIntervalPicker?: boolean;
    showAutoInterval?: boolean;
    width?: string;
    primary?: boolean;
    isOnCanvas?: boolean;
}
declare class RefreshPicker extends PureComponent<Props$$> {
    static offOption: {
        label: string;
        value: string;
        ariaLabel: string;
    };
    static liveOption: {
        label: string;
        value: string;
        ariaLabel: string;
    };
    static autoOption: {
        label: string;
        value: string;
        ariaLabel: string;
    };
    static isLive: (refreshInterval?: string) => boolean;
    constructor(props: Props$$);
    onChangeSelect: (item: SelectableValue<string>) => void;
    getVariant(): ToolbarButtonVariant;
    render(): react_jsx_runtime.JSX.Element;
}

interface Props$_ {
    onChange: (weekStart?: WeekStart) => void;
    value?: WeekStart;
    width?: number;
    autoFocus?: boolean;
    onBlur?: () => void;
    disabled?: boolean;
    inputId?: string;
}
type WeekStart = 'saturday' | 'sunday' | 'monday';
declare function isWeekStart(value: string): value is WeekStart;
declare global {
    interface Window {
        grafanaBootData?: BootData;
    }
}
/**
 * Returns the system or user defined week start (as defined in bootData)
 * Or you can pass in an override weekStart string and have it be validated and returned as WeekStart type if valid
 */
declare function getWeekStart(override?: string): WeekStart;
declare const WeekStartPicker: (props: Props$_) => react_jsx_runtime.JSX.Element;

/** @public */
interface TimeRangePickerProps {
    hideText?: boolean;
    value: TimeRange;
    timeZone?: TimeZone;
    fiscalYearStartMonth?: number;
    /**
     * If you handle sync state between pickers yourself use this prop to pass the sync button component.
     * Otherwise, a default one will show automatically if sync is possible.
     */
    timeSyncButton?: JSX.Element;
    isSynced?: boolean;
    initialIsSynced?: boolean;
    onChange: (timeRange: TimeRange) => void;
    onChangeTimeZone: (timeZone: TimeZone) => void;
    onChangeFiscalYearStartMonth?: (month: number) => void;
    onMoveBackward: () => void;
    onMoveForward: () => void;
    onZoom: () => void;
    onError?: (error?: string) => void;
    history?: TimeRange[];
    quickRanges?: TimeOption[];
    hideQuickRanges?: boolean;
    widthOverride?: number;
    isOnCanvas?: boolean;
    onToolbarTimePickerClick?: () => void;
    /** Which day of the week the calendar should start on. Possible values: "saturday", "sunday" or "monday" */
    weekStart?: WeekStart;
}
declare function TimeRangePicker(props: TimeRangePickerProps): react_jsx_runtime.JSX.Element;
declare namespace TimeRangePicker {
    var displayName: string;
}
declare const TimePickerTooltip: ({ timeRange, timeZone }: {
    timeRange: TimeRange;
    timeZone?: TimeZone;
}) => react_jsx_runtime.JSX.Element;

declare function TimeRangeProvider({ children }: {
    children: ReactNode;
}): react_jsx_runtime.JSX.Element;

type LabelProps$2 = Pick<TimeRangePickerProps, 'hideText' | 'value' | 'timeZone'> & {
    placeholder?: string;
    className?: string;
};
declare const TimeRangeLabel: React$1.NamedExoticComponent<LabelProps$2>;

type FormInputSize = 'sm' | 'md' | 'lg' | 'auto';

interface BaseProps$2 {
    onChange: (value: DateTime) => void | ((value?: DateTime) => void);
    value?: DateTime;
    showHour?: boolean;
    showSeconds?: boolean;
    minuteStep?: PickerProps['minuteStep'];
    size?: FormInputSize;
    disabled?: boolean;
    disabledHours?: () => number[];
    disabledMinutes?: () => number[];
    disabledSeconds?: () => number[];
    placeholder?: string;
    allowEmpty?: boolean;
}
interface AllowEmptyProps extends BaseProps$2 {
    allowEmpty: true;
    onChange: (value?: DateTime) => void;
}
interface NoAllowEmptyProps extends BaseProps$2 {
    allowEmpty?: false;
    onChange: (value: DateTime) => void;
}
type Props$Z = AllowEmptyProps | NoAllowEmptyProps;
declare const TimeOfDayPicker: ({ minuteStep, showHour, showSeconds, value, size, disabled, disabledHours, disabledMinutes, disabledSeconds, placeholder, ...restProps }: Props$Z) => react_jsx_runtime.JSX.Element;

interface Props$Y {
    onChange: (timeZone?: TimeZone) => void;
    value?: TimeZone;
    width?: number;
    autoFocus?: boolean;
    onBlur?: () => void;
    includeInternal?: boolean | InternalTimeZones[];
    disabled?: boolean;
    inputId?: string;
    menuShouldPortal?: boolean;
    openMenuOnFocus?: boolean;
}
declare const TimeZonePicker: (props: Props$Y) => react_jsx_runtime.JSX.Element;

/** @public */
interface DatePickerProps {
    isOpen?: boolean;
    onClose: () => void;
    onChange: (value: Date) => void;
    value?: Date;
    minDate?: Date;
    maxDate?: Date;
}
/** @public */
declare const DatePicker: React$1.NamedExoticComponent<DatePickerProps>;

/** @public */
interface DatePickerWithInputProps extends Omit<Props$14, 'ref' | 'value' | 'onChange'> {
    /** Value selected by the DatePicker */
    value?: Date | string;
    /** The minimum date the value can be set to */
    minDate?: Date;
    /** The maximum date the value can be set to */
    maxDate?: Date;
    /** Handles changes when a new date is selected */
    onChange: (value: Date | string) => void;
    /** Hide the calendar when date is selected */
    closeOnSelect?: boolean;
    /** Text that appears when the input has no text */
    placeholder?: string;
}
/** @public */
declare const DatePickerWithInput: ({ value, minDate, maxDate, onChange, closeOnSelect, placeholder, ...rest }: DatePickerWithInputProps) => react_jsx_runtime.JSX.Element;

interface Props$X {
    /** Input date for the component */
    date?: DateTime;
    /** Callback for returning the selected date */
    onChange: (date?: DateTime) => void;
    /** label for the input field */
    label?: ReactNode;
    /** Set the latest selectable date */
    maxDate?: Date;
    /** Set the minimum selectable date */
    minDate?: Date;
    /** Display seconds on the time picker */
    showSeconds?: boolean;
    /** Set the hours that can't be selected */
    disabledHours?: () => number[];
    /** Set the minutes that can't be selected */
    disabledMinutes?: () => number[];
    /** Set the seconds that can't be selected */
    disabledSeconds?: () => number[];
    /** Can input be cleared/have empty values */
    clearable?: boolean;
    /** Custom timezone for the date/time display */
    timeZone?: TimeZone;
}
declare const DateTimePicker: ({ date, maxDate, minDate, label, onChange, disabledHours, disabledMinutes, disabledSeconds, timeZone, showSeconds, clearable, }: Props$X) => react_jsx_runtime.JSX.Element;

interface ListProps<T> {
    items: T[];
    renderItem: (item: T, index: number) => JSX.Element;
    getItemKey?: (item: T) => string;
    className?: string;
}

declare class List<T> extends PureComponent<ListProps<T>> {
    render(): react_jsx_runtime.JSX.Element;
}

type InteractiveTableHeaderTooltip = {
    content: PopoverContent;
    iconName?: IconName;
};
type FetchDataArgs<Data> = {
    sortBy: Array<SortingRule<Data>>;
};
type FetchDataFunc<Data> = ({ sortBy }: FetchDataArgs<Data>) => void;
interface BaseProps$1<TableData extends object> {
    className?: string;
    /**
     * Table's columns definition. Must be memoized.
     */
    columns: Array<Column<TableData>>;
    /**
     * The data to display in the table. Must be memoized.
     */
    data: TableData[];
    /**
     * Must return a unique id for each row
     */
    getRowId: TableOptions<TableData>['getRowId'];
    /**
     * Optional tooltips for the table headers. The key must match the column id.
     */
    headerTooltips?: Record<string, InteractiveTableHeaderTooltip>;
    /**
     * Number of rows per page. A value of zero disables pagination. Defaults to 0.
     * A React hooks error will be thrown if pageSize goes from greater than 0 to 0 or vice versa. If enabling pagination,
     * make sure pageSize remains a non-zero value.
     */
    pageSize?: number;
    /**
     * A custom function to fetch data when the table is sorted. If not provided, the table will be sorted client-side.
     * It's important for this function to have a stable identity, e.g. being wrapped into useCallback to prevent unnecessary
     * re-renders of the table.
     */
    fetchData?: FetchDataFunc<TableData>;
    /**
     * Optional way to set how the table is sorted from the beginning. Must be memoized.
     */
    initialSortBy?: Array<SortingRule<TableData>>;
}
interface WithExpandableRow<TableData extends object> extends BaseProps$1<TableData> {
    /**
     * Render function for the expanded row. if not provided, the tables rows will not be expandable.
     */
    renderExpandedRow: (row: TableData) => ReactNode;
    /**
     * Whether to show the "Expand all" button. Depends on renderExpandedRow to be provided. Defaults to false.
     */
    showExpandAll?: boolean;
}
interface WithoutExpandableRow<TableData extends object> extends BaseProps$1<TableData> {
    renderExpandedRow?: never;
    showExpandAll?: never;
}
type Props$W<TableData extends object> = WithExpandableRow<TableData> | WithoutExpandableRow<TableData>;
/** @alpha */
declare function InteractiveTable<TableData extends object>({ className, columns, data, getRowId, headerTooltips, pageSize, renderExpandedRow, showExpandAll, fetchData, initialSortBy, }: Props$W<TableData>): react_jsx_runtime.JSX.Element;

interface Props$V {
    placeholder?: string;
    /** Array of selected tags */
    tags?: string[];
    onChange: (tags: string[]) => void;
    width?: number;
    id?: string;
    className?: string;
    /** Toggle disabled state */
    disabled?: boolean;
    /** Enable adding new tags when input loses focus */
    addOnBlur?: boolean;
    /** Toggle invalid state */
    invalid?: boolean;
    /** Colours the tags 'randomly' based on the name. Defaults to true */
    autoColors?: boolean;
}
declare const TagsInput: ({ placeholder, tags, onChange, width, className, disabled, addOnBlur, invalid, id, autoColors, }: Props$V) => react_jsx_runtime.JSX.Element;

interface FieldProps extends HTMLAttributes<HTMLDivElement> {
    /** Form input element, i.e Input or Switch */
    children: React$1.ReactElement;
    /** Label for the field */
    label?: React$1.ReactNode;
    /** Description of the field */
    description?: React$1.ReactNode;
    /** Indicates if field is in invalid state */
    invalid?: boolean;
    /** Indicates if field is in loading state */
    loading?: boolean;
    /** Indicates if field is disabled */
    disabled?: boolean;
    /** Indicates if field is required */
    required?: boolean;
    /** Error message to display */
    error?: React$1.ReactNode;
    /** Indicates horizontal layout of the field */
    horizontal?: boolean;
    /** make validation message overflow horizontally. Prevents pushing out adjacent inline components */
    validationMessageHorizontalOverflow?: boolean;
    className?: string;
    /**
     *  A unique id that associates the label of the Field component with the control with the unique id.
     *  If the `htmlFor` property is missing the `htmlFor` will be inferred from the `id` or `inputId` property of the first child.
     *  https://developer.mozilla.org/en-US/docs/Web/HTML/Element/label#attr-for
     */
    htmlFor?: string;
}
declare const Field: React$1.ForwardRefExoticComponent<FieldProps & React$1.RefAttributes<HTMLDivElement>>;

interface Props$U<T = string> extends Omit<FieldProps, 'children'> {
    /** Saving request that will be triggered 600ms after changing the value */
    onFinishChange: (inputValue: T) => Promise<void>;
    /** Custom error message to display on saving */
    saveErrorMessage?: string;
    /** Input that will save its value on change  */
    children: (onChange: (newValue: T) => void) => React$1.ReactElement;
}
declare function AutoSaveField<T = string>(props: Props$U<T>): react_jsx_runtime.JSX.Element;
declare namespace AutoSaveField {
    var displayName: string;
}

interface Props$T {
    /** The current page index being shown. */
    currentPage: number;
    /** Number of total pages. */
    numberOfPages: number;
    /** Callback function for fetching the selected page.  */
    onNavigate: (toPage: number) => void;
    /** When set to true and the pagination result is only one page it will not render the pagination at all. */
    hideWhenSinglePage?: boolean;
    /** Small version only shows the current page and the navigation buttons. */
    showSmallVersion?: boolean;
    className?: string;
}
declare const Pagination: ({ currentPage, numberOfPages, onNavigate, hideWhenSinglePage, showSmallVersion, className, }: Props$T) => react_jsx_runtime.JSX.Element | null;

/**
 * @public
 */
type OnTagClick = (name: string, event: React$1.MouseEvent<HTMLElement>) => void;
interface Props$S extends Omit<HTMLAttributes<HTMLElement>, 'onClick'> {
    /** Name of the tag to display */
    name: string;
    icon?: IconName;
    /** Use constant color from TAG_COLORS. Using index instead of color directly so we can match other styling. */
    colorIndex?: number;
    onClick?: OnTagClick;
}
declare const Tag: React$1.ForwardRefExoticComponent<Props$S & React$1.RefAttributes<HTMLElement>> & {
    Skeleton: (props: unknown) => react_jsx_runtime.JSX.Element;
};

interface Props$R {
    /** Maximum number of the tags to display */
    displayMax?: number;
    /** Names of the tags to display */
    tags: string[];
    /** Callback when the tag is clicked */
    onClick?: OnTagClick;
    /** Custom styles for the wrapper component */
    className?: string;
    /** aria-label for the `i`-th Tag component */
    getAriaLabel?: (name: string, i: number) => string;
    getColorIndex?: (name: string, i: number) => number;
    /** Icon to show next to tag label */
    icon?: IconName;
}
declare const TagList: React$1.NamedExoticComponent<Omit<Props$R & React$1.RefAttributes<HTMLUListElement>, "ref"> & {
    ref?: React$1.RefObject<HTMLUListElement> | ((instance: HTMLUListElement | null) => void | React$1.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React$1.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | null | undefined;
}> & {
    readonly type: React$1.ForwardRefExoticComponent<Props$R & React$1.RefAttributes<HTMLUListElement>>;
} & {
    Skeleton: (props: unknown) => react_jsx_runtime.JSX.Element;
};

interface FilterPillProps {
    selected: boolean;
    label: string;
    onClick: React$1.MouseEventHandler<HTMLElement>;
    icon?: IconName;
}
declare const FilterPill: ({ label, selected, onClick, icon }: FilterPillProps) => react_jsx_runtime.JSX.Element;

interface ConfirmModalProps {
    /** Toggle modal's open/closed state */
    isOpen: boolean;
    /** Title for the modal header */
    title: string;
    /** Modal content */
    body: React$1.ReactNode;
    /** Modal description */
    description?: React$1.ReactNode;
    /** Text for confirm button */
    confirmText: string;
    /** Variant for confirm button */
    confirmVariant?: ButtonVariant;
    /** Text for dismiss button */
    dismissText?: string;
    /** Variant for dismiss button */
    dismissVariant?: ButtonVariant;
    /** Icon for the modal header */
    icon?: IconName;
    /** Additional styling for modal container */
    modalClass?: string;
    /** Text user needs to fill in before confirming */
    confirmationText?: string;
    /** Text for alternative button */
    alternativeText?: string;
    /** Confirm button variant */
    confirmButtonVariant?: ButtonVariant;
    /** Confirm action callback
     * Return a promise to disable the confirm button until the promise is resolved
     */
    onConfirm(): void | Promise<void>;
    /** Dismiss action callback */
    onDismiss(): void;
    /** Alternative action callback */
    onAlternative?(): void;
    /** Disable the confirm button and the confirm text input if needed */
    disabled?: boolean;
}
declare const ConfirmModal: ({ isOpen, title, body, description, confirmText, confirmVariant, confirmationText, dismissText, dismissVariant, alternativeText, modalClass, icon, onConfirm, onDismiss, onAlternative, confirmButtonVariant, disabled, }: ConfirmModalProps) => JSX.Element;

interface QueryFieldProps extends Themeable2 {
    additionalPlugins?: Plugin[];
    cleanText?: (text: string) => string;
    disabled?: boolean;
    query?: string | null;
    onRunQuery?: () => void;
    onBlur?: () => void;
    onChange?: (value: string) => void;
    onRichValueChange?: (value: Value) => void;
    onClick?: EventHook<React$1.MouseEvent<Element, MouseEvent>>;
    onTypeahead?: (typeahead: TypeaheadInput) => Promise<TypeaheadOutput>;
    onWillApplySuggestion?: (suggestion: string, state: SuggestionsState) => string;
    placeholder?: string;
    portalOrigin: string;
    syntax?: string;
    syntaxLoaded?: boolean;
    theme: GrafanaTheme2;
}
declare const QueryField: React$1.FunctionComponent<{
    query?: string | null | undefined;
    onChange?: ((value: string) => void) | undefined;
    onRunQuery?: (() => void) | undefined;
    onBlur?: (() => void) | undefined;
    disabled?: boolean | undefined;
    onClick?: EventHook<React$1.MouseEvent<Element, MouseEvent>> | undefined;
    placeholder?: string | undefined;
    syntax?: string | undefined;
    onTypeahead?: ((typeahead: TypeaheadInput) => Promise<TypeaheadOutput>) | undefined;
    cleanText?: ((text: string) => string) | undefined;
    onWillApplySuggestion?: ((suggestion: string, state: SuggestionsState) => string) | undefined;
    portalOrigin: string;
    additionalPlugins?: Plugin[] | undefined;
    onRichValueChange?: ((value: Value) => void) | undefined;
    syntaxLoaded?: boolean | undefined;
}>;

type ReactMonacoEditorProps = Omit<EditorProps, 'theme'>;
type CodeEditorChangeHandler = (value: string) => void;
type CodeEditorSuggestionProvider = () => CodeEditorSuggestionItem[];

type Monaco = typeof monacoType;
type MonacoEditor = monacoType.editor.IStandaloneCodeEditor;
type MonacoOptions = MonacoOptionsWithGrafanaDefaults;
/**
 * @alpha
 */
declare enum CodeEditorSuggestionItemKind {
    Method = "method",
    Field = "field",
    Property = "property",
    Constant = "constant",
    Text = "text"
}
/**
 * @alpha
 */
interface CodeEditorSuggestionItem {
    /**
     * The label of this completion item. By default
     * this is also the text that is inserted when selecting
     * this completion.
     */
    label: string;
    /**
     * The kind of this completion item. An icon is chosen
     * by the editor based on the kind.
     */
    kind?: CodeEditorSuggestionItemKind;
    /**
     * A human-readable string with additional information
     * about this item, like type or symbol information.
     */
    detail?: string;
    /**
     * A human-readable string that represents a doc-comment.
     */
    documentation?: string;
    /**
     * A string or snippet that should be inserted in a document when selecting
     * this completion. When `falsy` the `label` is used.
     */
    insertText?: string;
}
/**
 * This interface will extend the original Monaco editor options interface
 * but changing the code comments to contain the proper default values to
 * prevent the consumer of the CodeEditor to get incorrect documentation in editor.
 */
interface MonacoOptionsWithGrafanaDefaults extends monacoType.editor.IStandaloneEditorConstructionOptions {
    /**
     * Enable custom contextmenu.
     * Defaults to false.
     */
    contextmenu?: boolean;
    /**
     * The number of spaces a tab is equal to.
     * This setting is overridden based on the file contents when `detectIndentation` is on.
     * Defaults to 4.
     */
    tabSize?: number;
    /**
     * Show code lens
     * Defaults to false.
     */
    codeLens?: boolean;
    /**
     * Control the width of line numbers, by reserving horizontal space for rendering at least an amount of digits.
     * Defaults to 4.
     */
    lineNumbersMinChars?: number;
    /**
     * The width reserved for line decorations (in px).
     * Line decorations are placed between line numbers and the editor content.
     * You can pass in a string in the format floating point followed by "ch". e.g. 1.3ch.
     * Defaults to 1 * theme.spacing.gridSize.
     */
    lineDecorationsWidth?: number | string;
    /**
     * Controls if a border should be drawn around the overview ruler.
     * Defaults to `false`.
     */
    overviewRulerBorder?: boolean;
    /**
     * Enable that the editor will install an interval to check if its container dom node size has changed.
     * Enabling this might have a severe performance impact.
     * Defaults to true.
     */
    automaticLayout?: boolean;
    /**
     * Always consume mouse wheel events (always call preventDefault() and stopPropagation() on the browser events).
     * Always consuming mouse wheel events will prevent the page from scrolling if the cursor is over the editor.
     * Defaults to `false`.
     */
    alwaysConsumeMouseWheel?: boolean;
}

declare const CodeEditor: React$1.FunctionComponent<{
    value: string;
    width?: number | string | undefined;
    height?: number | string | undefined;
    onChange?: CodeEditorChangeHandler | undefined;
    onBlur?: CodeEditorChangeHandler | undefined;
    readOnly?: boolean | undefined;
    language: string;
    wordWrap?: boolean | undefined;
    onFocus?: CodeEditorChangeHandler | undefined;
    showMiniMap?: boolean | undefined;
    showLineNumbers?: boolean | undefined;
    monacoOptions?: MonacoOptions | undefined;
    onBeforeEditorMount?: ((monaco: Monaco) => void) | undefined;
    onEditorDidMount?: ((editor: MonacoEditor, monaco: Monaco) => void) | undefined;
    onEditorWillUnmount?: (() => void) | undefined;
    onSave?: CodeEditorChangeHandler | undefined;
    getSuggestions?: CodeEditorSuggestionProvider | undefined;
    containerStyles?: string | undefined;
}>;

/**
 * @internal
 * Experimental export
 **/
declare const ReactMonacoEditorLazy: (props: ReactMonacoEditorProps) => react_jsx_runtime.JSX.Element;

/**
 * @alpha
 */
declare function variableSuggestionToCodeEditorSuggestion(sug: VariableSuggestion): CodeEditorSuggestionItem;

interface Props$Q {
    /** @deprecated no longer used */
    icon?: IconName;
    /** @deprecated no longer used */
    iconTooltip?: string;
    /** Title for the modal or custom header element */
    title: string | JSX.Element;
    className?: string;
    contentClassName?: string;
    closeOnEscape?: boolean;
    closeOnBackdropClick?: boolean;
    trapFocus?: boolean;
    isOpen?: boolean;
    onDismiss?: () => void;
    /** If not set will call onDismiss if that is set. */
    onClickBackdrop?: () => void;
}
declare function Modal(props: PropsWithChildren<Props$Q>): react_jsx_runtime.JSX.Element | null;
declare namespace Modal {
    var ButtonRow: typeof ModalButtonRow;
}
declare function ModalButtonRow({ leftItems, children }: {
    leftItems?: React$1.ReactNode;
    children: React$1.ReactNode;
}): react_jsx_runtime.JSX.Element;

interface Props$P {
    title: string;
    id?: string;
    /** @deprecated */
    icon?: IconName;
    /** @deprecated */
    iconTooltip?: string;
}
/** @internal */
declare const ModalHeader: ({ icon, iconTooltip, title, children, id }: React$1.PropsWithChildren<Props$P>) => react_jsx_runtime.JSX.Element;

interface ModalTab {
    value: string;
    label: string;
    icon?: IconName;
    tabSuffix?: NavModelItem['tabSuffix'];
}
interface Props$O {
    icon: IconName;
    title: string;
    tabs: ModalTab[];
    activeTab: string;
    onChangeTab(tab: ModalTab): void;
}
declare const ModalTabsHeader: ({ icon, title, tabs, activeTab, onChangeTab }: Props$O) => react_jsx_runtime.JSX.Element;

interface Props$N {
    /** @deprecated */
    icon?: IconName;
    /** @deprecated */
    iconClass?: string;
}
/** @internal */
declare const ModalTabContent: ({ children }: React$1.PropsWithChildren<Props$N>) => react_jsx_runtime.JSX.Element;

interface ModalsContextState {
    component: React$1.ComponentType<any> | null;
    props: any;
    showModal: <T>(component: React$1.ComponentType<T>, props: T) => void;
    hideModal: () => void;
}
declare const ModalsContext: React$1.Context<ModalsContextState>;
interface ModalsProviderProps {
    children: React$1.ReactNode;
    /** Set default component to render as modal. Useful when rendering modals from Angular */
    component?: React$1.ComponentType<any> | null;
    /** Set default component props. Useful when rendering modals from Angular */
    props?: any;
}
/**
 * @deprecated.
 * Not the real implementation used by core.
 */
declare class ModalsProvider extends Component<ModalsProviderProps, ModalsContextState> {
    constructor(props: ModalsProviderProps);
    showModal: <T>(component: React$1.ComponentType<T>, props: T) => void;
    hideModal: () => void;
    render(): react_jsx_runtime.JSX.Element;
}
declare const ModalRoot: () => react_jsx_runtime.JSX.Element;
declare const ModalsController: React$1.Consumer<ModalsContextState>;

interface Props$M {
    pageIcon?: IconName;
    title?: string;
    section?: string;
    parent?: string;
    onGoBack?: () => void;
    titleHref?: string;
    parentHref?: string;
    leftItems?: ReactNode[];
    children?: ReactNode;
    className?: string;
    isFullscreen?: boolean;
    'aria-label'?: string;
    buttonOverflowAlignment?: 'left' | 'right';
    /**
     * Forces left items to be visible on small screens.
     * By default left items are hidden on small screens.
     */
    forceShowLeftItems?: boolean;
}
/** @alpha */
declare const PageToolbar: React$1.MemoExoticComponent<({ title, section, parent, pageIcon, onGoBack, children, titleHref, parentHref, leftItems, isFullscreen, className, "aria-label": ariaLabel, buttonOverflowAlignment, forceShowLeftItems, }: Props$M) => react_jsx_runtime.JSX.Element>;

interface Props$L {
    func: () => unknown;
    loading: boolean;
    interval: string;
}
declare class SetInterval extends PureComponent<Props$L> {
    private propsSubject;
    private subscription;
    constructor(props: Props$L);
    componentDidMount(): void;
    componentDidUpdate(prevProps: Props$L): void;
    componentWillUnmount(): void;
    render(): null;
}

declare enum TableCellInspectorMode {
    code = "code",
    text = "text"
}
interface TableCellInspectorProps {
    value: any;
    onDismiss: () => void;
    mode: TableCellInspectorMode;
}
declare function TableCellInspector({ value, onDismiss, mode }: TableCellInspectorProps): react_jsx_runtime.JSX.Element;

declare const FILTER_FOR_OPERATOR = "=";
declare const FILTER_OUT_OPERATOR = "!=";
type AdHocFilterOperator = typeof FILTER_FOR_OPERATOR | typeof FILTER_OUT_OPERATOR;
type AdHocFilterItem = {
    key: string;
    value: string;
    operator: AdHocFilterOperator;
};
type TableFilterActionCallback = (item: AdHocFilterItem) => void;
type TableColumnResizeActionCallback = (fieldDisplayName: string, width: number) => void;
type TableSortByActionCallback = (state: TableSortByFieldState[]) => void;
interface TableSortByFieldState {
    displayName: string;
    desc?: boolean;
}
type FooterItem = Array<KeyValue<string>> | string | undefined;
interface TableFooterCalc {
    show: boolean;
    reducer: string[];
    fields?: string[];
    enablePagination?: boolean;
    countRows?: boolean;
}
interface TableRTProps {
    ariaLabel?: string;
    data: DataFrame;
    width: number;
    height: number;
    maxHeight?: number;
    /** Minimal column width specified in pixels */
    columnMinWidth?: number;
    noHeader?: boolean;
    showTypeIcons?: boolean;
    resizable?: boolean;
    initialSortBy?: TableSortByFieldState[];
    onColumnResize?: TableColumnResizeActionCallback;
    onSortByChange?: TableSortByActionCallback;
    onCellFilterAdded?: TableFilterActionCallback;
    footerOptions?: TableFooterCalc;
    footerValues?: FooterItem[];
    enablePagination?: boolean;
    cellHeight?: schema.TableCellHeight;
    /** @alpha Used by SparklineCell when provided */
    timeRange?: TimeRange;
    enableSharedCrosshair?: boolean;
    initialRowIndex?: number;
    fieldConfig?: FieldConfigSource;
    getActions?: GetActionsFunction;
    replaceVariables?: InterpolateFunction;
}
/**
 * @alpha
 * Props that will be passed to the TableCustomCellOptions.cellComponent when rendered.
 */
interface CustomCellRendererProps {
    field: Field$1;
    rowIndex: number;
    frame: DataFrame;
    value: unknown;
}
/**
 * @alpha
 * Can be used to define completely custom cell contents by providing a custom cellComponent.
 */
interface TableCustomCellOptions {
    cellComponent: FC<CustomCellRendererProps>;
    type: schema.TableCellDisplayMode.Custom;
}
/**
 * @alpha
 * Props that will be passed to the TableCustomCellOptions.cellComponent when rendered.
 */
interface CustomHeaderRendererProps {
    field: Field$1;
    defaultContent: React.ReactNode;
}
type TableCellOptions = schema.TableCellOptions | TableCustomCellOptions;
type TableFieldOptions = Omit<schema.TableFieldOptions, 'cellOptions'> & {
    cellOptions: TableCellOptions;
    headerComponent?: React.ComponentType<CustomHeaderRendererProps>;
};
type GetActionsFunction = (frame: DataFrame, field: Field$1, rowIndex: number, replaceVariables?: InterpolateFunction) => ActionModel[];

declare const Table: React$1.MemoExoticComponent<(props: TableRTProps) => react_jsx_runtime.JSX.Element>;

declare const TableInputCSV: React$1.FunctionComponent<{
    text: string;
    width: string | number;
    height: string | number;
    config?: CSVConfig | undefined;
    onSeriesParsed: (data: DataFrame[], text: string) => void;
}>;

interface Props$K {
    /** Children should be a single <Tab /> or an array of <Tab /> */
    children: ReactNode;
    className?: string;
    /** For hiding the bottom border (on PageHeader for example) */
    hideBorder?: boolean;
}
declare const TabsBar: React$1.ForwardRefExoticComponent<Props$K & React$1.RefAttributes<HTMLDivElement>>;

interface TabProps extends HTMLProps<HTMLElement> {
    label: string;
    active?: boolean;
    /** When provided, it is possible to use the tab as a hyperlink. Use in cases where the tabs update location. */
    href?: string;
    icon?: IconName;
    onChangeTab?: (event: React$1.MouseEvent<HTMLElement>) => void;
    /** A number rendered next to the text. Usually used to display the number of items in a tab's view. */
    counter?: number | null;
    /** Extra content, displayed after the tab label and counter */
    suffix?: NavModelItem['tabSuffix'];
    truncate?: boolean;
    tooltip?: string;
}
declare const Tab: React$1.ForwardRefExoticComponent<Omit<TabProps, "ref"> & React$1.RefAttributes<HTMLElement>>;

declare const VerticalTab: React$1.ForwardRefExoticComponent<Omit<TabProps, "ref"> & React$1.RefAttributes<HTMLAnchorElement>>;

interface Props$J extends HTMLAttributes<HTMLDivElement> {
    children: ReactNode;
}
declare const TabContent: ({ children, className, ...restProps }: Props$J) => react_jsx_runtime.JSX.Element;

interface CounterProps {
    value: number;
}
declare const Counter: ({ value }: CounterProps) => react_jsx_runtime.JSX.Element;

interface RenderUserContentAsHTMLProps<T = HTMLSpanElement> extends Omit<HTMLAttributes<T>, 'dangerouslySetInnerHTML'> {
    component?: keyof React$1.ReactHTML;
    content: string;
}
declare function RenderUserContentAsHTML<T>({ component, content, ...rest }: PropsWithChildren<RenderUserContentAsHTMLProps<T>>): JSX.Element;

declare enum BigValueColorMode {
    Background = "background",
    BackgroundSolid = "background_solid",
    None = "none",
    Value = "value"
}
declare enum BigValueGraphMode {
    None = "none",
    Line = "line",
    Area = "area"
}
declare enum BigValueJustifyMode {
    Auto = "auto",
    Center = "center"
}
/**
 * Options for how the value & title are to be displayed
 */
declare enum BigValueTextMode {
    Auto = "auto",
    Value = "value",
    ValueAndName = "value_and_name",
    Name = "name",
    None = "none"
}
interface Props$I extends Themeable2 {
    /** Height of the component */
    height: number;
    /** Width of the component */
    width: number;
    /** Value displayed as Big Value */
    value: DisplayValue;
    /** Sparkline values for showing a graph under/behind the value  */
    sparkline?: FieldSparkline;
    /** onClick handler for the value */
    onClick?: React$1.MouseEventHandler<HTMLElement>;
    /** Custom styling */
    className?: string;
    /** Color mode for coloring the value or the background */
    colorMode: BigValueColorMode;
    /** Show a graph behind/under the value */
    graphMode: BigValueGraphMode;
    /** Auto justify value and text or center it */
    justifyMode?: BigValueJustifyMode;
    /** Factors that should influence the positioning of the text  */
    alignmentFactors?: DisplayValueAlignmentFactors;
    /** Explicit font size control */
    text?: VizTextDisplayOptions;
    /** Specify which text should be visible in the BigValue */
    textMode?: BigValueTextMode;
    /** If true disables the tooltip */
    hasLinks?: boolean;
    /** Percent change color mode */
    percentChangeColorMode?: PercentChangeColorMode;
    /**
     * If part of a series of stat panes, this is the total number.
     * Used by BigValueTextMode.Auto text mode.
     */
    count?: number;
    /**
     * Disable the wide layout for the BigValue
     */
    disableWideLayout?: boolean;
}
declare class BigValue extends PureComponent<Props$I> {
    static defaultProps: Partial<Props$I>;
    render(): react_jsx_runtime.JSX.Element;
}

/**
 * @internal -- not a public API
 */
declare const FIXED_UNIT = "__fixed";
type PlotConfig = Pick<Options, 'mode' | 'series' | 'scales' | 'axes' | 'cursor' | 'bands' | 'hooks' | 'select' | 'tzDate' | 'padding'>;
type FacetValues = any[];
type FacetSeries = FacetValues[];
type FacetedData = [_: null, ...series: FacetSeries];
interface PlotProps {
    data: AlignedData | FacetedData;
    width: number;
    height: number;
    config: UPlotConfigBuilder;
    children?: React$1.ReactNode;
    plotRef?: (u: uPlot) => void;
}
declare abstract class PlotConfigBuilder<P, T> {
    props: P;
    constructor(props: P);
    abstract getConfig(): T;
}
/**
 * @alpha
 */
type PlotTooltipInterpolator = (updateActiveSeriesIdx: (sIdx: number | null) => void, updateActiveDatapointIdx: (dIdx: number | null) => void, updateTooltipPosition: (clear?: boolean) => void, u: uPlot) => void;
interface PlotSelection {
    min: number;
    max: number;
    bbox: {
        top: number;
        left: number;
        width: number;
        height: number;
    };
}

/** @internal */
interface StackingGroup {
    series: number[];
    dir: StackDirection;
}
/** @internal */
declare const enum StackDirection {
    Pos = 1,
    Neg = -1
}

interface AxisProps {
    scaleKey: string;
    theme: GrafanaTheme2;
    label?: string;
    show?: boolean;
    size?: number | null;
    gap?: number;
    tickLabelRotation?: number;
    placement?: AxisPlacement;
    grid?: Axis.Grid;
    ticks?: Axis.Ticks;
    filter?: Axis.Filter;
    space?: Axis.Space;
    formatValue?: (v: any, decimals?: DecimalCount) => string;
    incrs?: Axis.Incrs;
    splits?: Axis.Splits;
    values?: Axis.Values;
    isTime?: boolean;
    timeZone?: TimeZone;
    color?: uPlot.Axis.Stroke;
    border?: uPlot.Axis.Border;
    decimals?: DecimalCount;
    distr?: ScaleDistribution;
}
declare const UPLOT_AXIS_FONT_SIZE = 12;

interface ScaleProps {
    scaleKey: string;
    isTime?: boolean;
    min?: number | null;
    max?: number | null;
    softMin?: number | null;
    softMax?: number | null;
    range?: Scale.Range;
    distribution?: ScaleDistribution;
    orientation: ScaleOrientation;
    direction: ScaleDirection;
    log?: number;
    linearThreshold?: number;
    centeredZero?: boolean;
    decimals?: DecimalCount;
    stackingMode?: StackingMode;
}
declare class UPlotScaleBuilder extends PlotConfigBuilder<ScaleProps, Scale> {
    merge(props: ScaleProps): void;
    getConfig(): Scale;
}

interface SeriesProps extends LineConfig, BarConfig, FillConfig, PointsConfig {
    scaleKey: string;
    pxAlign?: boolean;
    gradientMode?: GraphGradientMode;
    dynamicSeriesColor?: (seriesIdx: number) => string | undefined;
    facets?: uPlot.Series.Facet[];
    /** Used when gradientMode is set to Scheme */
    thresholds?: ThresholdsConfig;
    colorMode?: FieldColorMode;
    hardMin?: number | null;
    hardMax?: number | null;
    softMin?: number | null;
    softMax?: number | null;
    drawStyle?: GraphDrawStyle;
    pathBuilder?: Series.PathBuilder | null;
    pointsFilter?: Series.Points.Filter | null;
    pointsBuilder?: Series.Points.Show | null;
    show?: boolean;
    dataFrameFieldIndex?: DataFrameFieldIndex;
    theme: GrafanaTheme2;
    value?: uPlot.Series.Value;
}
declare class UPlotSeriesBuilder extends PlotConfigBuilder<SeriesProps, Series> {
    getConfig(): {
        show: boolean;
        class?: string;
        scale: string;
        auto?: boolean;
        sorted?: Series.Sorted;
        spanGaps: boolean;
        gaps?: Series.GapsRefiner;
        pxAlign: number | boolean;
        label?: string | HTMLElement;
        value: Series.Value;
        values?: Series.Values;
        paths?: Series.PathBuilder;
        points?: Series.Points;
        facets: Series.Facet[];
        width?: number;
        stroke?: Series.Stroke;
        fill: Series.Fill;
        fillTo?: Series.FillTo;
        dash?: number[];
        cap?: Series.Cap;
        alpha?: number;
        idxs?: Series.MinMaxIdxs;
        min?: number;
        max?: number;
    };
    private getLineColor;
    private getFill;
}

interface UPlotThresholdOptions {
    scaleKey: string;
    thresholds: ThresholdsConfig;
    config: GraphThresholdsStyleConfig;
    theme: GrafanaTheme2;
    hardMin?: number | null;
    hardMax?: number | null;
    softMin?: number | null;
    softMax?: number | null;
}

type PrepData = (frames: DataFrame[]) => AlignedData | FacetedData;
type PreDataStacked = (frames: DataFrame[], stackingGroups: StackingGroup[]) => AlignedData | FacetedData;
declare class UPlotConfigBuilder {
    readonly uid: string;
    series: UPlotSeriesBuilder[];
    private axes;
    readonly scales: UPlotScaleBuilder[];
    private bands;
    private stackingGroups;
    private cursor;
    private select;
    private hasLeftAxis;
    private hooks;
    private tz;
    private mode;
    private frames;
    private thresholds;
    private padding?;
    private cachedConfig?;
    prepData: PrepData | undefined;
    constructor(timeZone?: TimeZone);
    scaleKeys: [string, string];
    addHook<T extends keyof Hooks.Defs>(type: T, hook: Hooks.Defs[T]): void;
    addThresholds(options: UPlotThresholdOptions): void;
    addAxis(props: AxisProps): void;
    getAxisPlacement(scaleKey: string): AxisPlacement;
    setCursor(cursor?: Cursor): void;
    setMode(mode: uPlot.Mode): void;
    setSelect(select: Select$2): void;
    addSeries(props: SeriesProps): void;
    getSeries(): UPlotSeriesBuilder[];
    /** Add or update the scale with the scale key */
    addScale(props: ScaleProps): void;
    addBand(band: Band): void;
    setStackingGroups(groups: StackingGroup[]): void;
    getStackingGroups(): StackingGroup[];
    setPrepData(prepData: PreDataStacked): void;
    setPadding(padding: Padding): void;
    getConfig(): PlotConfig;
    private tzDate;
    private ensureNonOverlappingAxes;
}
type Renderers = Array<{
    fieldMap: Record<string, string>;
    indicesOnly: string[];
    init: (config: UPlotConfigBuilder, fieldIndices: Record<string, number>) => void;
}>;
/** @alpha */
type UPlotConfigPrepOpts<T extends Record<string, unknown> = {}> = {
    frame: DataFrame;
    theme: GrafanaTheme2;
    timeZones: TimeZone[];
    getTimeRange: () => TimeRange;
    allFrames: DataFrame[];
    renderers?: Renderers;
    tweakScale?: (opts: ScaleProps, forField: Field$1) => ScaleProps;
    tweakAxis?: (opts: AxisProps, forField: Field$1) => AxisProps;
    hoverProximity?: number;
    orientation?: VizOrientation;
} & T;
/** @alpha */
type UPlotConfigPrepFn<T extends {} = {}> = (opts: UPlotConfigPrepOpts<T>) => UPlotConfigBuilder;

interface SparklineProps extends Themeable2 {
    width: number;
    height: number;
    config?: FieldConfig<GraphFieldConfig>;
    sparkline: FieldSparkline;
}
interface State$4 {
    data: AlignedData;
    alignedDataFrame: DataFrame;
    configBuilder: UPlotConfigBuilder;
}
/** @internal */
declare class Sparkline extends PureComponent<SparklineProps, State$4> {
    constructor(props: SparklineProps);
    static getDerivedStateFromProps(props: SparklineProps, state: State$4): {
        data: AlignedData;
        alignedDataFrame: DataFrame;
        configBuilder: UPlotConfigBuilder;
    };
    componentDidUpdate(prevProps: SparklineProps, prevState: State$4): void;
    getYRange(field: Field$1): Range.MinMax;
    prepareConfig(data: DataFrame): UPlotConfigBuilder;
    render(): react_jsx_runtime.JSX.Element;
}

interface Props$H {
    height: number;
    field: FieldConfig;
    showThresholdMarkers: boolean;
    showThresholdLabels: boolean;
    width: number;
    value: DisplayValue;
    text?: VizTextDisplayOptions;
    onClick?: React$1.MouseEventHandler<HTMLElement>;
    className?: string;
    theme: GrafanaTheme2;
    orientation?: VizOrientation;
}
declare class Gauge extends PureComponent<Props$H> {
    canvasElement: HTMLDivElement | null;
    static defaultProps: Partial<Props$H>;
    componentDidMount(): void;
    componentDidUpdate(): void;
    draw(): void;
    renderVisualization: () => react_jsx_runtime.JSX.Element;
    render(): react_jsx_runtime.JSX.Element;
}

interface Props$G extends Themeable2 {
    height: number;
    width: number;
    field: FieldConfig;
    display?: DisplayProcessor;
    value: DisplayValue;
    orientation: VizOrientation$1;
    text?: VizTextDisplayOptions;
    itemSpacing?: number;
    lcdCellWidth?: number;
    displayMode: BarGaugeDisplayMode;
    onClick?: React$1.MouseEventHandler<HTMLElement>;
    className?: string;
    showUnfilled?: boolean;
    alignmentFactors?: DisplayValueAlignmentFactors;
    valueDisplayMode?: BarGaugeValueMode;
    namePlacement?: BarGaugeNamePlacement;
    isOverflow: boolean;
}
declare class BarGauge extends PureComponent<Props$G> {
    static defaultProps: Partial<Props$G>;
    render(): react_jsx_runtime.JSX.Element;
    renderBarAndValue(): ReactNode;
    renderBasicAndGradientBars(): ReactNode;
    renderRetroBars(): ReactNode;
}

interface FlotPosition {
    pageX: number;
    pageY: number;
    x: number;
    x1: number;
    y: number;
    y1: number;
}
type ActiveDimensions<T extends Dimensions = any> = {
    [key in keyof T]: [number, number | undefined] | null;
};
interface VizTooltipContentProps<T extends Dimensions = any> {
    dimensions: T;
    activeDimensions?: ActiveDimensions<T>;
    timeZone?: TimeZone;
    pos: FlotPosition;
    mode: TooltipDisplayMode;
}
interface VizTooltipProps {
    /** Element used as tooltips content */
    content?: React$1.ReactElement;
    /** Optional component to be used as a tooltip content */
    tooltipComponent?: React$1.ComponentType<React$1.PropsWithChildren<VizTooltipContentProps>>;
    /** x/y position relative to the window */
    position?: {
        x: number;
        y: number;
    };
    /** x/y offset relative to tooltip origin element, i.e. graph's datapoint */
    offset?: {
        x: number;
        y: number;
    };
    mode?: TooltipDisplayMode;
}
/**
 * @public
 */
declare const VizTooltip: {
    ({ content, position, offset }: VizTooltipProps): react_jsx_runtime.JSX.Element | null;
    displayName: string;
};

/**
 * @public
 */
interface VizTooltipContainerProps extends HTMLAttributes<HTMLDivElement> {
    position: {
        x: number;
        y: number;
    };
    offset: {
        x: number;
        y: number;
    };
    children?: React$1.ReactNode;
    allowPointerEvents?: boolean;
}
/**
 * @public
 */
declare const VizTooltipContainer: {
    ({ position: { x: positionX, y: positionY }, offset: { x: offsetX, y: offsetY }, children, allowPointerEvents, className, ...otherProps }: VizTooltipContainerProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

/**
 * @public
 */
interface SeriesTableRowProps {
    color?: string;
    label?: React$1.ReactNode;
    value?: string | GraphSeriesValue;
    isActive?: boolean;
}
/**
 * @public
 */
declare const SeriesTableRow: ({ color, label, value, isActive }: SeriesTableRowProps) => react_jsx_runtime.JSX.Element;
/**
 * @public
 */
interface SeriesTableProps {
    timestamp?: string | GraphSeriesValue;
    series: SeriesTableRowProps[];
}
/**
 * @public
 */
declare const SeriesTable: ({ timestamp, series }: SeriesTableProps) => react_jsx_runtime.JSX.Element;

interface Props$F<V, D> {
    /**
     * Optionally precalculate dimensions to support consistent behavior between repeated
     * values.  Two typical patterns are:
     * 1) Calculate raw values like font size etc and pass them to each vis
     * 2) find the maximum input values and pass that to the vis
     */
    getAlignmentFactors?: (values: V[], width: number, height: number) => D;
    /**
     * Render a single value
     */
    renderValue: (props: VizRepeaterRenderValueProps<V, D>) => JSX.Element;
    height: number;
    width: number;
    source: unknown;
    getValues: () => V[];
    renderCounter: number;
    orientation: VizOrientation$1;
    itemSpacing?: number;
    /** When orientation is set to auto layout items in a grid */
    autoGrid?: boolean;
    minVizWidth?: number;
    minVizHeight?: number;
    maxVizHeight?: number;
}
interface VizRepeaterRenderValueProps<V, D = {}> {
    value: V;
    width: number;
    height: number;
    orientation: VizOrientation$1;
    alignmentFactors: D;
    /**
     * Total number of values being shown in repeater
     */
    count: number;
}
interface DefaultProps {
    itemSpacing: number;
}
type PropsWithDefaults<V, D> = Props$F<V, D> & DefaultProps;
interface State$3<V> {
    values: V[];
}
declare class VizRepeater<V, D = {}> extends PureComponent<PropsWithDefaults<V, D>, State$3<V>> {
    static defaultProps: DefaultProps;
    constructor(props: PropsWithDefaults<V, D>);
    componentDidUpdate(prevProps: Props$F<V, D>): void;
    getOrientation(): VizOrientation$1;
    renderGrid(): react_jsx_runtime.JSX.Element;
    render(): react_jsx_runtime.JSX.Element;
}

/**
 * @internal
 */
type LoadingIndicatorProps = {
    loading: boolean;
    onCancel: () => void;
};
/**
 * @internal
 */
declare const LoadingIndicator: ({ onCancel, loading }: LoadingIndicatorProps) => react_jsx_runtime.JSX.Element | null;

/**
 * @internal
 */
type PanelChromeProps = (AutoSize | FixedDimensions) & (Collapsible | HoverHeader);
interface BaseProps {
    padding?: PanelPadding;
    title?: string | React$1.ReactElement;
    description?: string | (() => string);
    titleItems?: ReactNode;
    menu?: ReactElement | (() => ReactElement);
    dragClass?: string;
    dragClassCancel?: string;
    onDragStart?: (e: React$1.PointerEvent) => void;
    selectionId?: string;
    /**
     * Use only to indicate loading or streaming data in the panel.
     * Any other values of loadingState are ignored.
     */
    loadingState?: LoadingState;
    /**
     * Used to display status message (used for panel errors currently)
     */
    statusMessage?: string;
    /**
     * Handle opening error details view (like inspect / error tab)
     */
    statusMessageOnClick?: (e: React$1.SyntheticEvent) => void;
    /**
     * @deprecated use `actions' instead
     **/
    leftItems?: ReactNode[];
    actions?: ReactNode;
    displayMode?: 'default' | 'transparent';
    onCancelQuery?: () => void;
    /**
     * callback when opening the panel menu
     */
    onOpenMenu?: () => void;
    /**
     * Used for setting panel attention
     */
    onFocus?: () => void;
    /**
     * Debounce the event handler, if possible
     */
    onMouseMove?: () => void;
    onMouseEnter?: () => void;
    /**
     * If true, the VizPanelMenu will always be visible in the panel header. Defaults to false.
     */
    showMenuAlways?: boolean;
}
interface FixedDimensions extends BaseProps {
    width: number;
    height: number;
    children: (innerWidth: number, innerHeight: number) => ReactNode;
}
interface AutoSize extends BaseProps {
    width?: never;
    height?: never;
    children: ReactNode;
}
interface Collapsible {
    collapsible: boolean;
    collapsed?: boolean;
    /**
     * callback when collapsing or expanding the panel
     */
    onToggleCollapse?: (collapsed: boolean) => void;
    hoverHeader?: never;
    hoverHeaderOffset?: never;
}
interface HoverHeader {
    collapsible?: never;
    collapsed?: never;
    showMenuAlways?: never;
    onToggleCollapse?: never;
    hoverHeader?: boolean;
    hoverHeaderOffset?: number;
}
/**
 * @internal
 */
type PanelPadding = 'none' | 'md';

type TitleItemProps = {
    className?: string;
    children: React$1.ReactNode;
    onClick?: LinkModel['onClick'];
    href?: string;
    target?: LinkTarget;
    title?: string;
};
type TitleItemElement = HTMLAnchorElement & HTMLButtonElement;
declare const TitleItem: React$1.ForwardRefExoticComponent<TitleItemProps & React$1.RefAttributes<TitleItemElement>>;

/**
 * Mode to describe if a legend is isolated/selected or being appended to an existing
 * series selection.
 * @alpha
 */
declare enum SeriesVisibilityChangeMode {
    ToggleSelection = "select",
    AppendToSelection = "append"
}
type OnSelectRangeCallback = (selections: RangeSelection2D[]) => void;
interface RangeSelection1D {
    from: number;
    to: number;
}
interface RangeSelection2D {
    x?: RangeSelection1D;
    y?: RangeSelection1D;
}

/** @alpha */
interface PanelContext {
    /** Identifier for the events scope */
    eventsScope: string;
    eventBus: EventBus;
    /** Dashboard panels sync */
    sync?: () => DashboardCursorSync;
    /** Information on what the outer container is */
    app?: CoreApp | 'string';
    /**
     * Called when a component wants to change the color for a series
     *
     * @alpha -- experimental
     */
    onSeriesColorChange?: (label: string, color: string) => void;
    onToggleSeriesVisibility?: (label: string, mode: SeriesVisibilityChangeMode) => void;
    canAddAnnotations?: () => boolean;
    canEditAnnotations?: (dashboardUID?: string) => boolean;
    canDeleteAnnotations?: (dashboardUID?: string) => boolean;
    onAnnotationCreate?: (annotation: AnnotationEventUIModel) => void;
    onAnnotationUpdate?: (annotation: AnnotationEventUIModel) => void;
    onAnnotationDelete?: (id: string) => void;
    /**
     * Called when a user selects an area on the panel, if defined will override the default behavior of the panel,
     * which is to update the time range
     */
    onSelectRange?: OnSelectRangeCallback;
    /**
     * Used from visualizations like Table to add ad-hoc filters from cell values
     */
    onAddAdHocFilter?: (item: AdHocFilterItem) => void;
    /**
     * Enables modifying thresholds directly from the panel
     *
     * @alpha -- experimental
     */
    canEditThresholds?: boolean;
    /**
     * Shows threshold indicators on the right-hand side of the panel
     *
     * @alpha -- experimental
     */
    showThresholds?: boolean;
    /**
     * Called when a panel wants to change default thresholds configuration
     *
     * @alpha -- experimental
     */
    onThresholdsChange?: (thresholds: ThresholdsConfig) => void;
    /** For instance state that can be shared between panel & options UI  */
    instanceState?: any;
    /** Update instance state, this is only supported in dashboard panel context currently */
    onInstanceStateChange?: (state: any) => void;
    /**
     * Called when a panel is changing the sort order of the legends.
     */
    onToggleLegendSort?: (sortBy: string) => void;
    /**
     * Optional, only some contexts support this. This action can be cancelled by user which will result
     * in a the Promise resolving to a false value.
     */
    onUpdateData?: (frames: DataFrame[]) => Promise<boolean>;
    /**
     * Optional supplier for internal data links. If not provided a link pointing to Explore will be generated.
     * @internal
     */
    dataLinkPostProcessor?: DataLinkPostProcessor;
}
declare const PanelContextRoot: React$1.Context<PanelContext>;
/**
 * @alpha
 */
declare const PanelContextProvider: React$1.Provider<PanelContext>;
/**
 * @alpha
 */
declare const usePanelContext: () => PanelContext;

/**
 * @internal
 */
interface PanelChromeType extends React$1.FC<PanelChromeProps> {
    LoadingIndicator: typeof LoadingIndicator;
    TitleItem: typeof TitleItem;
}
/**
 * @internal
 */
declare const PanelChrome: PanelChromeType;

/**
 * @beta
 */
interface VizLayoutProps {
    width: number;
    height: number;
    legend?: React$1.ReactElement<VizLayoutLegendProps> | null;
    children: (width: number, height: number) => React$1.ReactNode;
}
/**
 * @beta
 */
interface VizLayoutComponentType extends FC<VizLayoutProps> {
    Legend: ComponentType<VizLayoutLegendProps>;
}
/**
 * @beta
 */
declare const VizLayout: VizLayoutComponentType;
/**
 * @beta
 */
interface VizLayoutLegendProps {
    placement: LegendPlacement;
    children: React$1.ReactNode;
    maxHeight?: string;
    maxWidth?: string;
    width?: number;
}

declare enum SeriesVisibilityChangeBehavior {
    Isolate = 0,
    Hide = 1
}
interface VizLegendBaseProps<T> {
    placement: LegendPlacement;
    className?: string;
    items: Array<VizLegendItem<T>>;
    thresholdItems?: Array<VizLegendItem<T>>;
    mappingItems?: Array<VizLegendItem<T>>;
    seriesVisibilityChangeBehavior?: SeriesVisibilityChangeBehavior;
    onLabelClick?: (item: VizLegendItem<T>, event: React$1.MouseEvent<HTMLButtonElement>) => void;
    itemRenderer?: (item: VizLegendItem<T>, index: number) => JSX.Element;
    onLabelMouseOver?: (item: VizLegendItem, event: React$1.MouseEvent<HTMLButtonElement> | React$1.FocusEvent<HTMLButtonElement>) => void;
    onLabelMouseOut?: (item: VizLegendItem, event: React$1.MouseEvent<HTMLButtonElement> | React$1.FocusEvent<HTMLButtonElement>) => void;
    readonly?: boolean;
}
interface VizLegendTableProps<T> extends VizLegendBaseProps<T> {
    sortBy?: string;
    sortDesc?: boolean;
    onToggleSort?: (sortBy: string) => void;
    isSortable?: boolean;
}
interface LegendProps<T = any> extends VizLegendBaseProps<T>, VizLegendTableProps<T> {
    displayMode: LegendDisplayMode;
}
interface VizLegendItem<T = any> {
    getItemKey?: () => string;
    label: string;
    color?: string;
    gradient?: string;
    yAxis: number;
    disabled?: boolean;
    getDisplayValues?: () => DisplayValue[];
    fieldIndex?: DataFrameFieldIndex;
    fieldName?: string;
    data?: T;
    lineStyle?: LineStyle;
}

/**
 * @public
 */
declare function VizLegend<T>({ items, thresholdItems, mappingItems, displayMode, sortBy: sortKey, seriesVisibilityChangeBehavior, sortDesc, onLabelClick, onToggleSort, placement, className, itemRenderer, readonly, isSortable, }: LegendProps<T>): react_jsx_runtime.JSX.Element | null;
declare namespace VizLegend {
    var displayName: string;
}

interface Props$E<T> {
    item: VizLegendItem<T>;
    className?: string;
    onLabelClick?: (item: VizLegendItem<T>, event: React$1.MouseEvent<HTMLButtonElement>) => void;
    onLabelMouseOver?: (item: VizLegendItem, event: React$1.MouseEvent<HTMLButtonElement> | React$1.FocusEvent<HTMLButtonElement>) => void;
    onLabelMouseOut?: (item: VizLegendItem, event: React$1.MouseEvent<HTMLButtonElement> | React$1.FocusEvent<HTMLButtonElement>) => void;
    readonly?: boolean;
}
/**
 * @internal
 */
declare const VizLegendListItem: {
    <T = unknown>({ item, onLabelClick, onLabelMouseOver, onLabelMouseOut, className, readonly, }: Props$E<T>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

type AlertVariant = 'success' | 'warning' | 'error' | 'info';
interface Props$D extends HTMLAttributes<HTMLDivElement> {
    title: string;
    /** On click handler for alert button, mostly used for dismissing the alert */
    onRemove?: (event: React$1.MouseEvent) => void;
    severity?: AlertVariant;
    children?: ReactNode;
    elevated?: boolean;
    buttonContent?: React$1.ReactNode | string;
    bottomSpacing?: number;
    topSpacing?: number;
}
declare const Alert: React$1.ForwardRefExoticComponent<Props$D & React$1.RefAttributes<HTMLDivElement>>;

/** @deprecated */
interface GraphSeriesTogglerAPI {
    onSeriesToggle: (label: string, event: React$1.MouseEvent<HTMLElement>) => void;
    toggledSeries: GraphSeriesXY[];
}
/** @deprecated */
interface GraphSeriesTogglerProps {
    children: (api: GraphSeriesTogglerAPI) => JSX.Element;
    series: GraphSeriesXY[];
    onHiddenSeriesChanged?: (hiddenSeries: string[]) => void;
}
/** @deprecated */
interface GraphSeriesTogglerState {
    hiddenSeries: string[];
    toggledSeries: GraphSeriesXY[];
}
/** @deprecated */
declare class GraphSeriesToggler extends Component<GraphSeriesTogglerProps, GraphSeriesTogglerState> {
    constructor(props: GraphSeriesTogglerProps);
    componentDidUpdate(prevProps: Readonly<GraphSeriesTogglerProps>): void;
    onSeriesToggle(label: string, event: React$1.MouseEvent<HTMLElement>): void;
    render(): JSX.Element;
}

interface Props$C {
    /** Expand or collapse te content */
    isOpen?: boolean;
    /** Element or text for the Collapse header */
    label: React$1.ReactNode;
    /** Indicates loading state of the content */
    loading?: boolean;
    /** Toggle collapsed header icon */
    collapsible?: boolean;
    /** Callback for the toggle functionality */
    onToggle?: (isOpen: boolean) => void;
    /** Additional class name for the root element */
    className?: string;
}
declare const ControlledCollapse: ({ isOpen, onToggle, ...otherProps }: React$1.PropsWithChildren<Props$C>) => react_jsx_runtime.JSX.Element;
declare const Collapse: {
    ({ isOpen, label, loading, collapsible, onToggle, className, children, }: React$1.PropsWithChildren<Props$C>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface Props$B {
    label: ReactNode;
    isOpen: boolean;
    /** Callback for the toggle functionality */
    onToggle?: (isOpen: boolean) => void;
    children: ReactNode;
    className?: string;
    contentClassName?: string;
    loading?: boolean;
    labelId?: string;
    headerDataTestId?: string;
    contentDataTestId?: string;
    unmountContentWhenClosed?: boolean;
}
declare const CollapsableSection: ({ label, isOpen, onToggle, className, contentClassName, children, labelId, loading, headerDataTestId, contentDataTestId, unmountContentWhenClosed, }: Props$B) => react_jsx_runtime.JSX.Element;

type DataLinkButtonProps = {
    link: LinkModel<Field$1>;
    buttonProps?: ButtonProps;
};
/**
 * @internal
 */
declare function DataLinkButton({ link, buttonProps }: DataLinkButtonProps): react_jsx_runtime.JSX.Element;

type Props$A = {
    links: Array<LinkModel<Field$1>>;
};
/**
 * @internal
 */
declare function FieldLinkList({ links }: Props$A): react_jsx_runtime.JSX.Element;

interface Props$z {
    className?: string;
}
declare const FullWidthButtonContainer: ({ className, children }: React$1.PropsWithChildren<Props$z>) => react_jsx_runtime.JSX.Element;

interface Props$y {
    /**
     *  Callback to trigger when clicking outside of current element occurs.
     */
    onClick: () => void;
    /**
     *  Runs the 'onClick' function when pressing a key outside of the current element. Defaults to true.
     */
    includeButtonPress: boolean;
    /** Object to attach the click event listener to. */
    parent: Window | Document;
    /**
     * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener. Defaults to false.
     */
    useCapture?: boolean;
}
interface State$2 {
    hasEventListener: boolean;
}
declare class ClickOutsideWrapper extends PureComponent<React$1.PropsWithChildren<Props$y>, State$2> {
    static defaultProps: {
        includeButtonPress: boolean;
        parent: (Window & typeof globalThis) | undefined;
        useCapture: boolean;
    };
    myRef: React$1.RefObject<HTMLDivElement>;
    state: {
        hasEventListener: boolean;
    };
    componentDidMount(): void;
    componentWillUnmount(): void;
    onOutsideClick: EventListener;
    render(): react_jsx_runtime.JSX.Element;
}

interface SingleStatBaseOptions extends OptionsWithTextFormatting {
    reduceOptions: ReduceDataOptions;
    orientation: VizOrientation$1;
}
declare function sharedSingleStatPanelChangedHandler(panel: PanelModel<Partial<SingleStatBaseOptions>> | any, prevPluginId: string, prevOptions: any): any;
declare function sharedSingleStatMigrationHandler(panel: PanelModel<SingleStatBaseOptions>): SingleStatBaseOptions;
/**
 * @deprecated use convertOldAngularValueMappings instead
 * Convert the angular single stat mapping to new react style
 */
declare function convertOldAngularValueMapping(panel: any): ValueMapping[];

interface CallToActionCardProps {
    message?: string | JSX.Element;
    callToActionElement: JSX.Element;
    footer?: string | JSX.Element;
    className?: string;
}
declare const CallToActionCard: ({ message, callToActionElement, footer, className }: CallToActionCardProps) => react_jsx_runtime.JSX.Element;

interface ContextMenuProps {
    /** Starting horizontal position for the menu */
    x: number;
    /** Starting vertical position for the menu */
    y: number;
    /** Callback for closing the menu */
    onClose?: () => void;
    /** On menu open focus the first element */
    focusOnOpen?: boolean;
    /** RenderProp function that returns menu items to display */
    renderMenuItems?: () => React$1.ReactNode;
    /** A function that returns header element */
    renderHeader?: () => React$1.ReactNode;
}
declare const ContextMenu: React$1.MemoExoticComponent<({ x, y, onClose, focusOnOpen, renderMenuItems, renderHeader }: ContextMenuProps) => react_jsx_runtime.JSX.Element>;

/** @internal */
interface MenuItemsGroup<T = unknown> {
    /** Label for the menu items group */
    label?: string;
    /** Aria label for accessibility support */
    ariaLabel?: string;
    /** Items of the group */
    items: Array<MenuItemProps<T>>;
}
/** @internal */
interface MenuGroupProps extends Partial<MenuItemsGroup> {
    /** special children prop to pass children elements */
    children: React$1.ReactNode;
}
/** @internal */
declare const MenuGroup: {
    ({ label, ariaLabel, children }: MenuGroupProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare function MenuDivider(): react_jsx_runtime.JSX.Element;

interface MenuProps extends React$1.HTMLAttributes<HTMLDivElement> {
    /** React element rendered at the top of the menu */
    header?: React$1.ReactNode;
    children: React$1.ReactNode;
    ariaLabel?: string;
    onOpen?: (focusOnItem: (itemId: number) => void) => void;
    onClose?: () => void;
    onKeyDown?: React$1.KeyboardEventHandler;
}
declare const Menu: React$1.ForwardRefExoticComponent<MenuProps & React$1.RefAttributes<HTMLDivElement>> & {
    Item: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<MenuItemProps<unknown> & React$1.RefAttributes<MenuItemElement>>>;
    Divider: typeof MenuDivider;
    Group: {
        ({ label, ariaLabel, children }: MenuGroupProps): react_jsx_runtime.JSX.Element;
        displayName: string;
    };
};

interface WithContextMenuProps {
    /** Menu item trigger that accepts openMenu prop */
    children: (props: {
        openMenu: React$1.MouseEventHandler<HTMLElement>;
    }) => JSX.Element;
    /** A function that returns an array of menu items */
    renderMenuItems: () => React$1.ReactNode;
    /** On menu open focus the first element */
    focusOnOpen?: boolean;
}
declare const WithContextMenu: ({ children, renderMenuItems, focusOnOpen }: WithContextMenuProps) => react_jsx_runtime.JSX.Element;

interface DataLinksInlineEditorBaseProps<T extends DataLink | Action> {
    type: 'link' | 'action';
    items?: T[];
    onChange: (items: T[]) => void;
    data: DataFrame[];
    children: (item: T, index: number, onSave: (index: number, item: T) => void, onCancel: (index: number) => void) => React.ReactNode;
}
/** @internal */
declare function DataLinksInlineEditorBase<T extends DataLink | Action>({ type, items, onChange, data, children, }: DataLinksInlineEditorBaseProps<T>): react_jsx_runtime.JSX.Element;

type DataLinksInlineEditorProps = Omit<DataLinksInlineEditorBaseProps<DataLink>, 'children' | 'type' | 'items'> & {
    links?: DataLink[];
    showOneClick?: boolean;
    getSuggestions: () => VariableSuggestion[];
};
declare const DataLinksInlineEditor: ({ links, getSuggestions, showOneClick, ...rest }: DataLinksInlineEditorProps) => react_jsx_runtime.JSX.Element;

interface DataLinkInputProps {
    value: string;
    onChange: (url: string, callback?: () => void) => void;
    suggestions: VariableSuggestion[];
    placeholder?: string;
}
declare const DataLinkInput: React$1.MemoExoticComponent<({ value, onChange, suggestions, placeholder, }: DataLinkInputProps) => react_jsx_runtime.JSX.Element>;

interface DataLinksContextMenuProps {
    children: (props: DataLinksContextMenuApi) => JSX.Element;
    links: () => LinkModel[];
    style?: CSSProperties;
    /**
     * @deprecated Will be removed in a future version
     */
    actions?: ActionModel[];
}
interface DataLinksContextMenuApi {
    openMenu?: React$1.MouseEventHandler<HTMLOrSVGElement>;
    targetClassName?: string;
}
declare const DataLinksContextMenu: ({ children, links, style }: DataLinksContextMenuProps) => react_jsx_runtime.JSX.Element;

interface Props$x extends React$1.HTMLAttributes<HTMLDivElement> {
    color?: string;
    gradient?: string;
    lineStyle?: LineStyle;
}
declare const SeriesIcon: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<Props$x & React$1.RefAttributes<HTMLDivElement>>>;

interface InfoBoxProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, 'title'> {
    children: React$1.ReactNode;
    /** Title of the box */
    title?: string | JSX.Element;
    /** Url of the read more link */
    url?: string;
    /** Text of the read more link */
    urlTitle?: string;
    /** Indicates whether or not box should be rendered with Grafana branding background */
    branded?: boolean;
    /** Color variant of the box */
    severity?: AlertVariant;
    /** Call back to be performed when box is dismissed */
    onDismiss?: () => void;
}
/** @deprecated use Alert with severity info */
declare const InfoBox: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<InfoBoxProps & React$1.RefAttributes<HTMLDivElement>>>;

interface FeatureInfoBoxProps extends Omit<InfoBoxProps, 'title' | 'urlTitle'> {
    title: string;
    featureState?: FeatureState;
}
/** @deprecated use Alert with severity info */
declare const FeatureInfoBox: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<FeatureInfoBoxProps & React$1.RefAttributes<HTMLDivElement>>>;

interface FeatureBadgeProps {
    featureState: FeatureState;
    tooltip?: string;
}
declare const FeatureBadge: ({ featureState, tooltip }: FeatureBadgeProps) => react_jsx_runtime.JSX.Element;

interface JsonExplorerConfig {
    animateOpen?: boolean;
    animateClose?: boolean;
    theme?: string;
}
/**
 * @class JsonExplorer
 *
 * JsonExplorer allows you to render JSON objects in HTML with a
 * **collapsible** navigation.
 */
declare class JsonExplorer {
    json: any;
    private open;
    private config;
    private key?;
    private _isOpen;
    private element;
    private skipChildren;
    /**
     * @param {object} json The JSON object you want to render. It has to be an
     * object or array. Do NOT pass raw JSON string.
     *
     * @param {number} [open=1] his number indicates up to how many levels the
     * rendered tree should expand. Set it to `0` to make the whole tree collapsed
     * or set it to `Infinity` to expand the tree deeply
     *
     * @param {object} [config=defaultConfig] -
     *  defaultConfig = {
     *   hoverPreviewEnabled: false,
     *   hoverPreviewArrayCount: 100,
     *   hoverPreviewFieldCount: 5
     * }
     *
     * Available configurations:
     *  #####Hover Preview
     * * `hoverPreviewEnabled`:  enable preview on hover
     * * `hoverPreviewArrayCount`: number of array items to show in preview Any
     *    array larger than this number will be shown as `Array[XXX]` where `XXX`
     *    is length of the array.
     * * `hoverPreviewFieldCount`: number of object properties to show for object
     *   preview. Any object with more properties that thin number will be
     *   truncated.
     *
     * @param {string} [key=undefined] The key that this object in its parent
     * context
     */
    constructor(json: any, open?: number, config?: JsonExplorerConfig, key?: string | undefined);
    private get isOpen();
    private set isOpen(value);
    private get isDate();
    private get isUrl();
    private get isArray();
    private get isObject();
    private get isEmptyObject();
    private get isEmpty();
    private get hasKey();
    private get constructorName();
    private get type();
    private get keys();
    /**
     * Toggles `isOpen` state
     *
     */
    toggleOpen(): void;
    /**
     * Open all children up to a certain depth.
     * Allows actions such as expand all/collapse all
     *
     */
    openAtDepth(depth?: number): void;
    isNumberArray(): boolean;
    renderArray(): HTMLSpanElement;
    /**
     * Renders an HTML element and installs event listeners
     *
     * @returns {HTMLDivElement}
     */
    render(skipRoot?: boolean): HTMLDivElement;
    /**
     * Appends all the children to children element
     * Animated option is used when user triggers this via a click
     */
    appendChildren(animated?: boolean): void;
    /**
     * Removes all the children from children element
     * Animated option is used when user triggers this via a click
     */
    removeChildren(animated?: boolean): void;
}

interface Props$w {
    className?: string;
    json: {};
    config?: JsonExplorerConfig;
    open?: number;
    onDidRender?: (formattedJson: {}) => void;
}
declare class JSONFormatter extends PureComponent<Props$w> {
    private wrapperRef;
    static defaultProps: {
        open: number;
        config: {
            animateOpen: boolean;
        };
    };
    componentDidMount(): void;
    componentDidUpdate(): void;
    renderJson: () => void;
    render(): react_jsx_runtime.JSX.Element;
}

interface ErrorBoundaryApi {
    error: Error | null;
    errorInfo: ErrorInfo | null;
}
interface Props$v {
    children: (r: ErrorBoundaryApi) => ReactNode;
    /** Will re-render children after error if recover values changes */
    dependencies?: unknown[];
    /** Callback called on error */
    onError?: (error: Error) => void;
    /** Callback error state is cleared due to recover props change */
    onRecover?: () => void;
    /** Default error logger - Faro by default */
    errorLogger?: (error: Error) => void;
}
interface State$1 {
    error: Error | null;
    errorInfo: ErrorInfo | null;
}
declare class ErrorBoundary extends PureComponent<Props$v, State$1> {
    readonly state: State$1;
    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
    componentDidUpdate(prevProps: Props$v): void;
    render(): ReactNode;
}
/**
 * Props for the ErrorBoundaryAlert component
 *
 * @public
 */
interface ErrorBoundaryAlertProps {
    /** Title for the error boundary alert */
    title?: string;
    /** Component to be wrapped with an error boundary */
    children: ReactNode;
    /** 'page' will render full page error with stacktrace. 'alertbox' will render an <Alert />. Default 'alertbox' */
    style?: 'page' | 'alertbox';
    /** Will re-render children after error if recover values changes */
    dependencies?: unknown[];
    /** Default error logger - Faro by default */
    errorLogger?: (error: Error) => void;
}
declare class ErrorBoundaryAlert extends PureComponent<ErrorBoundaryAlertProps> {
    static defaultProps: Partial<ErrorBoundaryAlertProps>;
    render(): react_jsx_runtime.JSX.Element;
}
/**
 * HOC for wrapping a component in an error boundary.
 *
 * @param Component - the react component to wrap in error boundary
 * @param errorBoundaryProps - error boundary options
 *
 * @public
 */
declare function withErrorBoundary<P extends {} = {}>(Component: ComponentType<P>, errorBoundaryProps?: Omit<ErrorBoundaryAlertProps, 'children'>): ComponentType<P>;

interface Props$u extends ErrorBoundaryApi {
    title: string;
}
declare const ErrorWithStack: {
    ({ error, errorInfo, title }: Props$u): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface AzureAuthSettings {
    /** Set to true if Azure authentication supported by the datasource */
    readonly azureAuthSupported: boolean;
    /** Gets whether the Azure authentication currently enabled for the datasource */
    readonly getAzureAuthEnabled: (config: DataSourceSettings) => boolean;
    /** Enables/disables the Azure authentication from the datasource */
    readonly setAzureAuthEnabled: (config: DataSourceSettings, enabled: boolean) => Partial<DataSourceSettings>;
    /** Optional React component of additional Azure settings UI if authentication is enabled  */
    readonly azureSettingsUI?: React$1.ComponentType<HttpSettingsBaseProps>;
}
interface HttpSettingsBaseProps<JSONData extends DataSourceJsonData = any, SecureJSONData = any> {
    /** The configuration object of the data source */
    dataSourceConfig: DataSourceSettings<JSONData, SecureJSONData>;
    /** Callback for handling changes to the configuration object */
    onChange: (config: DataSourceSettings<JSONData, SecureJSONData>) => void;
    /** Show the Forward OAuth identity option */
    showForwardOAuthIdentityOption?: boolean;
}
interface HttpSettingsProps extends HttpSettingsBaseProps {
    /** The default url for the data source */
    defaultUrl: string;
    /** Set label for url option */
    urlLabel?: string;
    /** Added to default url tooltip */
    urlDocs?: React$1.ReactNode;
    /** Show the http access help box */
    showAccessOptions?: boolean;
    /** Show the SigV4 auth toggle option */
    sigV4AuthToggleEnabled?: boolean;
    /** Azure authentication settings **/
    azureAuthSettings?: AzureAuthSettings;
    /** If SIGV4 is enabled, provide an editor for SIGV4 connection config  **/
    renderSigV4Editor?: React$1.ReactNode;
    /** Show the Secure Socks Datasource Proxy toggle option */
    secureSocksDSProxyEnabled?: boolean;
}

/**
 * @deprecated Use components from `@grafana/plugin-ui` instead, according to the [migration guide](https://github.com/grafana/plugin-ui/blob/main/src/components/ConfigEditor/migrating-from-datasource-http-settings.md).
 */
declare const DataSourceHttpSettings: (props: HttpSettingsProps) => react_jsx_runtime.JSX.Element;

interface CustomHeader {
    id: string;
    name: string;
    value: string;
    configured: boolean;
}
type CustomHeaders = CustomHeader[];
interface Props$t {
    dataSourceConfig: DataSourceSettings<any, any>;
    onChange: (config: DataSourceSettings) => void;
}
interface State {
    headers: CustomHeaders;
}
declare class CustomHeadersSettings extends PureComponent<Props$t, State> {
    state: State;
    constructor(props: Props$t);
    updateSettings: () => void;
    onHeaderAdd: () => void;
    onHeaderChange: (headerIndex: number, value: CustomHeader) => void;
    onHeaderReset: (headerId: string) => void;
    onHeaderRemove: (headerId: string) => void;
    render(): react_jsx_runtime.JSX.Element;
}

interface Props$s<T extends DataSourceJsonData> extends Pick<DataSourcePluginOptionsEditorProps<T>, 'options' | 'onOptionsChange'> {
}
interface AlertingConfig extends DataSourceJsonData {
    manageAlerts?: boolean;
}
declare function AlertingSettings<T extends AlertingConfig>({ options, onOptionsChange }: Props$s<T>): JSX.Element;

interface Props$r<T extends DataSourceJsonData> extends Pick<DataSourcePluginOptionsEditorProps<T>, 'options' | 'onOptionsChange'> {
}
interface SecureSocksProxyConfig extends DataSourceJsonData {
    enableSecureSocksProxy?: boolean;
}
declare function SecureSocksProxySettings<T extends SecureSocksProxyConfig>({ options, onOptionsChange, }: Props$r<T>): JSX.Element;

declare const TLSAuthSettings: ({ dataSourceConfig, onChange }: HttpSettingsBaseProps) => react_jsx_runtime.JSX.Element;

interface Props$q {
    label: string;
    hasCert: boolean;
    placeholder: string;
    onChange: (event: ChangeEvent<HTMLTextAreaElement>) => void;
    onClick: (event: MouseEvent$1<HTMLButtonElement>) => void;
}
declare const CertificationKey: ({ hasCert, label, onChange, onClick, placeholder }: Props$q) => react_jsx_runtime.JSX.Element;

interface Props$p {
    className?: string;
    style?: React$1.CSSProperties;
    iconClassName?: string;
    inline?: boolean;
    size?: IconSize;
}
/**
 * @deprecated
 * use a predefined size, e.g. 'md' or 'lg' instead
 */
interface PropsWithDeprecatedSize extends Omit<Props$p, 'size'> {
    size?: number | string;
}
/**
 * @public
 */
declare const Spinner: ({ className, inline, iconClassName, style, size, }: Props$p | PropsWithDeprecatedSize) => react_jsx_runtime.JSX.Element;

type Props$o = {
    children: React$1.ReactElement;
    visible: boolean;
    duration?: number;
};
declare function FadeTransition(props: Props$o): react_jsx_runtime.JSX.Element;

type Props$n = {
    children: React$1.ReactElement;
    visible: boolean;
    size: number;
    duration?: number;
    horizontal?: boolean;
};
declare function SlideOutTransition(props: Props$n): react_jsx_runtime.JSX.Element;

interface SegmentProps {
    Component?: ReactElement;
    className?: string;
    allowCustomValue?: boolean;
    placeholder?: string;
    disabled?: boolean;
    onExpandedChange?: (expanded: boolean) => void;
    autofocus?: boolean;
    allowEmptyValue?: boolean;
    inputPlaceholder?: string;
}

interface SegmentSyncProps<T> extends SegmentProps, Omit<HTMLProps<HTMLDivElement>, 'value' | 'onChange'> {
    value?: T | SelectableValue<T>;
    onChange: (item: SelectableValue<T>) => void;
    options: Array<SelectableValue<T>>;
    inputMinWidth?: number;
}
declare function Segment<T>({ options, value, onChange, Component, className, allowCustomValue, allowEmptyValue, placeholder, disabled, inputMinWidth, inputPlaceholder, onExpandedChange, autofocus, ...rest }: React$1.PropsWithChildren<SegmentSyncProps<T>>): react_jsx_runtime.JSX.Element;

interface SegmentAsyncProps<T> extends SegmentProps, Omit<HTMLProps<HTMLDivElement>, 'value' | 'onChange'> {
    value?: T | SelectableValue<T>;
    loadOptions: (query?: string) => Promise<Array<SelectableValue<T>>>;
    /**
     *  If true options will be reloaded when user changes the value in the input,
     *  otherwise, options will be loaded when the segment is clicked
     */
    reloadOptionsOnChange?: boolean;
    onChange: (item: SelectableValue<T>) => void;
    noOptionMessageHandler?: (state: AsyncState<Array<SelectableValue<T>>>) => string;
    inputMinWidth?: number;
}
declare function SegmentAsync<T>({ value, onChange, loadOptions, reloadOptionsOnChange, Component, className, allowCustomValue, allowEmptyValue, disabled, placeholder, inputMinWidth, inputPlaceholder, autofocus, onExpandedChange, noOptionMessageHandler, ...rest }: React$1.PropsWithChildren<SegmentAsyncProps<T>>): react_jsx_runtime.JSX.Element;

/** @internal
 * Should be used only internally by Segment/SegmentAsync which can guarantee that SegmentSelect is hidden
 * when a value is selected. See comment below on closeMenuOnSelect()
 */
interface Props$m<T> extends Omit<HTMLProps<HTMLDivElement>, 'value' | 'onChange'> {
    value?: T | SelectableValue<T>;
    options: Array<SelectableValue<T>>;
    onChange: (item: SelectableValue<T>) => void;
    /**
     * If provided - AsyncSelect will be used allowing to reload options when the value in the input changes
     */
    loadOptions?: (inputValue: string) => Promise<Array<SelectableValue<T>>>;
    onClickOutside: () => void;
    width: number;
    noOptionsMessage?: string;
    allowCustomValue?: boolean;
    /**
     * If true, empty value will be passed to onChange callback otherwise using empty value
     * will work as canceling and using the previous value
     */
    allowEmptyValue?: boolean;
    placeholder?: string;
}
/** @internal */
declare function SegmentSelect<T>({ value, placeholder, options, onChange, onClickOutside, loadOptions, width: widthPixels, noOptionsMessage, allowCustomValue, allowEmptyValue, ...rest }: React$1.PropsWithChildren<Props$m<T>>): react_jsx_runtime.JSX.Element;

interface SegmentInputProps extends Omit<SegmentProps, 'allowCustomValue' | 'allowEmptyValue'>, Omit<HTMLProps<HTMLInputElement>, 'value' | 'onChange'> {
    value: string | number;
    onChange: (text: string | number) => void;
}
declare function SegmentInput({ value: initialValue, onChange, Component, className, placeholder, inputPlaceholder, disabled, autofocus, onExpandedChange, ...rest }: React$1.PropsWithChildren<SegmentInputProps>): react_jsx_runtime.JSX.Element;

/**
 * Horizontal section for editor components.
 *
 * @alpha
 */
declare const SegmentSection: ({ label, htmlFor, children, fill, }: {
    label: string;
    htmlFor?: string;
    children: React$1.ReactNode;
    fill?: boolean;
}) => react_jsx_runtime.JSX.Element;

interface Props$l {
    children: ReactNode;
    /** Title shown at the top of the drawer */
    title?: ReactNode;
    /** Subtitle shown below the title */
    subtitle?: ReactNode;
    /** Should the Drawer be closable by clicking on the mask, defaults to true */
    closeOnMaskClick?: boolean;
    /** @deprecated */
    inline?: boolean;
    /**
     * @deprecated use the size property instead
     **/
    width?: number | string;
    /**
     * @deprecated use a large size instead if high width is needed
     **/
    expandable?: boolean;
    /**
     * Specifies the width and min-width.
     * sm = width 25vw & min-width 384px
     * md = width 50vw & min-width 568px
     * lg = width 75vw & min-width 744px
     **/
    size?: 'sm' | 'md' | 'lg';
    /** Tabs */
    tabs?: React$1.ReactNode;
    /**
     * Whether the content should be wrapped in a ScrollContainer
     * Only change this if you intend to manage scroll behaviour yourself
     * (e.g. having a split pane with independent scrolling)
     **/
    scrollableContent?: boolean;
    /** Callback for closing the drawer */
    onClose: () => void;
}
declare function Drawer({ children, onClose, closeOnMaskClick, scrollableContent, title, subtitle, width, size, tabs, }: Props$l): react_jsx_runtime.JSX.Element;

type Orientation$1 = 'horizontal' | 'vertical';

interface CommonSliderProps {
    min: number;
    max: number;
    orientation?: Orientation$1;
    /** Set current positions of handle(s). If only 1 value supplied, only 1 handle displayed. */
    reverse?: boolean;
    step?: number;
    tooltipAlwaysVisible?: boolean;
    /** Marks on the slider. The key determines the position, and the value determines what will show. If you want to set the style of a specific mark point, the value should be an object which contains style and label properties. */
    marks?: SliderMarks;
    /** If the value is true, it means a continuous value interval, otherwise, it is a independent value. */
    included?: boolean;
}
interface SliderProps extends CommonSliderProps {
    value?: number;
    onChange?: (value: number) => void;
    onAfterChange?: (value?: number) => void;
    formatTooltipResult?: (value: number) => number;
    ariaLabelForHandle?: string;
}
interface RangeSliderProps extends CommonSliderProps {
    value?: number[];
    onChange?: (value: number[]) => void;
    onAfterChange?: (value?: number[]) => void;
    formatTooltipResult?: (value: number) => number | string;
}

/**
 * @public
 */
declare const Slider: {
    ({ min, max, onChange, onAfterChange, orientation, reverse, step, value, ariaLabelForHandle, marks, included, }: SliderProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

/**
 * @public
 *
 * RichHistoryQueriesTab uses this Range Component
 */
declare const RangeSlider: {
    ({ min, max, onChange, onAfterChange, orientation, reverse, step, formatTooltipResult, value, tooltipAlwaysVisible, }: RangeSliderProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface FormProps<T extends FieldValues> extends Omit<HTMLProps<HTMLFormElement>, 'onSubmit' | 'children'> {
    validateOn?: Mode;
    validateOnMount?: boolean;
    validateFieldsOnMount?: string | string[];
    defaultValues?: DefaultValues<T>;
    onSubmit: SubmitHandler<T>;
    children: (api: FormAPI<T>) => React$1.ReactNode;
    /** Sets max-width for container. Use it instead of setting individual widths on inputs.*/
    maxWidth?: number | 'none';
}
/**
 * @deprecated use the `useForm` hook from react-hook-form instead
 */
declare function Form<T extends FieldValues>({ defaultValues, onSubmit, validateOnMount, validateFieldsOnMount, children, validateOn, maxWidth, ...htmlProps }: FormProps<T>): react_jsx_runtime.JSX.Element;

declare const sharedInputStyle: (theme: GrafanaTheme2, invalid?: boolean) => string;

/**
 * @deprecated use the `Controller` component from react-hook-form instead
 */
declare const InputControl: <TFieldValues extends react_hook_form.FieldValues = react_hook_form.FieldValues, TName extends react_hook_form.FieldPath<TFieldValues> = react_hook_form.FieldPath<TFieldValues>>(props: react_hook_form.ControllerProps<TFieldValues, TName>) => React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;

interface ValuePickerProps<T> {
    /** Aria label applied to the input field */
    ['aria-label']?: string;
    /** Label to display on the picker button */
    label: string;
    /** Icon to display on the picker button */
    icon?: IconName;
    /** ValuePicker options  */
    options: Array<SelectableValue<T>>;
    /** Callback to handle selected option */
    onChange: (value: SelectableValue<T>) => void;
    /** Which ButtonVariant to render */
    variant?: ButtonVariant;
    /** Size of button  */
    size?: ComponentSize;
    /** Min width for select in grid units */
    minWidth?: number;
    /** Should the picker cover the full width of its parent */
    isFullWidth?: boolean;
    /** Control where the menu is rendered */
    menuPlacement?: 'auto' | 'bottom' | 'top';
    /** Which ButtonFill to use */
    fill?: ButtonFill;
    /** custom css applied to the button */
    buttonCss?: string;
}
declare function ValuePicker<T>({ 'aria-label': ariaLabel, label, icon, options, onChange, variant, minWidth, size, isFullWidth, menuPlacement, fill, buttonCss, }: ValuePickerProps<T>): react_jsx_runtime.JSX.Element;

interface FieldMatcherUIRegistryItem<TOptions> extends RegistryItem {
    component: React$1.ComponentType<MatcherUIProps<TOptions>>;
    matcher: FieldMatcherInfo<TOptions>;
    optionsToLabel: (options: TOptions) => string;
}
interface MatcherUIProps<T> {
    matcher: FieldMatcherInfo<T>;
    id?: string;
    data: DataFrame[];
    options: T;
    onChange: (options: T) => void;
}

declare const fieldMatchersUI: Registry<FieldMatcherUIRegistryItem<any>>;

interface Props$k extends AnchorHTMLAttributes<HTMLAnchorElement> {
}
/**
 * @alpha
 */
declare const Link: React$1.ForwardRefExoticComponent<Props$k & React$1.RefAttributes<HTMLAnchorElement>>;

type TextLinkVariants = keyof Omit<ThemeTypographyVariantTypes, 'code'>;
interface TextLinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'target' | 'rel'> {
    /** url to which redirect the user, external or internal */
    href: string;
    /** Color to use for text */
    color?: keyof GrafanaTheme2['colors']['text'];
    /** Specify if the link will redirect users to a page in or out Grafana */
    external?: boolean;
    /** True when the link will be displayed inline with surrounding text, false if it will be displayed as a block. Depending on this prop correspondant default styles will be applied */
    inline?: boolean;
    /** The default variant is 'body'. To fit another styles set the correspondent variant as it is necessary also to adjust the icon size. `code` is excluded, as it is not fit for links. */
    variant?: TextLinkVariants;
    /** Override the default weight for the used variant */
    weight?: 'light' | 'regular' | 'medium' | 'bold';
    /** Set the icon to be shown. An external link will show the 'external-link-alt' icon as default.*/
    icon?: IconName;
    children: React.ReactNode;
}
declare const TextLink: React$1.ForwardRefExoticComponent<TextLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;

interface TextProps extends Omit<React$1.HTMLAttributes<HTMLElement>, 'className' | 'style'> {
    /** Defines what HTML element is defined underneath. "span" by default */
    element?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'span' | 'p';
    /** What typograpy variant should be used for the component. Only use if default variant for the defined element is not what is needed */
    variant?: keyof ThemeTypographyVariantTypes;
    /** Override the default weight for the used variant */
    weight?: 'light' | 'regular' | 'medium' | 'bold';
    /** Color to use for text */
    color?: keyof GrafanaTheme2['colors']['text'] | 'error' | 'success' | 'warning' | 'info';
    /** Use to cut the text off with ellipsis if there isn't space to show all of it. On hover shows the rest of the text */
    truncate?: boolean;
    /** If true, show the text as italic. False by default */
    italic?: boolean;
    /** If true, numbers will have fixed width, useful for displaying tabular data. False by default */
    tabular?: boolean;
    /** Whether to align the text to left, center or right */
    textAlignment?: CSSProperties['textAlign'];
    children: NonNullable<React$1.ReactNode>;
}
declare const Text: React$1.ForwardRefExoticComponent<TextProps & React$1.RefAttributes<HTMLElement>>;

/**
 * Type that represents a prop that can be responsive.
 *
 * @example To turn a prop like `margin: number` responsive, change it to `margin: ResponsiveProp<number>`.
 */
type ResponsiveProp<T> = T | Responsive<T>;
type Responsive<T> = {
    xs: T;
    sm?: T;
    md?: T;
    lg?: T;
    xl?: T;
    xxl?: T;
};

type AlignItems = 'stretch' | 'flex-start' | 'flex-end' | 'center' | 'baseline' | 'start' | 'end' | 'self-start' | 'self-end';
type JustifyContent = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly' | 'stretch' | 'start' | 'end' | 'left' | 'right';
type Direction = 'row' | 'row-reverse' | 'column' | 'column-reverse';
type Wrap = boolean | 'nowrap' | 'wrap' | 'wrap-reverse';
type FlexGrow = number;
type FlexShrink = number;
type FlexBasis = 'auto' | 'initial' | '0' | `${number}%` | `${number}px`;
type Flex = FlexGrow | `${FlexGrow}` | `${FlexGrow} ${FlexShrink}` | `${FlexGrow} ${FlexShrink} ${FlexBasis}`;
type FlexProps = {
    /** Sets the property `flex-grow` */
    grow?: ResponsiveProp<FlexGrow>;
    /** Sets the property `flex-shrink` */
    shrink?: ResponsiveProp<FlexShrink>;
    /** Sets the property `flex-basis` */
    basis?: ResponsiveProp<FlexBasis>;
    /** Sets the property `flex` */
    flex?: ResponsiveProp<Flex>;
};

interface SizeProps {
    minWidth?: ResponsiveProp<Property.MinWidth<number>>;
    maxWidth?: ResponsiveProp<Property.MaxWidth<number>>;
    width?: ResponsiveProp<Property.Width<number>>;
    minHeight?: ResponsiveProp<Property.MinHeight<number>>;
    maxHeight?: ResponsiveProp<Property.MaxHeight<number>>;
    height?: ResponsiveProp<Property.Height<number>>;
}

type Display = 'flex' | 'block' | 'inline' | 'inline-block' | 'none';
type BackgroundColor = keyof GrafanaTheme2['colors']['background'] | 'error' | 'success' | 'warning' | 'info';
type BorderStyle = 'solid' | 'dashed';
type BorderColor = keyof GrafanaTheme2['colors']['border'] | 'error' | 'success' | 'warning' | 'info';
type BorderRadius = keyof ThemeShape['radius'];
type BoxShadow = keyof ThemeShadows;
interface BoxProps extends FlexProps, SizeProps, Omit<React$1.HTMLAttributes<HTMLElement>, 'className' | 'style'> {
    /** Sets the property `margin` */
    margin?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the properties `margin-top` and `margin-bottom`. Higher priority than margin. */
    marginX?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the properties `margin-left` and `margin-right`. Higher priority than margin. */
    marginY?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the property `margin-top`. Higher priority than margin and marginY. */
    marginTop?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the property `margin-bottom`. Higher priority than margin and marginXY */
    marginBottom?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the property `margin-left`. Higher priority than margin and marginX. */
    marginLeft?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the property `margin-right`. Higher priority than margin and marginX. */
    marginRight?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the property `padding` */
    padding?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the properties `padding-top` and `padding-bottom`. Higher priority than padding. */
    paddingX?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the properties `padding-left` and `padding-right`. Higher priority than padding. */
    paddingY?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the property `padding-top`. Higher priority than padding and paddingY. */
    paddingTop?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the property `padding-bottom`. Higher priority than padding and paddingY. */
    paddingBottom?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the property `padding-left`. Higher priority than padding and paddingX. */
    paddingLeft?: ResponsiveProp<ThemeSpacingTokens>;
    /** Sets the property `padding-right`. Higher priority than padding and paddingX. */
    paddingRight?: ResponsiveProp<ThemeSpacingTokens>;
    borderStyle?: ResponsiveProp<BorderStyle>;
    borderColor?: ResponsiveProp<BorderColor>;
    borderRadius?: ResponsiveProp<BorderRadius>;
    alignItems?: ResponsiveProp<AlignItems>;
    direction?: ResponsiveProp<Direction>;
    justifyContent?: ResponsiveProp<JustifyContent>;
    gap?: ResponsiveProp<ThemeSpacingTokens>;
    backgroundColor?: ResponsiveProp<BackgroundColor>;
    display?: ResponsiveProp<Display>;
    boxShadow?: ResponsiveProp<BoxShadow>;
    /** Sets the HTML element that will be rendered as a Box. Defaults to 'div' */
    element?: ElementType;
    position?: ResponsiveProp<Property.Position>;
}
declare const Box: React$1.ForwardRefExoticComponent<BoxProps & {
    children?: React$1.ReactNode | undefined;
} & React$1.RefAttributes<HTMLElement>>;

interface StackProps extends FlexProps, SizeProps, Omit<React$1.HTMLAttributes<HTMLElement>, 'className' | 'style'> {
    gap?: ResponsiveProp<ThemeSpacingTokens>;
    rowGap?: ResponsiveProp<ThemeSpacingTokens>;
    columnGap?: ResponsiveProp<ThemeSpacingTokens>;
    alignItems?: ResponsiveProp<AlignItems>;
    justifyContent?: ResponsiveProp<JustifyContent>;
    direction?: ResponsiveProp<Direction>;
    wrap?: ResponsiveProp<Wrap>;
    children?: React$1.ReactNode;
}
declare const Stack: React$1.ForwardRefExoticComponent<StackProps & React$1.RefAttributes<HTMLDivElement>>;

interface GridPropsBase extends Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'style'> {
    children: NonNullable<React$1.ReactNode>;
    /** Specifies the gutters between columns and rows. It is overwritten when a column or row gap has a value. */
    gap?: ResponsiveProp<ThemeSpacingTokens>;
    rowGap?: ResponsiveProp<ThemeSpacingTokens>;
    columnGap?: ResponsiveProp<ThemeSpacingTokens>;
    alignItems?: ResponsiveProp<AlignItems>;
}
interface PropsWithColumns extends GridPropsBase {
    /** Number of columns */
    columns?: ResponsiveProp<1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12>;
    minColumnWidth?: never;
}
interface PropsWithMinColumnWidth extends GridPropsBase {
    columns?: never;
    /** For a responsive layout, fit as many columns while maintaining this minimum column width.
     *  The real width will be calculated based on the theme spacing tokens: `theme.spacing(minColumnWidth)`
     */
    minColumnWidth?: ResponsiveProp<1 | 2 | 3 | 5 | 8 | 13 | 21 | 34 | 44 | 55 | 72 | 89 | 144>;
}
/** 'columns' and 'minColumnWidth' are mutually exclusive */
type GridProps = PropsWithColumns | PropsWithMinColumnWidth;
declare const Grid: React$1.ForwardRefExoticComponent<GridProps & React$1.RefAttributes<HTMLDivElement>>;

interface SpaceProps {
    /**
     * The amount of vertical space to use.
     */
    v?: ResponsiveProp<ThemeSpacingTokens>;
    /**
     * The amount of horizontal space to use.
     */
    h?: ResponsiveProp<ThemeSpacingTokens>;
    /**
     * The layout of the space. If set to `inline`, the component will behave like an inline-block element,
     * otherwise it will behave like a block element.
     */
    layout?: 'block' | 'inline';
}
declare const Space: ({ v, h, layout }: SpaceProps) => react_jsx_runtime.JSX.Element;

interface Props$j extends Omit<BoxProps, 'display' | 'direction' | 'element' | 'flex' | 'position'> {
    showScrollIndicators?: boolean;
    onScroll?: UIEventHandler<HTMLDivElement>;
    overflowX?: Property.OverflowX;
    overflowY?: Property.OverflowY;
    scrollbarWidth?: Property.ScrollbarWidth;
}
declare const ScrollContainer: React$1.ForwardRefExoticComponent<Props$j & {
    children?: React$1.ReactNode | undefined;
} & React$1.RefAttributes<HTMLDivElement>>;

interface LabelProps$1 extends React$1.LabelHTMLAttributes<HTMLLabelElement> {
    children: React$1.ReactNode;
    description?: React$1.ReactNode;
    category?: React$1.ReactNode[];
}
declare const Label$1: ({ children, description, className, category, ...labelProps }: LabelProps$1) => react_jsx_runtime.JSX.Element;

interface LabelProps extends React$1.HTMLAttributes<HTMLLegendElement> {
    children: string | ReactNode;
    description?: string;
}
declare const Legend: ({ children, className, ...legendProps }: LabelProps) => react_jsx_runtime.JSX.Element;

interface Props$i extends Omit<HTMLProps<HTMLFieldSetElement>, 'label'> {
    children: React$1.ReactNode[] | React$1.ReactNode;
    /** Label for the fieldset's legend */
    label?: React$1.ReactNode;
}
declare const FieldSet: ({ label, children, className, ...rest }: Props$i) => react_jsx_runtime.JSX.Element;

interface FieldValidationMessageProps {
    /** Override component style */
    className?: string;
    horizontal?: boolean;
}
declare const FieldValidationMessage: ({ children, horizontal, className, }: React$1.PropsWithChildren<FieldValidationMessageProps>) => react_jsx_runtime.JSX.Element;

interface Props$h extends Omit<FieldProps, 'css' | 'horizontal' | 'description' | 'error'> {
    /** Content for the label's tooltip */
    tooltip?: PopoverContent;
    /** Custom width for the label as a multiple of 8px */
    labelWidth?: number | 'auto';
    /** Make the field's child to fill the width of the row. Equivalent to setting `flex-grow:1` on the field */
    grow?: boolean;
    /** Make the field's child shrink with width of the row. Equivalent to setting `flex-shrink:1` on the field */
    shrink?: boolean;
    /** Make field's background transparent */
    transparent?: boolean;
    /** Error message to display */
    error?: ReactNode;
    htmlFor?: string;
    /** Make tooltip interactive */
    interactive?: boolean;
}
declare const InlineField: {
    ({ children, label, tooltip, labelWidth, invalid, loading, disabled, required, className, htmlFor, grow, shrink, error, transparent, interactive, validationMessageHorizontalOverflow, ...htmlProps }: Props$h): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface Props$g {
    grow?: boolean;
    className?: string;
}
/** @beta */
declare const InlineSegmentGroup: {
    ({ children, className, grow, ...htmlProps }: React$1.PropsWithChildren<Props$g>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface Props$f extends Omit<LabelProps$1, 'css' | 'description' | 'category'> {
    /** Content for the labels tooltip. If provided, an info icon with the tooltip content
     * will be displayed */
    tooltip?: PopoverContent;
    /** Custom width for the label */
    width?: number | 'auto';
    /** Make labels's background transparent */
    transparent?: boolean;
    /** Make tooltip interactive */
    interactive?: boolean;
    /** @beta */
    /** Controls which element the InlineLabel should be rendered into */
    as?: React$1.ElementType;
}
declare const InlineLabel: ({ children, className, tooltip, width, transparent, interactive, as: Component, ...rest }: Props$f) => react_jsx_runtime.JSX.Element;

interface Props$e extends Omit<HTMLProps<HTMLDivElement>, 'css'> {
    children: ReactNode | ReactNode[];
}
declare const InlineFieldRow: ({ children, className, ...htmlProps }: Props$e) => react_jsx_runtime.JSX.Element;

interface FieldArrayProps extends UseFieldArrayProps {
    children: (api: FieldArrayApi) => JSX.Element;
}
/**
 * @deprecated use the `useFieldArray` hook from react-hook-form instead
 */
declare const FieldArray: FC<FieldArrayProps>;

declare function resetSelectStyles(theme: GrafanaTheme2): {
    clearIndicator: () => {};
    container: () => {};
    control: () => {};
    dropdownIndicator: () => {};
    group: () => {};
    groupHeading: () => {};
    indicatorsContainer: () => {};
    indicatorSeparator: () => {};
    input: (originalStyles: CSSObjectWithLabel) => {
        color: string;
        margin: number;
        padding: number;
        zIndex: number;
        overflow: string;
        accentColor?: readonly string[] | csstype.Property.AccentColor | readonly csstype.Property.AccentColor[] | undefined;
        alignContent?: readonly string[] | csstype.Property.AlignContent | readonly csstype.Property.AlignContent[] | undefined;
        alignItems?: readonly string[] | csstype.Property.AlignItems | readonly csstype.Property.AlignItems[] | undefined;
        alignSelf?: readonly string[] | csstype.Property.AlignSelf | readonly csstype.Property.AlignSelf[] | undefined;
        alignTracks?: readonly string[] | csstype.Property.AlignTracks | readonly csstype.Property.AlignTracks[] | undefined;
        animationComposition?: readonly string[] | csstype.Property.AnimationComposition | readonly csstype.Property.AnimationComposition[] | undefined;
        animationDelay?: readonly string[] | csstype.Property.AnimationDelay<string & {}> | readonly csstype.Property.AnimationDelay<string & {}>[] | undefined;
        animationDirection?: readonly string[] | csstype.Property.AnimationDirection | readonly csstype.Property.AnimationDirection[] | undefined;
        animationDuration?: readonly string[] | csstype.Property.AnimationDuration<string & {}> | readonly csstype.Property.AnimationDuration<string & {}>[] | undefined;
        animationFillMode?: readonly string[] | csstype.Property.AnimationFillMode | readonly csstype.Property.AnimationFillMode[] | undefined;
        animationIterationCount?: csstype.Property.AnimationIterationCount | readonly NonNullable<csstype.Property.AnimationIterationCount | undefined>[] | readonly ((string & {}) | csstype.Globals | "infinite")[] | undefined;
        animationName?: readonly string[] | csstype.Property.AnimationName | readonly csstype.Property.AnimationName[] | undefined;
        animationPlayState?: readonly string[] | csstype.Property.AnimationPlayState | readonly csstype.Property.AnimationPlayState[] | undefined;
        animationRangeEnd?: readonly (string | (string & {}))[] | csstype.Property.AnimationRangeEnd<string | number> | readonly NonNullable<csstype.Property.AnimationRangeEnd<string | number> | undefined>[] | undefined;
        animationRangeStart?: readonly (string | (string & {}))[] | csstype.Property.AnimationRangeStart<string | number> | readonly NonNullable<csstype.Property.AnimationRangeStart<string | number> | undefined>[] | undefined;
        animationTimeline?: readonly string[] | csstype.Property.AnimationTimeline | readonly csstype.Property.AnimationTimeline[] | undefined;
        animationTimingFunction?: readonly string[] | csstype.Property.AnimationTimingFunction | readonly csstype.Property.AnimationTimingFunction[] | undefined;
        appearance?: csstype.Property.Appearance | readonly NonNullable<csstype.Property.Appearance | undefined>[] | readonly csstype.Property.Appearance[] | undefined;
        aspectRatio?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.AspectRatio | readonly NonNullable<csstype.Property.AspectRatio | undefined>[] | undefined;
        backdropFilter?: readonly string[] | csstype.Property.BackdropFilter | readonly csstype.Property.BackdropFilter[] | undefined;
        backfaceVisibility?: csstype.Property.BackfaceVisibility | readonly NonNullable<csstype.Property.BackfaceVisibility | undefined>[] | readonly csstype.Property.BackfaceVisibility[] | undefined;
        backgroundAttachment?: readonly string[] | csstype.Property.BackgroundAttachment | readonly csstype.Property.BackgroundAttachment[] | undefined;
        backgroundBlendMode?: readonly string[] | csstype.Property.BackgroundBlendMode | readonly csstype.Property.BackgroundBlendMode[] | undefined;
        backgroundClip?: readonly string[] | csstype.Property.BackgroundClip | readonly csstype.Property.BackgroundClip[] | undefined;
        backgroundColor?: readonly string[] | csstype.Property.BackgroundColor | readonly csstype.Property.BackgroundColor[] | undefined;
        backgroundImage?: readonly string[] | csstype.Property.BackgroundImage | readonly csstype.Property.BackgroundImage[] | undefined;
        backgroundOrigin?: readonly string[] | csstype.Property.BackgroundOrigin | readonly csstype.Property.BackgroundOrigin[] | undefined;
        backgroundPositionX?: readonly (string | (string & {}))[] | csstype.Property.BackgroundPositionX<string | number> | readonly NonNullable<csstype.Property.BackgroundPositionX<string | number> | undefined>[] | undefined;
        backgroundPositionY?: readonly (string | (string & {}))[] | csstype.Property.BackgroundPositionY<string | number> | readonly NonNullable<csstype.Property.BackgroundPositionY<string | number> | undefined>[] | undefined;
        backgroundRepeat?: readonly string[] | csstype.Property.BackgroundRepeat | readonly csstype.Property.BackgroundRepeat[] | undefined;
        backgroundSize?: readonly (string | (string & {}))[] | csstype.Property.BackgroundSize<string | number> | readonly NonNullable<csstype.Property.BackgroundSize<string | number> | undefined>[] | undefined;
        blockOverflow?: readonly string[] | csstype.Property.BlockOverflow | readonly csstype.Property.BlockOverflow[] | undefined;
        blockSize?: readonly (string | (string & {}))[] | csstype.Property.BlockSize<string | number> | readonly NonNullable<csstype.Property.BlockSize<string | number> | undefined>[] | undefined;
        borderBlockColor?: readonly string[] | csstype.Property.BorderBlockColor | readonly csstype.Property.BorderBlockColor[] | undefined;
        borderBlockEndColor?: readonly string[] | csstype.Property.BorderBlockEndColor | readonly csstype.Property.BorderBlockEndColor[] | undefined;
        borderBlockEndStyle?: csstype.Property.BorderBlockEndStyle | readonly NonNullable<csstype.Property.BorderBlockEndStyle | undefined>[] | readonly csstype.Property.BorderBlockEndStyle[] | undefined;
        borderBlockEndWidth?: readonly string[] | csstype.Property.BorderBlockEndWidth<string | number> | readonly NonNullable<csstype.Property.BorderBlockEndWidth<string | number> | undefined>[] | undefined;
        borderBlockStartColor?: readonly string[] | csstype.Property.BorderBlockStartColor | readonly csstype.Property.BorderBlockStartColor[] | undefined;
        borderBlockStartStyle?: csstype.Property.BorderBlockStartStyle | readonly NonNullable<csstype.Property.BorderBlockStartStyle | undefined>[] | readonly csstype.Property.BorderBlockStartStyle[] | undefined;
        borderBlockStartWidth?: readonly string[] | csstype.Property.BorderBlockStartWidth<string | number> | readonly NonNullable<csstype.Property.BorderBlockStartWidth<string | number> | undefined>[] | undefined;
        borderBlockStyle?: csstype.Property.BorderBlockStyle | readonly NonNullable<csstype.Property.BorderBlockStyle | undefined>[] | readonly csstype.Property.BorderBlockStyle[] | undefined;
        borderBlockWidth?: readonly string[] | csstype.Property.BorderBlockWidth<string | number> | readonly NonNullable<csstype.Property.BorderBlockWidth<string | number> | undefined>[] | undefined;
        borderBottomColor?: readonly string[] | csstype.Property.BorderBottomColor | readonly csstype.Property.BorderBottomColor[] | undefined;
        borderBottomLeftRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomLeftRadius<string | number> | undefined>[] | undefined;
        borderBottomRightRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomRightRadius<string | number> | undefined>[] | undefined;
        borderBottomStyle?: csstype.Property.BorderBottomStyle | readonly NonNullable<csstype.Property.BorderBottomStyle | undefined>[] | readonly csstype.Property.BorderBottomStyle[] | undefined;
        borderBottomWidth?: readonly string[] | csstype.Property.BorderBottomWidth<string | number> | readonly NonNullable<csstype.Property.BorderBottomWidth<string | number> | undefined>[] | undefined;
        borderCollapse?: csstype.Property.BorderCollapse | readonly NonNullable<csstype.Property.BorderCollapse | undefined>[] | readonly csstype.Property.BorderCollapse[] | undefined;
        borderEndEndRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderEndEndRadius<string | number> | readonly NonNullable<csstype.Property.BorderEndEndRadius<string | number> | undefined>[] | undefined;
        borderEndStartRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderEndStartRadius<string | number> | readonly NonNullable<csstype.Property.BorderEndStartRadius<string | number> | undefined>[] | undefined;
        borderImageOutset?: readonly (string | (string & {}))[] | csstype.Property.BorderImageOutset<string | number> | readonly NonNullable<csstype.Property.BorderImageOutset<string | number> | undefined>[] | undefined;
        borderImageRepeat?: readonly string[] | csstype.Property.BorderImageRepeat | readonly csstype.Property.BorderImageRepeat[] | undefined;
        borderImageSlice?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BorderImageSlice | readonly NonNullable<csstype.Property.BorderImageSlice | undefined>[] | undefined;
        borderImageSource?: readonly string[] | csstype.Property.BorderImageSource | readonly csstype.Property.BorderImageSource[] | undefined;
        borderImageWidth?: readonly (string | (string & {}))[] | csstype.Property.BorderImageWidth<string | number> | readonly NonNullable<csstype.Property.BorderImageWidth<string | number> | undefined>[] | undefined;
        borderInlineColor?: readonly string[] | csstype.Property.BorderInlineColor | readonly csstype.Property.BorderInlineColor[] | undefined;
        borderInlineEndColor?: readonly string[] | csstype.Property.BorderInlineEndColor | readonly csstype.Property.BorderInlineEndColor[] | undefined;
        borderInlineEndStyle?: csstype.Property.BorderInlineEndStyle | readonly NonNullable<csstype.Property.BorderInlineEndStyle | undefined>[] | readonly csstype.Property.BorderInlineEndStyle[] | undefined;
        borderInlineEndWidth?: readonly string[] | csstype.Property.BorderInlineEndWidth<string | number> | readonly NonNullable<csstype.Property.BorderInlineEndWidth<string | number> | undefined>[] | undefined;
        borderInlineStartColor?: readonly string[] | csstype.Property.BorderInlineStartColor | readonly csstype.Property.BorderInlineStartColor[] | undefined;
        borderInlineStartStyle?: csstype.Property.BorderInlineStartStyle | readonly NonNullable<csstype.Property.BorderInlineStartStyle | undefined>[] | readonly csstype.Property.BorderInlineStartStyle[] | undefined;
        borderInlineStartWidth?: readonly string[] | csstype.Property.BorderInlineStartWidth<string | number> | readonly NonNullable<csstype.Property.BorderInlineStartWidth<string | number> | undefined>[] | undefined;
        borderInlineStyle?: csstype.Property.BorderInlineStyle | readonly NonNullable<csstype.Property.BorderInlineStyle | undefined>[] | readonly csstype.Property.BorderInlineStyle[] | undefined;
        borderInlineWidth?: readonly string[] | csstype.Property.BorderInlineWidth<string | number> | readonly NonNullable<csstype.Property.BorderInlineWidth<string | number> | undefined>[] | undefined;
        borderLeftColor?: readonly string[] | csstype.Property.BorderLeftColor | readonly csstype.Property.BorderLeftColor[] | undefined;
        borderLeftStyle?: csstype.Property.BorderLeftStyle | readonly NonNullable<csstype.Property.BorderLeftStyle | undefined>[] | readonly csstype.Property.BorderLeftStyle[] | undefined;
        borderLeftWidth?: readonly string[] | csstype.Property.BorderLeftWidth<string | number> | readonly NonNullable<csstype.Property.BorderLeftWidth<string | number> | undefined>[] | undefined;
        borderRightColor?: readonly string[] | csstype.Property.BorderRightColor | readonly csstype.Property.BorderRightColor[] | undefined;
        borderRightStyle?: csstype.Property.BorderRightStyle | readonly NonNullable<csstype.Property.BorderRightStyle | undefined>[] | readonly csstype.Property.BorderRightStyle[] | undefined;
        borderRightWidth?: readonly string[] | csstype.Property.BorderRightWidth<string | number> | readonly NonNullable<csstype.Property.BorderRightWidth<string | number> | undefined>[] | undefined;
        borderSpacing?: readonly (string | (string & {}))[] | csstype.Property.BorderSpacing<string | number> | readonly NonNullable<csstype.Property.BorderSpacing<string | number> | undefined>[] | undefined;
        borderStartEndRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderStartEndRadius<string | number> | readonly NonNullable<csstype.Property.BorderStartEndRadius<string | number> | undefined>[] | undefined;
        borderStartStartRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderStartStartRadius<string | number> | readonly NonNullable<csstype.Property.BorderStartStartRadius<string | number> | undefined>[] | undefined;
        borderTopColor?: readonly string[] | csstype.Property.BorderTopColor | readonly csstype.Property.BorderTopColor[] | undefined;
        borderTopLeftRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderTopLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopLeftRadius<string | number> | undefined>[] | undefined;
        borderTopRightRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderTopRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopRightRadius<string | number> | undefined>[] | undefined;
        borderTopStyle?: csstype.Property.BorderTopStyle | readonly NonNullable<csstype.Property.BorderTopStyle | undefined>[] | readonly csstype.Property.BorderTopStyle[] | undefined;
        borderTopWidth?: readonly string[] | csstype.Property.BorderTopWidth<string | number> | readonly NonNullable<csstype.Property.BorderTopWidth<string | number> | undefined>[] | undefined;
        bottom?: readonly (string | (string & {}))[] | csstype.Property.Bottom<string | number> | readonly NonNullable<csstype.Property.Bottom<string | number> | undefined>[] | undefined;
        boxDecorationBreak?: csstype.Property.BoxDecorationBreak | readonly NonNullable<csstype.Property.BoxDecorationBreak | undefined>[] | readonly csstype.Property.BoxDecorationBreak[] | undefined;
        boxShadow?: readonly string[] | csstype.Property.BoxShadow | readonly csstype.Property.BoxShadow[] | undefined;
        boxSizing?: csstype.Property.BoxSizing | readonly NonNullable<csstype.Property.BoxSizing | undefined>[] | readonly csstype.Property.BoxSizing[] | undefined;
        breakAfter?: csstype.Property.BreakAfter | readonly NonNullable<csstype.Property.BreakAfter | undefined>[] | readonly csstype.Property.BreakAfter[] | undefined;
        breakBefore?: csstype.Property.BreakBefore | readonly NonNullable<csstype.Property.BreakBefore | undefined>[] | readonly csstype.Property.BreakBefore[] | undefined;
        breakInside?: csstype.Property.BreakInside | readonly NonNullable<csstype.Property.BreakInside | undefined>[] | readonly csstype.Property.BreakInside[] | undefined;
        captionSide?: csstype.Property.CaptionSide | readonly NonNullable<csstype.Property.CaptionSide | undefined>[] | readonly csstype.Property.CaptionSide[] | undefined;
        caretColor?: readonly string[] | csstype.Property.CaretColor | readonly csstype.Property.CaretColor[] | undefined;
        caretShape?: csstype.Property.CaretShape | readonly NonNullable<csstype.Property.CaretShape | undefined>[] | readonly csstype.Property.CaretShape[] | undefined;
        clear?: csstype.Property.Clear | readonly NonNullable<csstype.Property.Clear | undefined>[] | readonly csstype.Property.Clear[] | undefined;
        clipPath?: readonly string[] | csstype.Property.ClipPath | readonly csstype.Property.ClipPath[] | undefined;
        colorAdjust?: csstype.Property.PrintColorAdjust | readonly NonNullable<csstype.Property.PrintColorAdjust | undefined>[] | readonly csstype.Property.PrintColorAdjust[] | undefined;
        colorScheme?: readonly string[] | csstype.Property.ColorScheme | readonly csstype.Property.ColorScheme[] | undefined;
        columnCount?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.ColumnCount | readonly NonNullable<csstype.Property.ColumnCount | undefined>[] | undefined;
        columnFill?: csstype.Property.ColumnFill | readonly NonNullable<csstype.Property.ColumnFill | undefined>[] | readonly csstype.Property.ColumnFill[] | undefined;
        columnGap?: readonly (string | (string & {}))[] | csstype.Property.ColumnGap<string | number> | readonly NonNullable<csstype.Property.ColumnGap<string | number> | undefined>[] | undefined;
        columnRuleColor?: readonly string[] | csstype.Property.ColumnRuleColor | readonly csstype.Property.ColumnRuleColor[] | undefined;
        columnRuleStyle?: readonly string[] | csstype.Property.ColumnRuleStyle | readonly csstype.Property.ColumnRuleStyle[] | undefined;
        columnRuleWidth?: readonly (string | (string & {}))[] | csstype.Property.ColumnRuleWidth<string | number> | readonly NonNullable<csstype.Property.ColumnRuleWidth<string | number> | undefined>[] | undefined;
        columnSpan?: csstype.Property.ColumnSpan | readonly NonNullable<csstype.Property.ColumnSpan | undefined>[] | readonly csstype.Property.ColumnSpan[] | undefined;
        columnWidth?: readonly string[] | csstype.Property.ColumnWidth<string | number> | readonly NonNullable<csstype.Property.ColumnWidth<string | number> | undefined>[] | undefined;
        contain?: readonly string[] | csstype.Property.Contain | readonly csstype.Property.Contain[] | undefined;
        containIntrinsicBlockSize?: readonly (string | (string & {}))[] | csstype.Property.ContainIntrinsicBlockSize<string | number> | readonly NonNullable<csstype.Property.ContainIntrinsicBlockSize<string | number> | undefined>[] | undefined;
        containIntrinsicHeight?: readonly (string | (string & {}))[] | csstype.Property.ContainIntrinsicHeight<string | number> | readonly NonNullable<csstype.Property.ContainIntrinsicHeight<string | number> | undefined>[] | undefined;
        containIntrinsicInlineSize?: readonly (string | (string & {}))[] | csstype.Property.ContainIntrinsicInlineSize<string | number> | readonly NonNullable<csstype.Property.ContainIntrinsicInlineSize<string | number> | undefined>[] | undefined;
        containIntrinsicWidth?: readonly (string | (string & {}))[] | csstype.Property.ContainIntrinsicWidth<string | number> | readonly NonNullable<csstype.Property.ContainIntrinsicWidth<string | number> | undefined>[] | undefined;
        containerName?: readonly string[] | csstype.Property.ContainerName | readonly csstype.Property.ContainerName[] | undefined;
        containerType?: csstype.Property.ContainerType | readonly NonNullable<csstype.Property.ContainerType | undefined>[] | readonly csstype.Property.ContainerType[] | undefined;
        content?: readonly string[] | csstype.Property.Content | readonly csstype.Property.Content[] | undefined;
        contentVisibility?: csstype.Property.ContentVisibility | readonly NonNullable<csstype.Property.ContentVisibility | undefined>[] | readonly csstype.Property.ContentVisibility[] | undefined;
        counterIncrement?: readonly string[] | csstype.Property.CounterIncrement | readonly csstype.Property.CounterIncrement[] | undefined;
        counterReset?: readonly string[] | csstype.Property.CounterReset | readonly csstype.Property.CounterReset[] | undefined;
        counterSet?: readonly string[] | csstype.Property.CounterSet | readonly csstype.Property.CounterSet[] | undefined;
        cursor?: readonly string[] | csstype.Property.Cursor | readonly csstype.Property.Cursor[] | undefined;
        direction?: csstype.Property.Direction | readonly NonNullable<csstype.Property.Direction | undefined>[] | readonly csstype.Property.Direction[] | undefined;
        display?: readonly string[] | csstype.Property.Display | readonly csstype.Property.Display[] | undefined;
        emptyCells?: csstype.Property.EmptyCells | readonly NonNullable<csstype.Property.EmptyCells | undefined>[] | readonly csstype.Property.EmptyCells[] | undefined;
        filter?: readonly string[] | csstype.Property.Filter | readonly csstype.Property.Filter[] | undefined;
        flexBasis?: readonly (string | (string & {}))[] | csstype.Property.FlexBasis<string | number> | readonly NonNullable<csstype.Property.FlexBasis<string | number> | undefined>[] | undefined;
        flexDirection?: csstype.Property.FlexDirection | readonly NonNullable<csstype.Property.FlexDirection | undefined>[] | readonly csstype.Property.FlexDirection[] | undefined;
        flexGrow?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.FlexGrow | readonly NonNullable<csstype.Property.FlexGrow | undefined>[] | undefined;
        flexShrink?: csstype.Property.FlexShrink | readonly NonNullable<csstype.Property.FlexShrink | undefined>[] | readonly ((string & {}) | csstype.Globals)[] | undefined;
        flexWrap?: csstype.Property.FlexWrap | readonly NonNullable<csstype.Property.FlexWrap | undefined>[] | readonly csstype.Property.FlexWrap[] | undefined;
        float?: csstype.Property.Float | readonly NonNullable<csstype.Property.Float | undefined>[] | readonly csstype.Property.Float[] | undefined;
        fontFamily?: readonly string[] | csstype.Property.FontFamily | readonly csstype.Property.FontFamily[] | undefined;
        fontFeatureSettings?: readonly string[] | csstype.Property.FontFeatureSettings | readonly csstype.Property.FontFeatureSettings[] | undefined;
        fontKerning?: csstype.Property.FontKerning | readonly NonNullable<csstype.Property.FontKerning | undefined>[] | readonly csstype.Property.FontKerning[] | undefined;
        fontLanguageOverride?: readonly string[] | csstype.Property.FontLanguageOverride | readonly csstype.Property.FontLanguageOverride[] | undefined;
        fontOpticalSizing?: csstype.Property.FontOpticalSizing | readonly NonNullable<csstype.Property.FontOpticalSizing | undefined>[] | readonly csstype.Property.FontOpticalSizing[] | undefined;
        fontPalette?: readonly string[] | csstype.Property.FontPalette | readonly csstype.Property.FontPalette[] | undefined;
        fontSize?: readonly (string | (string & {}))[] | csstype.Property.FontSize<string | number> | readonly NonNullable<csstype.Property.FontSize<string | number> | undefined>[] | undefined;
        fontSizeAdjust?: csstype.Property.FontSizeAdjust | readonly NonNullable<csstype.Property.FontSizeAdjust | undefined>[] | readonly ("none" | (string & {}) | csstype.Globals | "from-font")[] | undefined;
        fontSmooth?: readonly string[] | csstype.Property.FontSmooth<string | number> | readonly NonNullable<csstype.Property.FontSmooth<string | number> | undefined>[] | undefined;
        fontStretch?: readonly string[] | csstype.Property.FontStretch | readonly csstype.Property.FontStretch[] | undefined;
        fontStyle?: readonly string[] | csstype.Property.FontStyle | readonly csstype.Property.FontStyle[] | undefined;
        fontSynthesis?: readonly string[] | csstype.Property.FontSynthesis | readonly csstype.Property.FontSynthesis[] | undefined;
        fontSynthesisPosition?: csstype.Property.FontSynthesisPosition | readonly NonNullable<csstype.Property.FontSynthesisPosition | undefined>[] | readonly csstype.Property.FontSynthesisPosition[] | undefined;
        fontSynthesisSmallCaps?: csstype.Property.FontSynthesisSmallCaps | readonly NonNullable<csstype.Property.FontSynthesisSmallCaps | undefined>[] | readonly csstype.Property.FontSynthesisSmallCaps[] | undefined;
        fontSynthesisStyle?: csstype.Property.FontSynthesisStyle | readonly NonNullable<csstype.Property.FontSynthesisStyle | undefined>[] | readonly csstype.Property.FontSynthesisStyle[] | undefined;
        fontSynthesisWeight?: csstype.Property.FontSynthesisWeight | readonly NonNullable<csstype.Property.FontSynthesisWeight | undefined>[] | readonly csstype.Property.FontSynthesisWeight[] | undefined;
        fontVariant?: readonly string[] | csstype.Property.FontVariant | readonly csstype.Property.FontVariant[] | undefined;
        fontVariantAlternates?: readonly string[] | csstype.Property.FontVariantAlternates | readonly csstype.Property.FontVariantAlternates[] | undefined;
        fontVariantCaps?: csstype.Property.FontVariantCaps | readonly NonNullable<csstype.Property.FontVariantCaps | undefined>[] | readonly csstype.Property.FontVariantCaps[] | undefined;
        fontVariantEastAsian?: readonly string[] | csstype.Property.FontVariantEastAsian | readonly csstype.Property.FontVariantEastAsian[] | undefined;
        fontVariantEmoji?: csstype.Property.FontVariantEmoji | readonly NonNullable<csstype.Property.FontVariantEmoji | undefined>[] | readonly csstype.Property.FontVariantEmoji[] | undefined;
        fontVariantLigatures?: readonly string[] | csstype.Property.FontVariantLigatures | readonly csstype.Property.FontVariantLigatures[] | undefined;
        fontVariantNumeric?: readonly string[] | csstype.Property.FontVariantNumeric | readonly csstype.Property.FontVariantNumeric[] | undefined;
        fontVariantPosition?: csstype.Property.FontVariantPosition | readonly NonNullable<csstype.Property.FontVariantPosition | undefined>[] | readonly csstype.Property.FontVariantPosition[] | undefined;
        fontVariationSettings?: readonly string[] | csstype.Property.FontVariationSettings | readonly csstype.Property.FontVariationSettings[] | undefined;
        fontWeight?: csstype.Property.FontWeight | readonly NonNullable<csstype.Property.FontWeight | undefined>[] | readonly ("normal" | "bold" | (string & {}) | csstype.Globals | "bolder" | "lighter")[] | undefined;
        forcedColorAdjust?: csstype.Property.ForcedColorAdjust | readonly NonNullable<csstype.Property.ForcedColorAdjust | undefined>[] | readonly csstype.Property.ForcedColorAdjust[] | undefined;
        gridAutoColumns?: readonly (string | (string & {}))[] | csstype.Property.GridAutoColumns<string | number> | readonly NonNullable<csstype.Property.GridAutoColumns<string | number> | undefined>[] | undefined;
        gridAutoFlow?: readonly string[] | csstype.Property.GridAutoFlow | readonly csstype.Property.GridAutoFlow[] | undefined;
        gridAutoRows?: readonly (string | (string & {}))[] | csstype.Property.GridAutoRows<string | number> | readonly NonNullable<csstype.Property.GridAutoRows<string | number> | undefined>[] | undefined;
        gridColumnEnd?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridColumnEnd | readonly NonNullable<csstype.Property.GridColumnEnd | undefined>[] | undefined;
        gridColumnStart?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridColumnStart | readonly NonNullable<csstype.Property.GridColumnStart | undefined>[] | undefined;
        gridRowEnd?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridRowEnd | readonly NonNullable<csstype.Property.GridRowEnd | undefined>[] | undefined;
        gridRowStart?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridRowStart | readonly NonNullable<csstype.Property.GridRowStart | undefined>[] | undefined;
        gridTemplateAreas?: readonly string[] | csstype.Property.GridTemplateAreas | readonly csstype.Property.GridTemplateAreas[] | undefined;
        gridTemplateColumns?: readonly (string | (string & {}))[] | csstype.Property.GridTemplateColumns<string | number> | readonly NonNullable<csstype.Property.GridTemplateColumns<string | number> | undefined>[] | undefined;
        gridTemplateRows?: readonly (string | (string & {}))[] | csstype.Property.GridTemplateRows<string | number> | readonly NonNullable<csstype.Property.GridTemplateRows<string | number> | undefined>[] | undefined;
        hangingPunctuation?: readonly string[] | csstype.Property.HangingPunctuation | readonly csstype.Property.HangingPunctuation[] | undefined;
        height?: readonly (string | (string & {}))[] | csstype.Property.Height<string | number> | readonly NonNullable<csstype.Property.Height<string | number> | undefined>[] | undefined;
        hyphenateCharacter?: readonly string[] | csstype.Property.HyphenateCharacter | readonly csstype.Property.HyphenateCharacter[] | undefined;
        hyphenateLimitChars?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.HyphenateLimitChars | readonly NonNullable<csstype.Property.HyphenateLimitChars | undefined>[] | undefined;
        hyphens?: csstype.Property.Hyphens | readonly NonNullable<csstype.Property.Hyphens | undefined>[] | readonly csstype.Property.Hyphens[] | undefined;
        imageOrientation?: readonly string[] | csstype.Property.ImageOrientation | readonly csstype.Property.ImageOrientation[] | undefined;
        imageRendering?: csstype.Property.ImageRendering | readonly NonNullable<csstype.Property.ImageRendering | undefined>[] | readonly csstype.Property.ImageRendering[] | undefined;
        imageResolution?: readonly string[] | csstype.Property.ImageResolution | readonly csstype.Property.ImageResolution[] | undefined;
        initialLetter?: csstype.Property.InitialLetter | readonly NonNullable<csstype.Property.InitialLetter | undefined>[] | readonly ("normal" | (string & {}) | csstype.Globals)[] | undefined;
        inlineSize?: readonly (string | (string & {}))[] | csstype.Property.InlineSize<string | number> | readonly NonNullable<csstype.Property.InlineSize<string | number> | undefined>[] | undefined;
        inputSecurity?: csstype.Property.InputSecurity | readonly NonNullable<csstype.Property.InputSecurity | undefined>[] | readonly csstype.Property.InputSecurity[] | undefined;
        insetBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.InsetBlockEnd<string | number> | readonly NonNullable<csstype.Property.InsetBlockEnd<string | number> | undefined>[] | undefined;
        insetBlockStart?: readonly (string | (string & {}))[] | csstype.Property.InsetBlockStart<string | number> | readonly NonNullable<csstype.Property.InsetBlockStart<string | number> | undefined>[] | undefined;
        insetInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.InsetInlineEnd<string | number> | readonly NonNullable<csstype.Property.InsetInlineEnd<string | number> | undefined>[] | undefined;
        insetInlineStart?: readonly (string | (string & {}))[] | csstype.Property.InsetInlineStart<string | number> | readonly NonNullable<csstype.Property.InsetInlineStart<string | number> | undefined>[] | undefined;
        isolation?: csstype.Property.Isolation | readonly NonNullable<csstype.Property.Isolation | undefined>[] | readonly csstype.Property.Isolation[] | undefined;
        justifyContent?: readonly string[] | csstype.Property.JustifyContent | readonly csstype.Property.JustifyContent[] | undefined;
        justifyItems?: readonly string[] | csstype.Property.JustifyItems | readonly csstype.Property.JustifyItems[] | undefined;
        justifySelf?: readonly string[] | csstype.Property.JustifySelf | readonly csstype.Property.JustifySelf[] | undefined;
        justifyTracks?: readonly string[] | csstype.Property.JustifyTracks | readonly csstype.Property.JustifyTracks[] | undefined;
        left?: readonly (string | (string & {}))[] | csstype.Property.Left<string | number> | readonly NonNullable<csstype.Property.Left<string | number> | undefined>[] | undefined;
        letterSpacing?: readonly string[] | csstype.Property.LetterSpacing<string | number> | readonly NonNullable<csstype.Property.LetterSpacing<string | number> | undefined>[] | undefined;
        lineBreak?: csstype.Property.LineBreak | readonly NonNullable<csstype.Property.LineBreak | undefined>[] | readonly csstype.Property.LineBreak[] | undefined;
        lineHeight?: csstype.Property.LineHeight<string | number> | readonly NonNullable<csstype.Property.LineHeight<string | number> | undefined>[] | readonly (string | (string & {}))[] | undefined;
        lineHeightStep?: readonly string[] | csstype.Property.LineHeightStep<string | number> | readonly NonNullable<csstype.Property.LineHeightStep<string | number> | undefined>[] | undefined;
        listStyleImage?: readonly string[] | csstype.Property.ListStyleImage | readonly csstype.Property.ListStyleImage[] | undefined;
        listStylePosition?: csstype.Property.ListStylePosition | readonly NonNullable<csstype.Property.ListStylePosition | undefined>[] | readonly csstype.Property.ListStylePosition[] | undefined;
        listStyleType?: readonly string[] | csstype.Property.ListStyleType | readonly csstype.Property.ListStyleType[] | undefined;
        marginBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.MarginBlockEnd<string | number> | readonly NonNullable<csstype.Property.MarginBlockEnd<string | number> | undefined>[] | undefined;
        marginBlockStart?: readonly (string | (string & {}))[] | csstype.Property.MarginBlockStart<string | number> | readonly NonNullable<csstype.Property.MarginBlockStart<string | number> | undefined>[] | undefined;
        marginBottom?: readonly (string | (string & {}))[] | csstype.Property.MarginBottom<string | number> | readonly NonNullable<csstype.Property.MarginBottom<string | number> | undefined>[] | undefined;
        marginInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineEnd<string | number> | readonly NonNullable<csstype.Property.MarginInlineEnd<string | number> | undefined>[] | undefined;
        marginInlineStart?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineStart<string | number> | readonly NonNullable<csstype.Property.MarginInlineStart<string | number> | undefined>[] | undefined;
        marginLeft?: readonly (string | (string & {}))[] | csstype.Property.MarginLeft<string | number> | readonly NonNullable<csstype.Property.MarginLeft<string | number> | undefined>[] | undefined;
        marginRight?: readonly (string | (string & {}))[] | csstype.Property.MarginRight<string | number> | readonly NonNullable<csstype.Property.MarginRight<string | number> | undefined>[] | undefined;
        marginTop?: readonly (string | (string & {}))[] | csstype.Property.MarginTop<string | number> | readonly NonNullable<csstype.Property.MarginTop<string | number> | undefined>[] | undefined;
        marginTrim?: csstype.Property.MarginTrim | readonly NonNullable<csstype.Property.MarginTrim | undefined>[] | readonly csstype.Property.MarginTrim[] | undefined;
        maskBorderMode?: csstype.Property.MaskBorderMode | readonly NonNullable<csstype.Property.MaskBorderMode | undefined>[] | readonly csstype.Property.MaskBorderMode[] | undefined;
        maskBorderOutset?: readonly (string | (string & {}))[] | csstype.Property.MaskBorderOutset<string | number> | readonly NonNullable<csstype.Property.MaskBorderOutset<string | number> | undefined>[] | undefined;
        maskBorderRepeat?: readonly string[] | csstype.Property.MaskBorderRepeat | readonly csstype.Property.MaskBorderRepeat[] | undefined;
        maskBorderSlice?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.MaskBorderSlice | readonly NonNullable<csstype.Property.MaskBorderSlice | undefined>[] | undefined;
        maskBorderSource?: readonly string[] | csstype.Property.MaskBorderSource | readonly csstype.Property.MaskBorderSource[] | undefined;
        maskBorderWidth?: readonly (string | (string & {}))[] | csstype.Property.MaskBorderWidth<string | number> | readonly NonNullable<csstype.Property.MaskBorderWidth<string | number> | undefined>[] | undefined;
        maskClip?: readonly string[] | csstype.Property.MaskClip | readonly csstype.Property.MaskClip[] | undefined;
        maskComposite?: readonly string[] | csstype.Property.MaskComposite | readonly csstype.Property.MaskComposite[] | undefined;
        maskImage?: readonly string[] | csstype.Property.MaskImage | readonly csstype.Property.MaskImage[] | undefined;
        maskMode?: readonly string[] | csstype.Property.MaskMode | readonly csstype.Property.MaskMode[] | undefined;
        maskOrigin?: readonly string[] | csstype.Property.MaskOrigin | readonly csstype.Property.MaskOrigin[] | undefined;
        maskPosition?: readonly (string | (string & {}))[] | csstype.Property.MaskPosition<string | number> | readonly NonNullable<csstype.Property.MaskPosition<string | number> | undefined>[] | undefined;
        maskRepeat?: readonly string[] | csstype.Property.MaskRepeat | readonly csstype.Property.MaskRepeat[] | undefined;
        maskSize?: readonly (string | (string & {}))[] | csstype.Property.MaskSize<string | number> | readonly NonNullable<csstype.Property.MaskSize<string | number> | undefined>[] | undefined;
        maskType?: csstype.Property.MaskType | readonly NonNullable<csstype.Property.MaskType | undefined>[] | readonly csstype.Property.MaskType[] | undefined;
        masonryAutoFlow?: readonly string[] | csstype.Property.MasonryAutoFlow | readonly csstype.Property.MasonryAutoFlow[] | undefined;
        mathDepth?: csstype.Property.MathDepth | readonly NonNullable<csstype.Property.MathDepth | undefined>[] | readonly ((string & {}) | csstype.Globals | "auto-add")[] | undefined;
        mathShift?: csstype.Property.MathShift | readonly NonNullable<csstype.Property.MathShift | undefined>[] | readonly csstype.Property.MathShift[] | undefined;
        mathStyle?: csstype.Property.MathStyle | readonly NonNullable<csstype.Property.MathStyle | undefined>[] | readonly csstype.Property.MathStyle[] | undefined;
        maxBlockSize?: readonly (string | (string & {}))[] | csstype.Property.MaxBlockSize<string | number> | readonly NonNullable<csstype.Property.MaxBlockSize<string | number> | undefined>[] | undefined;
        maxHeight?: readonly (string | (string & {}))[] | csstype.Property.MaxHeight<string | number> | readonly NonNullable<csstype.Property.MaxHeight<string | number> | undefined>[] | undefined;
        maxInlineSize?: readonly (string | (string & {}))[] | csstype.Property.MaxInlineSize<string | number> | readonly NonNullable<csstype.Property.MaxInlineSize<string | number> | undefined>[] | undefined;
        maxLines?: csstype.Property.MaxLines | readonly NonNullable<csstype.Property.MaxLines | undefined>[] | readonly ("none" | (string & {}) | csstype.Globals)[] | undefined;
        maxWidth?: readonly (string | (string & {}))[] | csstype.Property.MaxWidth<string | number> | readonly NonNullable<csstype.Property.MaxWidth<string | number> | undefined>[] | undefined;
        minBlockSize?: readonly (string | (string & {}))[] | csstype.Property.MinBlockSize<string | number> | readonly NonNullable<csstype.Property.MinBlockSize<string | number> | undefined>[] | undefined;
        minHeight?: readonly (string | (string & {}))[] | csstype.Property.MinHeight<string | number> | readonly NonNullable<csstype.Property.MinHeight<string | number> | undefined>[] | undefined;
        minInlineSize?: readonly (string | (string & {}))[] | csstype.Property.MinInlineSize<string | number> | readonly NonNullable<csstype.Property.MinInlineSize<string | number> | undefined>[] | undefined;
        minWidth?: readonly (string | (string & {}))[] | csstype.Property.MinWidth<string | number> | readonly NonNullable<csstype.Property.MinWidth<string | number> | undefined>[] | undefined;
        mixBlendMode?: csstype.Property.MixBlendMode | readonly NonNullable<csstype.Property.MixBlendMode | undefined>[] | readonly csstype.Property.MixBlendMode[] | undefined;
        motionDistance?: readonly (string | (string & {}))[] | csstype.Property.OffsetDistance<string | number> | readonly NonNullable<csstype.Property.OffsetDistance<string | number> | undefined>[] | undefined;
        motionPath?: readonly string[] | csstype.Property.OffsetPath | readonly csstype.Property.OffsetPath[] | undefined;
        motionRotation?: readonly string[] | csstype.Property.OffsetRotate | readonly csstype.Property.OffsetRotate[] | undefined;
        objectFit?: csstype.Property.ObjectFit | readonly NonNullable<csstype.Property.ObjectFit | undefined>[] | readonly csstype.Property.ObjectFit[] | undefined;
        objectPosition?: readonly (string | (string & {}))[] | csstype.Property.ObjectPosition<string | number> | readonly NonNullable<csstype.Property.ObjectPosition<string | number> | undefined>[] | undefined;
        offsetAnchor?: readonly (string | (string & {}))[] | csstype.Property.OffsetAnchor<string | number> | readonly NonNullable<csstype.Property.OffsetAnchor<string | number> | undefined>[] | undefined;
        offsetDistance?: readonly (string | (string & {}))[] | csstype.Property.OffsetDistance<string | number> | readonly NonNullable<csstype.Property.OffsetDistance<string | number> | undefined>[] | undefined;
        offsetPath?: readonly string[] | csstype.Property.OffsetPath | readonly csstype.Property.OffsetPath[] | undefined;
        offsetPosition?: readonly (string | (string & {}))[] | csstype.Property.OffsetPosition<string | number> | readonly NonNullable<csstype.Property.OffsetPosition<string | number> | undefined>[] | undefined;
        offsetRotate?: readonly string[] | csstype.Property.OffsetRotate | readonly csstype.Property.OffsetRotate[] | undefined;
        offsetRotation?: readonly string[] | csstype.Property.OffsetRotate | readonly csstype.Property.OffsetRotate[] | undefined;
        opacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Opacity | readonly NonNullable<csstype.Property.Opacity | undefined>[] | undefined;
        order?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Order | readonly NonNullable<csstype.Property.Order | undefined>[] | undefined;
        orphans?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Orphans | readonly NonNullable<csstype.Property.Orphans | undefined>[] | undefined;
        outlineColor?: readonly string[] | csstype.Property.OutlineColor | readonly csstype.Property.OutlineColor[] | undefined;
        outlineOffset?: readonly string[] | csstype.Property.OutlineOffset<string | number> | readonly NonNullable<csstype.Property.OutlineOffset<string | number> | undefined>[] | undefined;
        outlineStyle?: readonly string[] | csstype.Property.OutlineStyle | readonly csstype.Property.OutlineStyle[] | undefined;
        outlineWidth?: readonly string[] | csstype.Property.OutlineWidth<string | number> | readonly NonNullable<csstype.Property.OutlineWidth<string | number> | undefined>[] | undefined;
        overflowAnchor?: csstype.Property.OverflowAnchor | readonly NonNullable<csstype.Property.OverflowAnchor | undefined>[] | readonly csstype.Property.OverflowAnchor[] | undefined;
        overflowBlock?: csstype.Property.OverflowBlock | readonly NonNullable<csstype.Property.OverflowBlock | undefined>[] | readonly csstype.Property.OverflowBlock[] | undefined;
        overflowClipBox?: csstype.Property.OverflowClipBox | readonly NonNullable<csstype.Property.OverflowClipBox | undefined>[] | readonly csstype.Property.OverflowClipBox[] | undefined;
        overflowClipMargin?: readonly (string | (string & {}))[] | csstype.Property.OverflowClipMargin<string | number> | readonly NonNullable<csstype.Property.OverflowClipMargin<string | number> | undefined>[] | undefined;
        overflowInline?: csstype.Property.OverflowInline | readonly NonNullable<csstype.Property.OverflowInline | undefined>[] | readonly csstype.Property.OverflowInline[] | undefined;
        overflowWrap?: csstype.Property.OverflowWrap | readonly NonNullable<csstype.Property.OverflowWrap | undefined>[] | readonly csstype.Property.OverflowWrap[] | undefined;
        overflowX?: csstype.Property.OverflowX | readonly NonNullable<csstype.Property.OverflowX | undefined>[] | readonly csstype.Property.OverflowX[] | undefined;
        overflowY?: csstype.Property.OverflowY | readonly NonNullable<csstype.Property.OverflowY | undefined>[] | readonly csstype.Property.OverflowY[] | undefined;
        overlay?: csstype.Property.Overlay | readonly NonNullable<csstype.Property.Overlay | undefined>[] | readonly csstype.Property.Overlay[] | undefined;
        overscrollBehaviorBlock?: csstype.Property.OverscrollBehaviorBlock | readonly NonNullable<csstype.Property.OverscrollBehaviorBlock | undefined>[] | readonly csstype.Property.OverscrollBehaviorBlock[] | undefined;
        overscrollBehaviorInline?: csstype.Property.OverscrollBehaviorInline | readonly NonNullable<csstype.Property.OverscrollBehaviorInline | undefined>[] | readonly csstype.Property.OverscrollBehaviorInline[] | undefined;
        overscrollBehaviorX?: csstype.Property.OverscrollBehaviorX | readonly NonNullable<csstype.Property.OverscrollBehaviorX | undefined>[] | readonly csstype.Property.OverscrollBehaviorX[] | undefined;
        overscrollBehaviorY?: csstype.Property.OverscrollBehaviorY | readonly NonNullable<csstype.Property.OverscrollBehaviorY | undefined>[] | readonly csstype.Property.OverscrollBehaviorY[] | undefined;
        paddingBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.PaddingBlockEnd<string | number> | readonly NonNullable<csstype.Property.PaddingBlockEnd<string | number> | undefined>[] | undefined;
        paddingBlockStart?: readonly (string | (string & {}))[] | csstype.Property.PaddingBlockStart<string | number> | readonly NonNullable<csstype.Property.PaddingBlockStart<string | number> | undefined>[] | undefined;
        paddingBottom?: readonly (string | (string & {}))[] | csstype.Property.PaddingBottom<string | number> | readonly NonNullable<csstype.Property.PaddingBottom<string | number> | undefined>[] | undefined;
        paddingInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineEnd<string | number> | readonly NonNullable<csstype.Property.PaddingInlineEnd<string | number> | undefined>[] | undefined;
        paddingInlineStart?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineStart<string | number> | readonly NonNullable<csstype.Property.PaddingInlineStart<string | number> | undefined>[] | undefined;
        paddingLeft?: readonly (string | (string & {}))[] | csstype.Property.PaddingLeft<string | number> | readonly NonNullable<csstype.Property.PaddingLeft<string | number> | undefined>[] | undefined;
        paddingRight?: readonly (string | (string & {}))[] | csstype.Property.PaddingRight<string | number> | readonly NonNullable<csstype.Property.PaddingRight<string | number> | undefined>[] | undefined;
        paddingTop?: readonly (string | (string & {}))[] | csstype.Property.PaddingTop<string | number> | readonly NonNullable<csstype.Property.PaddingTop<string | number> | undefined>[] | undefined;
        page?: readonly string[] | csstype.Property.Page | readonly csstype.Property.Page[] | undefined;
        pageBreakAfter?: csstype.Property.PageBreakAfter | readonly NonNullable<csstype.Property.PageBreakAfter | undefined>[] | readonly csstype.Property.PageBreakAfter[] | undefined;
        pageBreakBefore?: csstype.Property.PageBreakBefore | readonly NonNullable<csstype.Property.PageBreakBefore | undefined>[] | readonly csstype.Property.PageBreakBefore[] | undefined;
        pageBreakInside?: csstype.Property.PageBreakInside | readonly NonNullable<csstype.Property.PageBreakInside | undefined>[] | readonly csstype.Property.PageBreakInside[] | undefined;
        paintOrder?: readonly string[] | csstype.Property.PaintOrder | readonly csstype.Property.PaintOrder[] | undefined;
        perspective?: readonly string[] | csstype.Property.Perspective<string | number> | readonly NonNullable<csstype.Property.Perspective<string | number> | undefined>[] | undefined;
        perspectiveOrigin?: readonly (string | (string & {}))[] | csstype.Property.PerspectiveOrigin<string | number> | readonly NonNullable<csstype.Property.PerspectiveOrigin<string | number> | undefined>[] | undefined;
        pointerEvents?: csstype.Property.PointerEvents | readonly NonNullable<csstype.Property.PointerEvents | undefined>[] | readonly csstype.Property.PointerEvents[] | undefined;
        position?: csstype.Property.Position | readonly NonNullable<csstype.Property.Position | undefined>[] | readonly csstype.Property.Position[] | undefined;
        printColorAdjust?: csstype.Property.PrintColorAdjust | readonly NonNullable<csstype.Property.PrintColorAdjust | undefined>[] | readonly csstype.Property.PrintColorAdjust[] | undefined;
        quotes?: readonly string[] | csstype.Property.Quotes | readonly csstype.Property.Quotes[] | undefined;
        resize?: csstype.Property.Resize | readonly NonNullable<csstype.Property.Resize | undefined>[] | readonly csstype.Property.Resize[] | undefined;
        right?: readonly (string | (string & {}))[] | csstype.Property.Right<string | number> | readonly NonNullable<csstype.Property.Right<string | number> | undefined>[] | undefined;
        rotate?: readonly string[] | csstype.Property.Rotate | readonly csstype.Property.Rotate[] | undefined;
        rowGap?: readonly (string | (string & {}))[] | csstype.Property.RowGap<string | number> | readonly NonNullable<csstype.Property.RowGap<string | number> | undefined>[] | undefined;
        rubyAlign?: csstype.Property.RubyAlign | readonly NonNullable<csstype.Property.RubyAlign | undefined>[] | readonly csstype.Property.RubyAlign[] | undefined;
        rubyMerge?: csstype.Property.RubyMerge | readonly NonNullable<csstype.Property.RubyMerge | undefined>[] | readonly csstype.Property.RubyMerge[] | undefined;
        rubyPosition?: readonly string[] | csstype.Property.RubyPosition | readonly csstype.Property.RubyPosition[] | undefined;
        scale?: readonly ("none" | (string & {}) | csstype.Globals)[] | csstype.Property.Scale | readonly NonNullable<csstype.Property.Scale | undefined>[] | undefined;
        scrollBehavior?: csstype.Property.ScrollBehavior | readonly NonNullable<csstype.Property.ScrollBehavior | undefined>[] | readonly csstype.Property.ScrollBehavior[] | undefined;
        scrollMarginBlockEnd?: readonly string[] | csstype.Property.ScrollMarginBlockEnd<string | number> | readonly NonNullable<csstype.Property.ScrollMarginBlockEnd<string | number> | undefined>[] | undefined;
        scrollMarginBlockStart?: readonly string[] | csstype.Property.ScrollMarginBlockStart<string | number> | readonly NonNullable<csstype.Property.ScrollMarginBlockStart<string | number> | undefined>[] | undefined;
        scrollMarginBottom?: readonly string[] | csstype.Property.ScrollMarginBottom<string | number> | readonly NonNullable<csstype.Property.ScrollMarginBottom<string | number> | undefined>[] | undefined;
        scrollMarginInlineEnd?: readonly string[] | csstype.Property.ScrollMarginInlineEnd<string | number> | readonly NonNullable<csstype.Property.ScrollMarginInlineEnd<string | number> | undefined>[] | undefined;
        scrollMarginInlineStart?: readonly string[] | csstype.Property.ScrollMarginInlineStart<string | number> | readonly NonNullable<csstype.Property.ScrollMarginInlineStart<string | number> | undefined>[] | undefined;
        scrollMarginLeft?: readonly string[] | csstype.Property.ScrollMarginLeft<string | number> | readonly NonNullable<csstype.Property.ScrollMarginLeft<string | number> | undefined>[] | undefined;
        scrollMarginRight?: readonly string[] | csstype.Property.ScrollMarginRight<string | number> | readonly NonNullable<csstype.Property.ScrollMarginRight<string | number> | undefined>[] | undefined;
        scrollMarginTop?: readonly string[] | csstype.Property.ScrollMarginTop<string | number> | readonly NonNullable<csstype.Property.ScrollMarginTop<string | number> | undefined>[] | undefined;
        scrollPaddingBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingBlockEnd<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingBlockEnd<string | number> | undefined>[] | undefined;
        scrollPaddingBlockStart?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingBlockStart<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingBlockStart<string | number> | undefined>[] | undefined;
        scrollPaddingBottom?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingBottom<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingBottom<string | number> | undefined>[] | undefined;
        scrollPaddingInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingInlineEnd<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingInlineEnd<string | number> | undefined>[] | undefined;
        scrollPaddingInlineStart?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingInlineStart<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingInlineStart<string | number> | undefined>[] | undefined;
        scrollPaddingLeft?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingLeft<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingLeft<string | number> | undefined>[] | undefined;
        scrollPaddingRight?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingRight<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingRight<string | number> | undefined>[] | undefined;
        scrollPaddingTop?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingTop<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingTop<string | number> | undefined>[] | undefined;
        scrollSnapAlign?: readonly string[] | csstype.Property.ScrollSnapAlign | readonly csstype.Property.ScrollSnapAlign[] | undefined;
        scrollSnapMarginBottom?: readonly string[] | csstype.Property.ScrollMarginBottom<string | number> | readonly NonNullable<csstype.Property.ScrollMarginBottom<string | number> | undefined>[] | undefined;
        scrollSnapMarginLeft?: readonly string[] | csstype.Property.ScrollMarginLeft<string | number> | readonly NonNullable<csstype.Property.ScrollMarginLeft<string | number> | undefined>[] | undefined;
        scrollSnapMarginRight?: readonly string[] | csstype.Property.ScrollMarginRight<string | number> | readonly NonNullable<csstype.Property.ScrollMarginRight<string | number> | undefined>[] | undefined;
        scrollSnapMarginTop?: readonly string[] | csstype.Property.ScrollMarginTop<string | number> | readonly NonNullable<csstype.Property.ScrollMarginTop<string | number> | undefined>[] | undefined;
        scrollSnapStop?: csstype.Property.ScrollSnapStop | readonly NonNullable<csstype.Property.ScrollSnapStop | undefined>[] | readonly csstype.Property.ScrollSnapStop[] | undefined;
        scrollSnapType?: readonly string[] | csstype.Property.ScrollSnapType | readonly csstype.Property.ScrollSnapType[] | undefined;
        scrollTimelineAxis?: readonly string[] | csstype.Property.ScrollTimelineAxis | readonly csstype.Property.ScrollTimelineAxis[] | undefined;
        scrollTimelineName?: readonly string[] | csstype.Property.ScrollTimelineName | readonly csstype.Property.ScrollTimelineName[] | undefined;
        scrollbarColor?: readonly string[] | csstype.Property.ScrollbarColor | readonly csstype.Property.ScrollbarColor[] | undefined;
        scrollbarGutter?: readonly string[] | csstype.Property.ScrollbarGutter | readonly csstype.Property.ScrollbarGutter[] | undefined;
        scrollbarWidth?: csstype.Property.ScrollbarWidth | readonly NonNullable<csstype.Property.ScrollbarWidth | undefined>[] | readonly csstype.Property.ScrollbarWidth[] | undefined;
        shapeImageThreshold?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.ShapeImageThreshold | readonly NonNullable<csstype.Property.ShapeImageThreshold | undefined>[] | undefined;
        shapeMargin?: readonly (string | (string & {}))[] | csstype.Property.ShapeMargin<string | number> | readonly NonNullable<csstype.Property.ShapeMargin<string | number> | undefined>[] | undefined;
        shapeOutside?: readonly string[] | csstype.Property.ShapeOutside | readonly csstype.Property.ShapeOutside[] | undefined;
        tabSize?: readonly (string | (string & {}))[] | csstype.Property.TabSize<string | number> | readonly NonNullable<csstype.Property.TabSize<string | number> | undefined>[] | undefined;
        tableLayout?: csstype.Property.TableLayout | readonly NonNullable<csstype.Property.TableLayout | undefined>[] | readonly csstype.Property.TableLayout[] | undefined;
        textAlign?: csstype.Property.TextAlign | readonly NonNullable<csstype.Property.TextAlign | undefined>[] | readonly csstype.Property.TextAlign[] | undefined;
        textAlignLast?: csstype.Property.TextAlignLast | readonly NonNullable<csstype.Property.TextAlignLast | undefined>[] | readonly csstype.Property.TextAlignLast[] | undefined;
        textCombineUpright?: readonly string[] | csstype.Property.TextCombineUpright | readonly csstype.Property.TextCombineUpright[] | undefined;
        textDecorationColor?: readonly string[] | csstype.Property.TextDecorationColor | readonly csstype.Property.TextDecorationColor[] | undefined;
        textDecorationLine?: readonly string[] | csstype.Property.TextDecorationLine | readonly csstype.Property.TextDecorationLine[] | undefined;
        textDecorationSkip?: readonly string[] | csstype.Property.TextDecorationSkip | readonly csstype.Property.TextDecorationSkip[] | undefined;
        textDecorationSkipInk?: csstype.Property.TextDecorationSkipInk | readonly NonNullable<csstype.Property.TextDecorationSkipInk | undefined>[] | readonly csstype.Property.TextDecorationSkipInk[] | undefined;
        textDecorationStyle?: csstype.Property.TextDecorationStyle | readonly NonNullable<csstype.Property.TextDecorationStyle | undefined>[] | readonly csstype.Property.TextDecorationStyle[] | undefined;
        textDecorationThickness?: readonly (string | (string & {}))[] | csstype.Property.TextDecorationThickness<string | number> | readonly NonNullable<csstype.Property.TextDecorationThickness<string | number> | undefined>[] | undefined;
        textEmphasisColor?: readonly string[] | csstype.Property.TextEmphasisColor | readonly csstype.Property.TextEmphasisColor[] | undefined;
        textEmphasisPosition?: readonly string[] | csstype.Property.TextEmphasisPosition | readonly csstype.Property.TextEmphasisPosition[] | undefined;
        textEmphasisStyle?: readonly string[] | csstype.Property.TextEmphasisStyle | readonly csstype.Property.TextEmphasisStyle[] | undefined;
        textIndent?: readonly (string | (string & {}))[] | csstype.Property.TextIndent<string | number> | readonly NonNullable<csstype.Property.TextIndent<string | number> | undefined>[] | undefined;
        textJustify?: csstype.Property.TextJustify | readonly NonNullable<csstype.Property.TextJustify | undefined>[] | readonly csstype.Property.TextJustify[] | undefined;
        textOrientation?: csstype.Property.TextOrientation | readonly NonNullable<csstype.Property.TextOrientation | undefined>[] | readonly csstype.Property.TextOrientation[] | undefined;
        textOverflow?: readonly string[] | csstype.Property.TextOverflow | readonly csstype.Property.TextOverflow[] | undefined;
        textRendering?: csstype.Property.TextRendering | readonly NonNullable<csstype.Property.TextRendering | undefined>[] | readonly csstype.Property.TextRendering[] | undefined;
        textShadow?: readonly string[] | csstype.Property.TextShadow | readonly csstype.Property.TextShadow[] | undefined;
        textSizeAdjust?: readonly string[] | csstype.Property.TextSizeAdjust | readonly csstype.Property.TextSizeAdjust[] | undefined;
        textTransform?: csstype.Property.TextTransform | readonly NonNullable<csstype.Property.TextTransform | undefined>[] | readonly csstype.Property.TextTransform[] | undefined;
        textUnderlineOffset?: readonly (string | (string & {}))[] | csstype.Property.TextUnderlineOffset<string | number> | readonly NonNullable<csstype.Property.TextUnderlineOffset<string | number> | undefined>[] | undefined;
        textUnderlinePosition?: readonly string[] | csstype.Property.TextUnderlinePosition | readonly csstype.Property.TextUnderlinePosition[] | undefined;
        textWrap?: csstype.Property.TextWrap | readonly NonNullable<csstype.Property.TextWrap | undefined>[] | readonly csstype.Property.TextWrap[] | undefined;
        timelineScope?: readonly string[] | csstype.Property.TimelineScope | readonly csstype.Property.TimelineScope[] | undefined;
        top?: readonly (string | (string & {}))[] | csstype.Property.Top<string | number> | readonly NonNullable<csstype.Property.Top<string | number> | undefined>[] | undefined;
        touchAction?: readonly string[] | csstype.Property.TouchAction | readonly csstype.Property.TouchAction[] | undefined;
        transform?: readonly string[] | csstype.Property.Transform | readonly csstype.Property.Transform[] | undefined;
        transformBox?: csstype.Property.TransformBox | readonly NonNullable<csstype.Property.TransformBox | undefined>[] | readonly csstype.Property.TransformBox[] | undefined;
        transformOrigin?: readonly (string | (string & {}))[] | csstype.Property.TransformOrigin<string | number> | readonly NonNullable<csstype.Property.TransformOrigin<string | number> | undefined>[] | undefined;
        transformStyle?: csstype.Property.TransformStyle | readonly NonNullable<csstype.Property.TransformStyle | undefined>[] | readonly csstype.Property.TransformStyle[] | undefined;
        transitionBehavior?: readonly string[] | csstype.Property.TransitionBehavior | readonly csstype.Property.TransitionBehavior[] | undefined;
        transitionDelay?: readonly string[] | csstype.Property.TransitionDelay<string & {}> | readonly csstype.Property.TransitionDelay<string & {}>[] | undefined;
        transitionDuration?: readonly string[] | csstype.Property.TransitionDuration<string & {}> | readonly csstype.Property.TransitionDuration<string & {}>[] | undefined;
        transitionProperty?: readonly string[] | csstype.Property.TransitionProperty | readonly csstype.Property.TransitionProperty[] | undefined;
        transitionTimingFunction?: readonly string[] | csstype.Property.TransitionTimingFunction | readonly csstype.Property.TransitionTimingFunction[] | undefined;
        translate?: readonly (string | (string & {}))[] | csstype.Property.Translate<string | number> | readonly NonNullable<csstype.Property.Translate<string | number> | undefined>[] | undefined;
        unicodeBidi?: csstype.Property.UnicodeBidi | readonly NonNullable<csstype.Property.UnicodeBidi | undefined>[] | readonly csstype.Property.UnicodeBidi[] | undefined;
        userSelect?: csstype.Property.UserSelect | readonly NonNullable<csstype.Property.UserSelect | undefined>[] | readonly csstype.Property.UserSelect[] | undefined;
        verticalAlign?: readonly (string | (string & {}))[] | csstype.Property.VerticalAlign<string | number> | readonly NonNullable<csstype.Property.VerticalAlign<string | number> | undefined>[] | undefined;
        viewTimelineAxis?: readonly string[] | csstype.Property.ViewTimelineAxis | readonly csstype.Property.ViewTimelineAxis[] | undefined;
        viewTimelineInset?: readonly (string | (string & {}))[] | csstype.Property.ViewTimelineInset<string | number> | readonly NonNullable<csstype.Property.ViewTimelineInset<string | number> | undefined>[] | undefined;
        viewTimelineName?: readonly string[] | csstype.Property.ViewTimelineName | readonly csstype.Property.ViewTimelineName[] | undefined;
        viewTransitionName?: readonly string[] | csstype.Property.ViewTransitionName | readonly csstype.Property.ViewTransitionName[] | undefined;
        visibility?: csstype.Property.Visibility | readonly NonNullable<csstype.Property.Visibility | undefined>[] | readonly csstype.Property.Visibility[] | undefined;
        whiteSpace?: readonly string[] | csstype.Property.WhiteSpace | readonly csstype.Property.WhiteSpace[] | undefined;
        whiteSpaceCollapse?: csstype.Property.WhiteSpaceCollapse | readonly NonNullable<csstype.Property.WhiteSpaceCollapse | undefined>[] | readonly csstype.Property.WhiteSpaceCollapse[] | undefined;
        whiteSpaceTrim?: readonly string[] | csstype.Property.WhiteSpaceTrim | readonly csstype.Property.WhiteSpaceTrim[] | undefined;
        widows?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Widows | readonly NonNullable<csstype.Property.Widows | undefined>[] | undefined;
        width?: readonly (string | (string & {}))[] | csstype.Property.Width<string | number> | readonly NonNullable<csstype.Property.Width<string | number> | undefined>[] | undefined;
        willChange?: readonly string[] | csstype.Property.WillChange | readonly csstype.Property.WillChange[] | undefined;
        wordBreak?: csstype.Property.WordBreak | readonly NonNullable<csstype.Property.WordBreak | undefined>[] | readonly csstype.Property.WordBreak[] | undefined;
        wordSpacing?: readonly string[] | csstype.Property.WordSpacing<string | number> | readonly NonNullable<csstype.Property.WordSpacing<string | number> | undefined>[] | undefined;
        wordWrap?: csstype.Property.WordWrap | readonly NonNullable<csstype.Property.WordWrap | undefined>[] | readonly csstype.Property.WordWrap[] | undefined;
        writingMode?: csstype.Property.WritingMode | readonly NonNullable<csstype.Property.WritingMode | undefined>[] | readonly csstype.Property.WritingMode[] | undefined;
        zoom?: csstype.Property.Zoom | readonly NonNullable<csstype.Property.Zoom | undefined>[] | readonly ("normal" | "reset" | (string & {}) | csstype.Globals)[] | undefined;
        all?: csstype.Globals | readonly NonNullable<csstype.Globals | undefined>[] | readonly csstype.Globals[] | undefined;
        animation?: csstype.Property.Animation<string & {}> | readonly NonNullable<csstype.Property.Animation<string & {}> | undefined>[] | readonly ("linear" | "auto" | "none" | "normal" | "reverse" | "paused" | (string & {}) | csstype.Globals | "ease" | "ease-in" | "ease-in-out" | "ease-out" | "step-end" | "step-start" | "alternate" | "alternate-reverse" | "backwards" | "both" | "forwards" | "infinite" | "running")[] | undefined;
        animationRange?: readonly (string | (string & {}))[] | csstype.Property.AnimationRange<string | number> | readonly NonNullable<csstype.Property.AnimationRange<string | number> | undefined>[] | undefined;
        background?: readonly (string | (string & {}))[] | csstype.Property.Background<string | number> | readonly NonNullable<csstype.Property.Background<string | number> | undefined>[] | undefined;
        backgroundPosition?: readonly (string | (string & {}))[] | csstype.Property.BackgroundPosition<string | number> | readonly NonNullable<csstype.Property.BackgroundPosition<string | number> | undefined>[] | undefined;
        border?: readonly (string | (string & {}))[] | csstype.Property.Border<string | number> | readonly NonNullable<csstype.Property.Border<string | number> | undefined>[] | undefined;
        borderBlock?: readonly (string | (string & {}))[] | csstype.Property.BorderBlock<string | number> | readonly NonNullable<csstype.Property.BorderBlock<string | number> | undefined>[] | undefined;
        borderBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.BorderBlockEnd<string | number> | readonly NonNullable<csstype.Property.BorderBlockEnd<string | number> | undefined>[] | undefined;
        borderBlockStart?: readonly (string | (string & {}))[] | csstype.Property.BorderBlockStart<string | number> | readonly NonNullable<csstype.Property.BorderBlockStart<string | number> | undefined>[] | undefined;
        borderBottom?: readonly (string | (string & {}))[] | csstype.Property.BorderBottom<string | number> | readonly NonNullable<csstype.Property.BorderBottom<string | number> | undefined>[] | undefined;
        borderColor?: readonly string[] | csstype.Property.BorderColor | readonly csstype.Property.BorderColor[] | undefined;
        borderImage?: csstype.Property.BorderImage | readonly NonNullable<csstype.Property.BorderImage | undefined>[] | readonly ("none" | "repeat" | "round" | (string & {}) | csstype.Globals | "space" | "stretch")[] | undefined;
        borderInline?: readonly (string | (string & {}))[] | csstype.Property.BorderInline<string | number> | readonly NonNullable<csstype.Property.BorderInline<string | number> | undefined>[] | undefined;
        borderInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.BorderInlineEnd<string | number> | readonly NonNullable<csstype.Property.BorderInlineEnd<string | number> | undefined>[] | undefined;
        borderInlineStart?: readonly (string | (string & {}))[] | csstype.Property.BorderInlineStart<string | number> | readonly NonNullable<csstype.Property.BorderInlineStart<string | number> | undefined>[] | undefined;
        borderLeft?: readonly (string | (string & {}))[] | csstype.Property.BorderLeft<string | number> | readonly NonNullable<csstype.Property.BorderLeft<string | number> | undefined>[] | undefined;
        borderRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderRadius<string | number> | readonly NonNullable<csstype.Property.BorderRadius<string | number> | undefined>[] | undefined;
        borderRight?: readonly (string | (string & {}))[] | csstype.Property.BorderRight<string | number> | readonly NonNullable<csstype.Property.BorderRight<string | number> | undefined>[] | undefined;
        borderStyle?: readonly string[] | csstype.Property.BorderStyle | readonly csstype.Property.BorderStyle[] | undefined;
        borderTop?: readonly (string | (string & {}))[] | csstype.Property.BorderTop<string | number> | readonly NonNullable<csstype.Property.BorderTop<string | number> | undefined>[] | undefined;
        borderWidth?: readonly (string | (string & {}))[] | csstype.Property.BorderWidth<string | number> | readonly NonNullable<csstype.Property.BorderWidth<string | number> | undefined>[] | undefined;
        caret?: readonly string[] | csstype.Property.Caret | readonly csstype.Property.Caret[] | undefined;
        columnRule?: readonly (string | (string & {}))[] | csstype.Property.ColumnRule<string | number> | readonly NonNullable<csstype.Property.ColumnRule<string | number> | undefined>[] | undefined;
        columns?: readonly (string | (string & {}))[] | csstype.Property.Columns<string | number> | readonly NonNullable<csstype.Property.Columns<string | number> | undefined>[] | undefined;
        containIntrinsicSize?: readonly (string | (string & {}))[] | csstype.Property.ContainIntrinsicSize<string | number> | readonly NonNullable<csstype.Property.ContainIntrinsicSize<string | number> | undefined>[] | undefined;
        container?: readonly string[] | csstype.Property.Container | readonly csstype.Property.Container[] | undefined;
        flex?: readonly (string | (string & {}))[] | csstype.Property.Flex<string | number> | readonly NonNullable<csstype.Property.Flex<string | number> | undefined>[] | undefined;
        flexFlow?: readonly string[] | csstype.Property.FlexFlow | readonly csstype.Property.FlexFlow[] | undefined;
        font?: readonly string[] | csstype.Property.Font | readonly csstype.Property.Font[] | undefined;
        gap?: readonly (string | (string & {}))[] | csstype.Property.Gap<string | number> | readonly NonNullable<csstype.Property.Gap<string | number> | undefined>[] | undefined;
        grid?: readonly string[] | csstype.Property.Grid | readonly csstype.Property.Grid[] | undefined;
        gridArea?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridArea | readonly NonNullable<csstype.Property.GridArea | undefined>[] | undefined;
        gridColumn?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridColumn | readonly NonNullable<csstype.Property.GridColumn | undefined>[] | undefined;
        gridRow?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridRow | readonly NonNullable<csstype.Property.GridRow | undefined>[] | undefined;
        gridTemplate?: readonly string[] | csstype.Property.GridTemplate | readonly csstype.Property.GridTemplate[] | undefined;
        inset?: readonly (string | (string & {}))[] | csstype.Property.Inset<string | number> | readonly NonNullable<csstype.Property.Inset<string | number> | undefined>[] | undefined;
        insetBlock?: readonly (string | (string & {}))[] | csstype.Property.InsetBlock<string | number> | readonly NonNullable<csstype.Property.InsetBlock<string | number> | undefined>[] | undefined;
        insetInline?: readonly (string | (string & {}))[] | csstype.Property.InsetInline<string | number> | readonly NonNullable<csstype.Property.InsetInline<string | number> | undefined>[] | undefined;
        lineClamp?: readonly ("none" | (string & {}) | csstype.Globals)[] | csstype.Property.LineClamp | readonly NonNullable<csstype.Property.LineClamp | undefined>[] | undefined;
        listStyle?: readonly string[] | csstype.Property.ListStyle | readonly csstype.Property.ListStyle[] | undefined;
        marginBlock?: readonly (string | (string & {}))[] | csstype.Property.MarginBlock<string | number> | readonly NonNullable<csstype.Property.MarginBlock<string | number> | undefined>[] | undefined;
        marginInline?: readonly (string | (string & {}))[] | csstype.Property.MarginInline<string | number> | readonly NonNullable<csstype.Property.MarginInline<string | number> | undefined>[] | undefined;
        mask?: readonly (string | (string & {}))[] | csstype.Property.Mask<string | number> | readonly NonNullable<csstype.Property.Mask<string | number> | undefined>[] | undefined;
        maskBorder?: csstype.Property.MaskBorder | readonly NonNullable<csstype.Property.MaskBorder | undefined>[] | readonly ("none" | "repeat" | "alpha" | "round" | (string & {}) | csstype.Globals | "space" | "stretch" | "luminance")[] | undefined;
        motion?: readonly (string | (string & {}))[] | csstype.Property.Offset<string | number> | readonly NonNullable<csstype.Property.Offset<string | number> | undefined>[] | undefined;
        offset?: readonly (string | (string & {}))[] | csstype.Property.Offset<string | number> | readonly NonNullable<csstype.Property.Offset<string | number> | undefined>[] | undefined;
        outline?: readonly (string | (string & {}))[] | csstype.Property.Outline<string | number> | readonly NonNullable<csstype.Property.Outline<string | number> | undefined>[] | undefined;
        overscrollBehavior?: readonly string[] | csstype.Property.OverscrollBehavior | readonly csstype.Property.OverscrollBehavior[] | undefined;
        paddingBlock?: readonly (string | (string & {}))[] | csstype.Property.PaddingBlock<string | number> | readonly NonNullable<csstype.Property.PaddingBlock<string | number> | undefined>[] | undefined;
        paddingInline?: readonly (string | (string & {}))[] | csstype.Property.PaddingInline<string | number> | readonly NonNullable<csstype.Property.PaddingInline<string | number> | undefined>[] | undefined;
        placeContent?: readonly string[] | csstype.Property.PlaceContent | readonly csstype.Property.PlaceContent[] | undefined;
        placeItems?: readonly string[] | csstype.Property.PlaceItems | readonly csstype.Property.PlaceItems[] | undefined;
        placeSelf?: readonly string[] | csstype.Property.PlaceSelf | readonly csstype.Property.PlaceSelf[] | undefined;
        scrollMargin?: readonly (string | (string & {}))[] | csstype.Property.ScrollMargin<string | number> | readonly NonNullable<csstype.Property.ScrollMargin<string | number> | undefined>[] | undefined;
        scrollMarginBlock?: readonly (string | (string & {}))[] | csstype.Property.ScrollMarginBlock<string | number> | readonly NonNullable<csstype.Property.ScrollMarginBlock<string | number> | undefined>[] | undefined;
        scrollMarginInline?: readonly (string | (string & {}))[] | csstype.Property.ScrollMarginInline<string | number> | readonly NonNullable<csstype.Property.ScrollMarginInline<string | number> | undefined>[] | undefined;
        scrollPadding?: readonly (string | (string & {}))[] | csstype.Property.ScrollPadding<string | number> | readonly NonNullable<csstype.Property.ScrollPadding<string | number> | undefined>[] | undefined;
        scrollPaddingBlock?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingBlock<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingBlock<string | number> | undefined>[] | undefined;
        scrollPaddingInline?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingInline<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingInline<string | number> | undefined>[] | undefined;
        scrollSnapMargin?: readonly (string | (string & {}))[] | csstype.Property.ScrollMargin<string | number> | readonly NonNullable<csstype.Property.ScrollMargin<string | number> | undefined>[] | undefined;
        scrollTimeline?: readonly string[] | csstype.Property.ScrollTimeline | readonly csstype.Property.ScrollTimeline[] | undefined;
        textDecoration?: readonly (string | (string & {}))[] | csstype.Property.TextDecoration<string | number> | readonly NonNullable<csstype.Property.TextDecoration<string | number> | undefined>[] | undefined;
        textEmphasis?: readonly string[] | csstype.Property.TextEmphasis | readonly csstype.Property.TextEmphasis[] | undefined;
        transition?: readonly string[] | csstype.Property.Transition<string & {}> | readonly csstype.Property.Transition<string & {}>[] | undefined;
        viewTimeline?: readonly string[] | csstype.Property.ViewTimeline | readonly csstype.Property.ViewTimeline[] | undefined;
        MozAnimationDelay?: readonly string[] | csstype.Property.AnimationDelay<string & {}> | readonly csstype.Property.AnimationDelay<string & {}>[] | undefined;
        MozAnimationDirection?: readonly string[] | csstype.Property.AnimationDirection | readonly csstype.Property.AnimationDirection[] | undefined;
        MozAnimationDuration?: readonly string[] | csstype.Property.AnimationDuration<string & {}> | readonly csstype.Property.AnimationDuration<string & {}>[] | undefined;
        MozAnimationFillMode?: readonly string[] | csstype.Property.AnimationFillMode | readonly csstype.Property.AnimationFillMode[] | undefined;
        MozAnimationIterationCount?: csstype.Property.AnimationIterationCount | readonly NonNullable<csstype.Property.AnimationIterationCount | undefined>[] | readonly ((string & {}) | csstype.Globals | "infinite")[] | undefined;
        MozAnimationName?: readonly string[] | csstype.Property.AnimationName | readonly csstype.Property.AnimationName[] | undefined;
        MozAnimationPlayState?: readonly string[] | csstype.Property.AnimationPlayState | readonly csstype.Property.AnimationPlayState[] | undefined;
        MozAnimationTimingFunction?: readonly string[] | csstype.Property.AnimationTimingFunction | readonly csstype.Property.AnimationTimingFunction[] | undefined;
        MozAppearance?: csstype.Property.MozAppearance | readonly NonNullable<csstype.Property.MozAppearance | undefined>[] | readonly csstype.Property.MozAppearance[] | undefined;
        MozBinding?: readonly string[] | csstype.Property.MozBinding | readonly csstype.Property.MozBinding[] | undefined;
        MozBorderBottomColors?: readonly string[] | csstype.Property.MozBorderBottomColors | readonly csstype.Property.MozBorderBottomColors[] | undefined;
        MozBorderEndColor?: readonly string[] | csstype.Property.BorderInlineEndColor | readonly csstype.Property.BorderInlineEndColor[] | undefined;
        MozBorderEndStyle?: csstype.Property.BorderInlineEndStyle | readonly NonNullable<csstype.Property.BorderInlineEndStyle | undefined>[] | readonly csstype.Property.BorderInlineEndStyle[] | undefined;
        MozBorderEndWidth?: readonly string[] | csstype.Property.BorderInlineEndWidth<string | number> | readonly NonNullable<csstype.Property.BorderInlineEndWidth<string | number> | undefined>[] | undefined;
        MozBorderLeftColors?: readonly string[] | csstype.Property.MozBorderLeftColors | readonly csstype.Property.MozBorderLeftColors[] | undefined;
        MozBorderRightColors?: readonly string[] | csstype.Property.MozBorderRightColors | readonly csstype.Property.MozBorderRightColors[] | undefined;
        MozBorderStartColor?: readonly string[] | csstype.Property.BorderInlineStartColor | readonly csstype.Property.BorderInlineStartColor[] | undefined;
        MozBorderStartStyle?: csstype.Property.BorderInlineStartStyle | readonly NonNullable<csstype.Property.BorderInlineStartStyle | undefined>[] | readonly csstype.Property.BorderInlineStartStyle[] | undefined;
        MozBorderTopColors?: readonly string[] | csstype.Property.MozBorderTopColors | readonly csstype.Property.MozBorderTopColors[] | undefined;
        MozBoxSizing?: csstype.Property.BoxSizing | readonly NonNullable<csstype.Property.BoxSizing | undefined>[] | readonly csstype.Property.BoxSizing[] | undefined;
        MozColumnCount?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.ColumnCount | readonly NonNullable<csstype.Property.ColumnCount | undefined>[] | undefined;
        MozColumnFill?: csstype.Property.ColumnFill | readonly NonNullable<csstype.Property.ColumnFill | undefined>[] | readonly csstype.Property.ColumnFill[] | undefined;
        MozColumnRuleColor?: readonly string[] | csstype.Property.ColumnRuleColor | readonly csstype.Property.ColumnRuleColor[] | undefined;
        MozColumnRuleStyle?: readonly string[] | csstype.Property.ColumnRuleStyle | readonly csstype.Property.ColumnRuleStyle[] | undefined;
        MozColumnRuleWidth?: readonly (string | (string & {}))[] | csstype.Property.ColumnRuleWidth<string | number> | readonly NonNullable<csstype.Property.ColumnRuleWidth<string | number> | undefined>[] | undefined;
        MozColumnWidth?: readonly string[] | csstype.Property.ColumnWidth<string | number> | readonly NonNullable<csstype.Property.ColumnWidth<string | number> | undefined>[] | undefined;
        MozContextProperties?: readonly string[] | csstype.Property.MozContextProperties | readonly csstype.Property.MozContextProperties[] | undefined;
        MozFontFeatureSettings?: readonly string[] | csstype.Property.FontFeatureSettings | readonly csstype.Property.FontFeatureSettings[] | undefined;
        MozFontLanguageOverride?: readonly string[] | csstype.Property.FontLanguageOverride | readonly csstype.Property.FontLanguageOverride[] | undefined;
        MozHyphens?: csstype.Property.Hyphens | readonly NonNullable<csstype.Property.Hyphens | undefined>[] | readonly csstype.Property.Hyphens[] | undefined;
        MozImageRegion?: readonly string[] | csstype.Property.MozImageRegion | readonly csstype.Property.MozImageRegion[] | undefined;
        MozMarginEnd?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineEnd<string | number> | readonly NonNullable<csstype.Property.MarginInlineEnd<string | number> | undefined>[] | undefined;
        MozMarginStart?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineStart<string | number> | readonly NonNullable<csstype.Property.MarginInlineStart<string | number> | undefined>[] | undefined;
        MozOrient?: csstype.Property.MozOrient | readonly NonNullable<csstype.Property.MozOrient | undefined>[] | readonly csstype.Property.MozOrient[] | undefined;
        MozOsxFontSmoothing?: readonly string[] | csstype.Property.FontSmooth<string | number> | readonly NonNullable<csstype.Property.FontSmooth<string | number> | undefined>[] | undefined;
        MozOutlineRadiusBottomleft?: readonly (string | (string & {}))[] | csstype.Property.MozOutlineRadiusBottomleft<string | number> | readonly NonNullable<csstype.Property.MozOutlineRadiusBottomleft<string | number> | undefined>[] | undefined;
        MozOutlineRadiusBottomright?: readonly (string | (string & {}))[] | csstype.Property.MozOutlineRadiusBottomright<string | number> | readonly NonNullable<csstype.Property.MozOutlineRadiusBottomright<string | number> | undefined>[] | undefined;
        MozOutlineRadiusTopleft?: readonly (string | (string & {}))[] | csstype.Property.MozOutlineRadiusTopleft<string | number> | readonly NonNullable<csstype.Property.MozOutlineRadiusTopleft<string | number> | undefined>[] | undefined;
        MozOutlineRadiusTopright?: readonly (string | (string & {}))[] | csstype.Property.MozOutlineRadiusTopright<string | number> | readonly NonNullable<csstype.Property.MozOutlineRadiusTopright<string | number> | undefined>[] | undefined;
        MozPaddingEnd?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineEnd<string | number> | readonly NonNullable<csstype.Property.PaddingInlineEnd<string | number> | undefined>[] | undefined;
        MozPaddingStart?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineStart<string | number> | readonly NonNullable<csstype.Property.PaddingInlineStart<string | number> | undefined>[] | undefined;
        MozStackSizing?: csstype.Property.MozStackSizing | readonly NonNullable<csstype.Property.MozStackSizing | undefined>[] | readonly csstype.Property.MozStackSizing[] | undefined;
        MozTabSize?: readonly (string | (string & {}))[] | csstype.Property.TabSize<string | number> | readonly NonNullable<csstype.Property.TabSize<string | number> | undefined>[] | undefined;
        MozTextBlink?: csstype.Property.MozTextBlink | readonly NonNullable<csstype.Property.MozTextBlink | undefined>[] | readonly csstype.Property.MozTextBlink[] | undefined;
        MozTextSizeAdjust?: readonly string[] | csstype.Property.TextSizeAdjust | readonly csstype.Property.TextSizeAdjust[] | undefined;
        MozUserFocus?: csstype.Property.MozUserFocus | readonly NonNullable<csstype.Property.MozUserFocus | undefined>[] | readonly csstype.Property.MozUserFocus[] | undefined;
        MozUserModify?: csstype.Property.MozUserModify | readonly NonNullable<csstype.Property.MozUserModify | undefined>[] | readonly csstype.Property.MozUserModify[] | undefined;
        MozUserSelect?: csstype.Property.UserSelect | readonly NonNullable<csstype.Property.UserSelect | undefined>[] | readonly csstype.Property.UserSelect[] | undefined;
        MozWindowDragging?: csstype.Property.MozWindowDragging | readonly NonNullable<csstype.Property.MozWindowDragging | undefined>[] | readonly csstype.Property.MozWindowDragging[] | undefined;
        MozWindowShadow?: csstype.Property.MozWindowShadow | readonly NonNullable<csstype.Property.MozWindowShadow | undefined>[] | readonly csstype.Property.MozWindowShadow[] | undefined;
        msAccelerator?: csstype.Property.MsAccelerator | readonly NonNullable<csstype.Property.MsAccelerator | undefined>[] | readonly csstype.Property.MsAccelerator[] | undefined;
        msBlockProgression?: csstype.Property.MsBlockProgression | readonly NonNullable<csstype.Property.MsBlockProgression | undefined>[] | readonly csstype.Property.MsBlockProgression[] | undefined;
        msContentZoomChaining?: csstype.Property.MsContentZoomChaining | readonly NonNullable<csstype.Property.MsContentZoomChaining | undefined>[] | readonly csstype.Property.MsContentZoomChaining[] | undefined;
        msContentZoomLimitMax?: readonly string[] | csstype.Property.MsContentZoomLimitMax | readonly csstype.Property.MsContentZoomLimitMax[] | undefined;
        msContentZoomLimitMin?: readonly string[] | csstype.Property.MsContentZoomLimitMin | readonly csstype.Property.MsContentZoomLimitMin[] | undefined;
        msContentZoomSnapPoints?: readonly string[] | csstype.Property.MsContentZoomSnapPoints | readonly csstype.Property.MsContentZoomSnapPoints[] | undefined;
        msContentZoomSnapType?: csstype.Property.MsContentZoomSnapType | readonly NonNullable<csstype.Property.MsContentZoomSnapType | undefined>[] | readonly csstype.Property.MsContentZoomSnapType[] | undefined;
        msContentZooming?: csstype.Property.MsContentZooming | readonly NonNullable<csstype.Property.MsContentZooming | undefined>[] | readonly csstype.Property.MsContentZooming[] | undefined;
        msFilter?: readonly string[] | csstype.Property.MsFilter | readonly csstype.Property.MsFilter[] | undefined;
        msFlexDirection?: csstype.Property.FlexDirection | readonly NonNullable<csstype.Property.FlexDirection | undefined>[] | readonly csstype.Property.FlexDirection[] | undefined;
        msFlexPositive?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.FlexGrow | readonly NonNullable<csstype.Property.FlexGrow | undefined>[] | undefined;
        msFlowFrom?: readonly string[] | csstype.Property.MsFlowFrom | readonly csstype.Property.MsFlowFrom[] | undefined;
        msFlowInto?: readonly string[] | csstype.Property.MsFlowInto | readonly csstype.Property.MsFlowInto[] | undefined;
        msGridColumns?: readonly (string | (string & {}))[] | csstype.Property.MsGridColumns<string | number> | readonly NonNullable<csstype.Property.MsGridColumns<string | number> | undefined>[] | undefined;
        msGridRows?: readonly (string | (string & {}))[] | csstype.Property.MsGridRows<string | number> | readonly NonNullable<csstype.Property.MsGridRows<string | number> | undefined>[] | undefined;
        msHighContrastAdjust?: csstype.Property.MsHighContrastAdjust | readonly NonNullable<csstype.Property.MsHighContrastAdjust | undefined>[] | readonly csstype.Property.MsHighContrastAdjust[] | undefined;
        msHyphenateLimitChars?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.MsHyphenateLimitChars | readonly NonNullable<csstype.Property.MsHyphenateLimitChars | undefined>[] | undefined;
        msHyphenateLimitLines?: csstype.Property.MsHyphenateLimitLines | readonly NonNullable<csstype.Property.MsHyphenateLimitLines | undefined>[] | readonly ((string & {}) | csstype.Globals | "no-limit")[] | undefined;
        msHyphenateLimitZone?: readonly (string | (string & {}))[] | csstype.Property.MsHyphenateLimitZone<string | number> | readonly NonNullable<csstype.Property.MsHyphenateLimitZone<string | number> | undefined>[] | undefined;
        msHyphens?: csstype.Property.Hyphens | readonly NonNullable<csstype.Property.Hyphens | undefined>[] | readonly csstype.Property.Hyphens[] | undefined;
        msImeAlign?: csstype.Property.MsImeAlign | readonly NonNullable<csstype.Property.MsImeAlign | undefined>[] | readonly csstype.Property.MsImeAlign[] | undefined;
        msLineBreak?: csstype.Property.LineBreak | readonly NonNullable<csstype.Property.LineBreak | undefined>[] | readonly csstype.Property.LineBreak[] | undefined;
        msOrder?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Order | readonly NonNullable<csstype.Property.Order | undefined>[] | undefined;
        msOverflowStyle?: csstype.Property.MsOverflowStyle | readonly NonNullable<csstype.Property.MsOverflowStyle | undefined>[] | readonly csstype.Property.MsOverflowStyle[] | undefined;
        msOverflowX?: csstype.Property.OverflowX | readonly NonNullable<csstype.Property.OverflowX | undefined>[] | readonly csstype.Property.OverflowX[] | undefined;
        msOverflowY?: csstype.Property.OverflowY | readonly NonNullable<csstype.Property.OverflowY | undefined>[] | readonly csstype.Property.OverflowY[] | undefined;
        msScrollChaining?: csstype.Property.MsScrollChaining | readonly NonNullable<csstype.Property.MsScrollChaining | undefined>[] | readonly csstype.Property.MsScrollChaining[] | undefined;
        msScrollLimitXMax?: readonly string[] | csstype.Property.MsScrollLimitXMax<string | number> | readonly NonNullable<csstype.Property.MsScrollLimitXMax<string | number> | undefined>[] | undefined;
        msScrollLimitXMin?: readonly string[] | csstype.Property.MsScrollLimitXMin<string | number> | readonly NonNullable<csstype.Property.MsScrollLimitXMin<string | number> | undefined>[] | undefined;
        msScrollLimitYMax?: readonly string[] | csstype.Property.MsScrollLimitYMax<string | number> | readonly NonNullable<csstype.Property.MsScrollLimitYMax<string | number> | undefined>[] | undefined;
        msScrollLimitYMin?: readonly string[] | csstype.Property.MsScrollLimitYMin<string | number> | readonly NonNullable<csstype.Property.MsScrollLimitYMin<string | number> | undefined>[] | undefined;
        msScrollRails?: csstype.Property.MsScrollRails | readonly NonNullable<csstype.Property.MsScrollRails | undefined>[] | readonly csstype.Property.MsScrollRails[] | undefined;
        msScrollSnapPointsX?: readonly string[] | csstype.Property.MsScrollSnapPointsX | readonly csstype.Property.MsScrollSnapPointsX[] | undefined;
        msScrollSnapPointsY?: readonly string[] | csstype.Property.MsScrollSnapPointsY | readonly csstype.Property.MsScrollSnapPointsY[] | undefined;
        msScrollSnapType?: csstype.Property.MsScrollSnapType | readonly NonNullable<csstype.Property.MsScrollSnapType | undefined>[] | readonly csstype.Property.MsScrollSnapType[] | undefined;
        msScrollTranslation?: csstype.Property.MsScrollTranslation | readonly NonNullable<csstype.Property.MsScrollTranslation | undefined>[] | readonly csstype.Property.MsScrollTranslation[] | undefined;
        msScrollbar3dlightColor?: readonly string[] | csstype.Property.MsScrollbar3dlightColor | readonly csstype.Property.MsScrollbar3dlightColor[] | undefined;
        msScrollbarArrowColor?: readonly string[] | csstype.Property.MsScrollbarArrowColor | readonly csstype.Property.MsScrollbarArrowColor[] | undefined;
        msScrollbarBaseColor?: readonly string[] | csstype.Property.MsScrollbarBaseColor | readonly csstype.Property.MsScrollbarBaseColor[] | undefined;
        msScrollbarDarkshadowColor?: readonly string[] | csstype.Property.MsScrollbarDarkshadowColor | readonly csstype.Property.MsScrollbarDarkshadowColor[] | undefined;
        msScrollbarFaceColor?: readonly string[] | csstype.Property.MsScrollbarFaceColor | readonly csstype.Property.MsScrollbarFaceColor[] | undefined;
        msScrollbarHighlightColor?: readonly string[] | csstype.Property.MsScrollbarHighlightColor | readonly csstype.Property.MsScrollbarHighlightColor[] | undefined;
        msScrollbarShadowColor?: readonly string[] | csstype.Property.MsScrollbarShadowColor | readonly csstype.Property.MsScrollbarShadowColor[] | undefined;
        msScrollbarTrackColor?: readonly string[] | csstype.Property.MsScrollbarTrackColor | readonly csstype.Property.MsScrollbarTrackColor[] | undefined;
        msTextAutospace?: csstype.Property.MsTextAutospace | readonly NonNullable<csstype.Property.MsTextAutospace | undefined>[] | readonly csstype.Property.MsTextAutospace[] | undefined;
        msTextCombineHorizontal?: readonly string[] | csstype.Property.TextCombineUpright | readonly csstype.Property.TextCombineUpright[] | undefined;
        msTextOverflow?: readonly string[] | csstype.Property.TextOverflow | readonly csstype.Property.TextOverflow[] | undefined;
        msTouchAction?: readonly string[] | csstype.Property.TouchAction | readonly csstype.Property.TouchAction[] | undefined;
        msTouchSelect?: csstype.Property.MsTouchSelect | readonly NonNullable<csstype.Property.MsTouchSelect | undefined>[] | readonly csstype.Property.MsTouchSelect[] | undefined;
        msTransform?: readonly string[] | csstype.Property.Transform | readonly csstype.Property.Transform[] | undefined;
        msTransformOrigin?: readonly (string | (string & {}))[] | csstype.Property.TransformOrigin<string | number> | readonly NonNullable<csstype.Property.TransformOrigin<string | number> | undefined>[] | undefined;
        msTransitionDelay?: readonly string[] | csstype.Property.TransitionDelay<string & {}> | readonly csstype.Property.TransitionDelay<string & {}>[] | undefined;
        msTransitionDuration?: readonly string[] | csstype.Property.TransitionDuration<string & {}> | readonly csstype.Property.TransitionDuration<string & {}>[] | undefined;
        msTransitionProperty?: readonly string[] | csstype.Property.TransitionProperty | readonly csstype.Property.TransitionProperty[] | undefined;
        msTransitionTimingFunction?: readonly string[] | csstype.Property.TransitionTimingFunction | readonly csstype.Property.TransitionTimingFunction[] | undefined;
        msUserSelect?: csstype.Property.MsUserSelect | readonly NonNullable<csstype.Property.MsUserSelect | undefined>[] | readonly csstype.Property.MsUserSelect[] | undefined;
        msWordBreak?: csstype.Property.WordBreak | readonly NonNullable<csstype.Property.WordBreak | undefined>[] | readonly csstype.Property.WordBreak[] | undefined;
        msWrapFlow?: csstype.Property.MsWrapFlow | readonly NonNullable<csstype.Property.MsWrapFlow | undefined>[] | readonly csstype.Property.MsWrapFlow[] | undefined;
        msWrapMargin?: readonly string[] | csstype.Property.MsWrapMargin<string | number> | readonly NonNullable<csstype.Property.MsWrapMargin<string | number> | undefined>[] | undefined;
        msWrapThrough?: csstype.Property.MsWrapThrough | readonly NonNullable<csstype.Property.MsWrapThrough | undefined>[] | readonly csstype.Property.MsWrapThrough[] | undefined;
        msWritingMode?: csstype.Property.WritingMode | readonly NonNullable<csstype.Property.WritingMode | undefined>[] | readonly csstype.Property.WritingMode[] | undefined;
        WebkitAlignContent?: readonly string[] | csstype.Property.AlignContent | readonly csstype.Property.AlignContent[] | undefined;
        WebkitAlignItems?: readonly string[] | csstype.Property.AlignItems | readonly csstype.Property.AlignItems[] | undefined;
        WebkitAlignSelf?: readonly string[] | csstype.Property.AlignSelf | readonly csstype.Property.AlignSelf[] | undefined;
        WebkitAnimationDelay?: readonly string[] | csstype.Property.AnimationDelay<string & {}> | readonly csstype.Property.AnimationDelay<string & {}>[] | undefined;
        WebkitAnimationDirection?: readonly string[] | csstype.Property.AnimationDirection | readonly csstype.Property.AnimationDirection[] | undefined;
        WebkitAnimationDuration?: readonly string[] | csstype.Property.AnimationDuration<string & {}> | readonly csstype.Property.AnimationDuration<string & {}>[] | undefined;
        WebkitAnimationFillMode?: readonly string[] | csstype.Property.AnimationFillMode | readonly csstype.Property.AnimationFillMode[] | undefined;
        WebkitAnimationIterationCount?: csstype.Property.AnimationIterationCount | readonly NonNullable<csstype.Property.AnimationIterationCount | undefined>[] | readonly ((string & {}) | csstype.Globals | "infinite")[] | undefined;
        WebkitAnimationName?: readonly string[] | csstype.Property.AnimationName | readonly csstype.Property.AnimationName[] | undefined;
        WebkitAnimationPlayState?: readonly string[] | csstype.Property.AnimationPlayState | readonly csstype.Property.AnimationPlayState[] | undefined;
        WebkitAnimationTimingFunction?: readonly string[] | csstype.Property.AnimationTimingFunction | readonly csstype.Property.AnimationTimingFunction[] | undefined;
        WebkitAppearance?: csstype.Property.WebkitAppearance | readonly NonNullable<csstype.Property.WebkitAppearance | undefined>[] | readonly csstype.Property.WebkitAppearance[] | undefined;
        WebkitBackdropFilter?: readonly string[] | csstype.Property.BackdropFilter | readonly csstype.Property.BackdropFilter[] | undefined;
        WebkitBackfaceVisibility?: csstype.Property.BackfaceVisibility | readonly NonNullable<csstype.Property.BackfaceVisibility | undefined>[] | readonly csstype.Property.BackfaceVisibility[] | undefined;
        WebkitBackgroundClip?: readonly string[] | csstype.Property.BackgroundClip | readonly csstype.Property.BackgroundClip[] | undefined;
        WebkitBackgroundOrigin?: readonly string[] | csstype.Property.BackgroundOrigin | readonly csstype.Property.BackgroundOrigin[] | undefined;
        WebkitBackgroundSize?: readonly (string | (string & {}))[] | csstype.Property.BackgroundSize<string | number> | readonly NonNullable<csstype.Property.BackgroundSize<string | number> | undefined>[] | undefined;
        WebkitBorderBeforeColor?: readonly string[] | csstype.Property.WebkitBorderBeforeColor | readonly csstype.Property.WebkitBorderBeforeColor[] | undefined;
        WebkitBorderBeforeStyle?: readonly string[] | csstype.Property.WebkitBorderBeforeStyle | readonly csstype.Property.WebkitBorderBeforeStyle[] | undefined;
        WebkitBorderBeforeWidth?: readonly (string | (string & {}))[] | csstype.Property.WebkitBorderBeforeWidth<string | number> | readonly NonNullable<csstype.Property.WebkitBorderBeforeWidth<string | number> | undefined>[] | undefined;
        WebkitBorderBottomLeftRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomLeftRadius<string | number> | undefined>[] | undefined;
        WebkitBorderBottomRightRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomRightRadius<string | number> | undefined>[] | undefined;
        WebkitBorderImageSlice?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BorderImageSlice | readonly NonNullable<csstype.Property.BorderImageSlice | undefined>[] | undefined;
        WebkitBorderTopLeftRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderTopLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopLeftRadius<string | number> | undefined>[] | undefined;
        WebkitBorderTopRightRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderTopRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopRightRadius<string | number> | undefined>[] | undefined;
        WebkitBoxDecorationBreak?: csstype.Property.BoxDecorationBreak | readonly NonNullable<csstype.Property.BoxDecorationBreak | undefined>[] | readonly csstype.Property.BoxDecorationBreak[] | undefined;
        WebkitBoxReflect?: readonly (string | (string & {}))[] | csstype.Property.WebkitBoxReflect<string | number> | readonly NonNullable<csstype.Property.WebkitBoxReflect<string | number> | undefined>[] | undefined;
        WebkitBoxShadow?: readonly string[] | csstype.Property.BoxShadow | readonly csstype.Property.BoxShadow[] | undefined;
        WebkitBoxSizing?: csstype.Property.BoxSizing | readonly NonNullable<csstype.Property.BoxSizing | undefined>[] | readonly csstype.Property.BoxSizing[] | undefined;
        WebkitClipPath?: readonly string[] | csstype.Property.ClipPath | readonly csstype.Property.ClipPath[] | undefined;
        WebkitColumnCount?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.ColumnCount | readonly NonNullable<csstype.Property.ColumnCount | undefined>[] | undefined;
        WebkitColumnFill?: csstype.Property.ColumnFill | readonly NonNullable<csstype.Property.ColumnFill | undefined>[] | readonly csstype.Property.ColumnFill[] | undefined;
        WebkitColumnRuleColor?: readonly string[] | csstype.Property.ColumnRuleColor | readonly csstype.Property.ColumnRuleColor[] | undefined;
        WebkitColumnRuleStyle?: readonly string[] | csstype.Property.ColumnRuleStyle | readonly csstype.Property.ColumnRuleStyle[] | undefined;
        WebkitColumnRuleWidth?: readonly (string | (string & {}))[] | csstype.Property.ColumnRuleWidth<string | number> | readonly NonNullable<csstype.Property.ColumnRuleWidth<string | number> | undefined>[] | undefined;
        WebkitColumnSpan?: csstype.Property.ColumnSpan | readonly NonNullable<csstype.Property.ColumnSpan | undefined>[] | readonly csstype.Property.ColumnSpan[] | undefined;
        WebkitColumnWidth?: readonly string[] | csstype.Property.ColumnWidth<string | number> | readonly NonNullable<csstype.Property.ColumnWidth<string | number> | undefined>[] | undefined;
        WebkitFilter?: readonly string[] | csstype.Property.Filter | readonly csstype.Property.Filter[] | undefined;
        WebkitFlexBasis?: readonly (string | (string & {}))[] | csstype.Property.FlexBasis<string | number> | readonly NonNullable<csstype.Property.FlexBasis<string | number> | undefined>[] | undefined;
        WebkitFlexDirection?: csstype.Property.FlexDirection | readonly NonNullable<csstype.Property.FlexDirection | undefined>[] | readonly csstype.Property.FlexDirection[] | undefined;
        WebkitFlexGrow?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.FlexGrow | readonly NonNullable<csstype.Property.FlexGrow | undefined>[] | undefined;
        WebkitFlexShrink?: csstype.Property.FlexShrink | readonly NonNullable<csstype.Property.FlexShrink | undefined>[] | readonly ((string & {}) | csstype.Globals)[] | undefined;
        WebkitFlexWrap?: csstype.Property.FlexWrap | readonly NonNullable<csstype.Property.FlexWrap | undefined>[] | readonly csstype.Property.FlexWrap[] | undefined;
        WebkitFontFeatureSettings?: readonly string[] | csstype.Property.FontFeatureSettings | readonly csstype.Property.FontFeatureSettings[] | undefined;
        WebkitFontKerning?: csstype.Property.FontKerning | readonly NonNullable<csstype.Property.FontKerning | undefined>[] | readonly csstype.Property.FontKerning[] | undefined;
        WebkitFontSmoothing?: readonly string[] | csstype.Property.FontSmooth<string | number> | readonly NonNullable<csstype.Property.FontSmooth<string | number> | undefined>[] | undefined;
        WebkitFontVariantLigatures?: readonly string[] | csstype.Property.FontVariantLigatures | readonly csstype.Property.FontVariantLigatures[] | undefined;
        WebkitHyphenateCharacter?: readonly string[] | csstype.Property.HyphenateCharacter | readonly csstype.Property.HyphenateCharacter[] | undefined;
        WebkitHyphens?: csstype.Property.Hyphens | readonly NonNullable<csstype.Property.Hyphens | undefined>[] | readonly csstype.Property.Hyphens[] | undefined;
        WebkitInitialLetter?: csstype.Property.InitialLetter | readonly NonNullable<csstype.Property.InitialLetter | undefined>[] | readonly ("normal" | (string & {}) | csstype.Globals)[] | undefined;
        WebkitJustifyContent?: readonly string[] | csstype.Property.JustifyContent | readonly csstype.Property.JustifyContent[] | undefined;
        WebkitLineBreak?: csstype.Property.LineBreak | readonly NonNullable<csstype.Property.LineBreak | undefined>[] | readonly csstype.Property.LineBreak[] | undefined;
        WebkitLineClamp?: readonly ("none" | (string & {}) | csstype.Globals)[] | csstype.Property.WebkitLineClamp | readonly NonNullable<csstype.Property.WebkitLineClamp | undefined>[] | undefined;
        WebkitMarginEnd?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineEnd<string | number> | readonly NonNullable<csstype.Property.MarginInlineEnd<string | number> | undefined>[] | undefined;
        WebkitMarginStart?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineStart<string | number> | readonly NonNullable<csstype.Property.MarginInlineStart<string | number> | undefined>[] | undefined;
        WebkitMaskAttachment?: readonly string[] | csstype.Property.WebkitMaskAttachment | readonly csstype.Property.WebkitMaskAttachment[] | undefined;
        WebkitMaskBoxImageOutset?: readonly (string | (string & {}))[] | csstype.Property.MaskBorderOutset<string | number> | readonly NonNullable<csstype.Property.MaskBorderOutset<string | number> | undefined>[] | undefined;
        WebkitMaskBoxImageRepeat?: readonly string[] | csstype.Property.MaskBorderRepeat | readonly csstype.Property.MaskBorderRepeat[] | undefined;
        WebkitMaskBoxImageSlice?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.MaskBorderSlice | readonly NonNullable<csstype.Property.MaskBorderSlice | undefined>[] | undefined;
        WebkitMaskBoxImageSource?: readonly string[] | csstype.Property.MaskBorderSource | readonly csstype.Property.MaskBorderSource[] | undefined;
        WebkitMaskBoxImageWidth?: readonly (string | (string & {}))[] | csstype.Property.MaskBorderWidth<string | number> | readonly NonNullable<csstype.Property.MaskBorderWidth<string | number> | undefined>[] | undefined;
        WebkitMaskClip?: readonly string[] | csstype.Property.WebkitMaskClip | readonly csstype.Property.WebkitMaskClip[] | undefined;
        WebkitMaskComposite?: readonly string[] | csstype.Property.WebkitMaskComposite | readonly csstype.Property.WebkitMaskComposite[] | undefined;
        WebkitMaskImage?: readonly string[] | csstype.Property.WebkitMaskImage | readonly csstype.Property.WebkitMaskImage[] | undefined;
        WebkitMaskOrigin?: readonly string[] | csstype.Property.WebkitMaskOrigin | readonly csstype.Property.WebkitMaskOrigin[] | undefined;
        WebkitMaskPosition?: readonly (string | (string & {}))[] | csstype.Property.WebkitMaskPosition<string | number> | readonly NonNullable<csstype.Property.WebkitMaskPosition<string | number> | undefined>[] | undefined;
        WebkitMaskPositionX?: readonly (string | (string & {}))[] | csstype.Property.WebkitMaskPositionX<string | number> | readonly NonNullable<csstype.Property.WebkitMaskPositionX<string | number> | undefined>[] | undefined;
        WebkitMaskPositionY?: readonly (string | (string & {}))[] | csstype.Property.WebkitMaskPositionY<string | number> | readonly NonNullable<csstype.Property.WebkitMaskPositionY<string | number> | undefined>[] | undefined;
        WebkitMaskRepeat?: readonly string[] | csstype.Property.WebkitMaskRepeat | readonly csstype.Property.WebkitMaskRepeat[] | undefined;
        WebkitMaskRepeatX?: csstype.Property.WebkitMaskRepeatX | readonly NonNullable<csstype.Property.WebkitMaskRepeatX | undefined>[] | readonly csstype.Property.WebkitMaskRepeatX[] | undefined;
        WebkitMaskRepeatY?: csstype.Property.WebkitMaskRepeatY | readonly NonNullable<csstype.Property.WebkitMaskRepeatY | undefined>[] | readonly csstype.Property.WebkitMaskRepeatY[] | undefined;
        WebkitMaskSize?: readonly (string | (string & {}))[] | csstype.Property.WebkitMaskSize<string | number> | readonly NonNullable<csstype.Property.WebkitMaskSize<string | number> | undefined>[] | undefined;
        WebkitMaxInlineSize?: readonly (string | (string & {}))[] | csstype.Property.MaxInlineSize<string | number> | readonly NonNullable<csstype.Property.MaxInlineSize<string | number> | undefined>[] | undefined;
        WebkitOrder?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Order | readonly NonNullable<csstype.Property.Order | undefined>[] | undefined;
        WebkitOverflowScrolling?: csstype.Property.WebkitOverflowScrolling | readonly NonNullable<csstype.Property.WebkitOverflowScrolling | undefined>[] | readonly csstype.Property.WebkitOverflowScrolling[] | undefined;
        WebkitPaddingEnd?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineEnd<string | number> | readonly NonNullable<csstype.Property.PaddingInlineEnd<string | number> | undefined>[] | undefined;
        WebkitPaddingStart?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineStart<string | number> | readonly NonNullable<csstype.Property.PaddingInlineStart<string | number> | undefined>[] | undefined;
        WebkitPerspective?: readonly string[] | csstype.Property.Perspective<string | number> | readonly NonNullable<csstype.Property.Perspective<string | number> | undefined>[] | undefined;
        WebkitPerspectiveOrigin?: readonly (string | (string & {}))[] | csstype.Property.PerspectiveOrigin<string | number> | readonly NonNullable<csstype.Property.PerspectiveOrigin<string | number> | undefined>[] | undefined;
        WebkitPrintColorAdjust?: csstype.Property.PrintColorAdjust | readonly NonNullable<csstype.Property.PrintColorAdjust | undefined>[] | readonly csstype.Property.PrintColorAdjust[] | undefined;
        WebkitRubyPosition?: readonly string[] | csstype.Property.RubyPosition | readonly csstype.Property.RubyPosition[] | undefined;
        WebkitScrollSnapType?: readonly string[] | csstype.Property.ScrollSnapType | readonly csstype.Property.ScrollSnapType[] | undefined;
        WebkitShapeMargin?: readonly (string | (string & {}))[] | csstype.Property.ShapeMargin<string | number> | readonly NonNullable<csstype.Property.ShapeMargin<string | number> | undefined>[] | undefined;
        WebkitTapHighlightColor?: readonly string[] | csstype.Property.WebkitTapHighlightColor | readonly csstype.Property.WebkitTapHighlightColor[] | undefined;
        WebkitTextCombine?: readonly string[] | csstype.Property.TextCombineUpright | readonly csstype.Property.TextCombineUpright[] | undefined;
        WebkitTextDecorationColor?: readonly string[] | csstype.Property.TextDecorationColor | readonly csstype.Property.TextDecorationColor[] | undefined;
        WebkitTextDecorationLine?: readonly string[] | csstype.Property.TextDecorationLine | readonly csstype.Property.TextDecorationLine[] | undefined;
        WebkitTextDecorationSkip?: readonly string[] | csstype.Property.TextDecorationSkip | readonly csstype.Property.TextDecorationSkip[] | undefined;
        WebkitTextDecorationStyle?: csstype.Property.TextDecorationStyle | readonly NonNullable<csstype.Property.TextDecorationStyle | undefined>[] | readonly csstype.Property.TextDecorationStyle[] | undefined;
        WebkitTextEmphasisColor?: readonly string[] | csstype.Property.TextEmphasisColor | readonly csstype.Property.TextEmphasisColor[] | undefined;
        WebkitTextEmphasisPosition?: readonly string[] | csstype.Property.TextEmphasisPosition | readonly csstype.Property.TextEmphasisPosition[] | undefined;
        WebkitTextEmphasisStyle?: readonly string[] | csstype.Property.TextEmphasisStyle | readonly csstype.Property.TextEmphasisStyle[] | undefined;
        WebkitTextFillColor?: readonly string[] | csstype.Property.WebkitTextFillColor | readonly csstype.Property.WebkitTextFillColor[] | undefined;
        WebkitTextOrientation?: csstype.Property.TextOrientation | readonly NonNullable<csstype.Property.TextOrientation | undefined>[] | readonly csstype.Property.TextOrientation[] | undefined;
        WebkitTextSizeAdjust?: readonly string[] | csstype.Property.TextSizeAdjust | readonly csstype.Property.TextSizeAdjust[] | undefined;
        WebkitTextStrokeColor?: readonly string[] | csstype.Property.WebkitTextStrokeColor | readonly csstype.Property.WebkitTextStrokeColor[] | undefined;
        WebkitTextStrokeWidth?: readonly string[] | csstype.Property.WebkitTextStrokeWidth<string | number> | readonly NonNullable<csstype.Property.WebkitTextStrokeWidth<string | number> | undefined>[] | undefined;
        WebkitTextUnderlinePosition?: readonly string[] | csstype.Property.TextUnderlinePosition | readonly csstype.Property.TextUnderlinePosition[] | undefined;
        WebkitTouchCallout?: csstype.Property.WebkitTouchCallout | readonly NonNullable<csstype.Property.WebkitTouchCallout | undefined>[] | readonly csstype.Property.WebkitTouchCallout[] | undefined;
        WebkitTransform?: readonly string[] | csstype.Property.Transform | readonly csstype.Property.Transform[] | undefined;
        WebkitTransformOrigin?: readonly (string | (string & {}))[] | csstype.Property.TransformOrigin<string | number> | readonly NonNullable<csstype.Property.TransformOrigin<string | number> | undefined>[] | undefined;
        WebkitTransformStyle?: csstype.Property.TransformStyle | readonly NonNullable<csstype.Property.TransformStyle | undefined>[] | readonly csstype.Property.TransformStyle[] | undefined;
        WebkitTransitionDelay?: readonly string[] | csstype.Property.TransitionDelay<string & {}> | readonly csstype.Property.TransitionDelay<string & {}>[] | undefined;
        WebkitTransitionDuration?: readonly string[] | csstype.Property.TransitionDuration<string & {}> | readonly csstype.Property.TransitionDuration<string & {}>[] | undefined;
        WebkitTransitionProperty?: readonly string[] | csstype.Property.TransitionProperty | readonly csstype.Property.TransitionProperty[] | undefined;
        WebkitTransitionTimingFunction?: readonly string[] | csstype.Property.TransitionTimingFunction | readonly csstype.Property.TransitionTimingFunction[] | undefined;
        WebkitUserModify?: csstype.Property.WebkitUserModify | readonly NonNullable<csstype.Property.WebkitUserModify | undefined>[] | readonly csstype.Property.WebkitUserModify[] | undefined;
        WebkitUserSelect?: csstype.Property.UserSelect | readonly NonNullable<csstype.Property.UserSelect | undefined>[] | readonly csstype.Property.UserSelect[] | undefined;
        WebkitWritingMode?: csstype.Property.WritingMode | readonly NonNullable<csstype.Property.WritingMode | undefined>[] | readonly csstype.Property.WritingMode[] | undefined;
        MozAnimation?: csstype.Property.Animation<string & {}> | readonly NonNullable<csstype.Property.Animation<string & {}> | undefined>[] | readonly ("linear" | "auto" | "none" | "normal" | "reverse" | "paused" | (string & {}) | csstype.Globals | "ease" | "ease-in" | "ease-in-out" | "ease-out" | "step-end" | "step-start" | "alternate" | "alternate-reverse" | "backwards" | "both" | "forwards" | "infinite" | "running")[] | undefined;
        MozBorderImage?: csstype.Property.BorderImage | readonly NonNullable<csstype.Property.BorderImage | undefined>[] | readonly ("none" | "repeat" | "round" | (string & {}) | csstype.Globals | "space" | "stretch")[] | undefined;
        MozColumnRule?: readonly (string | (string & {}))[] | csstype.Property.ColumnRule<string | number> | readonly NonNullable<csstype.Property.ColumnRule<string | number> | undefined>[] | undefined;
        MozColumns?: readonly (string | (string & {}))[] | csstype.Property.Columns<string | number> | readonly NonNullable<csstype.Property.Columns<string | number> | undefined>[] | undefined;
        MozOutlineRadius?: readonly (string | (string & {}))[] | csstype.Property.MozOutlineRadius<string | number> | readonly NonNullable<csstype.Property.MozOutlineRadius<string | number> | undefined>[] | undefined;
        msContentZoomLimit?: readonly string[] | csstype.Property.MsContentZoomLimit | readonly csstype.Property.MsContentZoomLimit[] | undefined;
        msContentZoomSnap?: readonly string[] | csstype.Property.MsContentZoomSnap | readonly csstype.Property.MsContentZoomSnap[] | undefined;
        msFlex?: readonly (string | (string & {}))[] | csstype.Property.Flex<string | number> | readonly NonNullable<csstype.Property.Flex<string | number> | undefined>[] | undefined;
        msScrollLimit?: readonly string[] | csstype.Property.MsScrollLimit | readonly csstype.Property.MsScrollLimit[] | undefined;
        msScrollSnapX?: readonly string[] | csstype.Property.MsScrollSnapX | readonly csstype.Property.MsScrollSnapX[] | undefined;
        msScrollSnapY?: readonly string[] | csstype.Property.MsScrollSnapY | readonly csstype.Property.MsScrollSnapY[] | undefined;
        msTransition?: readonly string[] | csstype.Property.Transition<string & {}> | readonly csstype.Property.Transition<string & {}>[] | undefined;
        WebkitAnimation?: csstype.Property.Animation<string & {}> | readonly NonNullable<csstype.Property.Animation<string & {}> | undefined>[] | readonly ("linear" | "auto" | "none" | "normal" | "reverse" | "paused" | (string & {}) | csstype.Globals | "ease" | "ease-in" | "ease-in-out" | "ease-out" | "step-end" | "step-start" | "alternate" | "alternate-reverse" | "backwards" | "both" | "forwards" | "infinite" | "running")[] | undefined;
        WebkitBorderBefore?: readonly (string | (string & {}))[] | csstype.Property.WebkitBorderBefore<string | number> | readonly NonNullable<csstype.Property.WebkitBorderBefore<string | number> | undefined>[] | undefined;
        WebkitBorderImage?: csstype.Property.BorderImage | readonly NonNullable<csstype.Property.BorderImage | undefined>[] | readonly ("none" | "repeat" | "round" | (string & {}) | csstype.Globals | "space" | "stretch")[] | undefined;
        WebkitBorderRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderRadius<string | number> | readonly NonNullable<csstype.Property.BorderRadius<string | number> | undefined>[] | undefined;
        WebkitColumnRule?: readonly (string | (string & {}))[] | csstype.Property.ColumnRule<string | number> | readonly NonNullable<csstype.Property.ColumnRule<string | number> | undefined>[] | undefined;
        WebkitColumns?: readonly (string | (string & {}))[] | csstype.Property.Columns<string | number> | readonly NonNullable<csstype.Property.Columns<string | number> | undefined>[] | undefined;
        WebkitFlex?: readonly (string | (string & {}))[] | csstype.Property.Flex<string | number> | readonly NonNullable<csstype.Property.Flex<string | number> | undefined>[] | undefined;
        WebkitFlexFlow?: readonly string[] | csstype.Property.FlexFlow | readonly csstype.Property.FlexFlow[] | undefined;
        WebkitMask?: readonly (string | (string & {}))[] | csstype.Property.WebkitMask<string | number> | readonly NonNullable<csstype.Property.WebkitMask<string | number> | undefined>[] | undefined;
        WebkitMaskBoxImage?: csstype.Property.MaskBorder | readonly NonNullable<csstype.Property.MaskBorder | undefined>[] | readonly ("none" | "repeat" | "alpha" | "round" | (string & {}) | csstype.Globals | "space" | "stretch" | "luminance")[] | undefined;
        WebkitTextEmphasis?: readonly string[] | csstype.Property.TextEmphasis | readonly csstype.Property.TextEmphasis[] | undefined;
        WebkitTextStroke?: readonly (string | (string & {}))[] | csstype.Property.WebkitTextStroke<string | number> | readonly NonNullable<csstype.Property.WebkitTextStroke<string | number> | undefined>[] | undefined;
        WebkitTransition?: readonly string[] | csstype.Property.Transition<string & {}> | readonly csstype.Property.Transition<string & {}>[] | undefined;
        azimuth?: readonly string[] | csstype.Property.Azimuth | readonly csstype.Property.Azimuth[] | undefined;
        boxAlign?: csstype.Property.BoxAlign | readonly NonNullable<csstype.Property.BoxAlign | undefined>[] | readonly csstype.Property.BoxAlign[] | undefined;
        boxDirection?: csstype.Property.BoxDirection | readonly NonNullable<csstype.Property.BoxDirection | undefined>[] | readonly csstype.Property.BoxDirection[] | undefined;
        boxFlex?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlex | readonly NonNullable<csstype.Property.BoxFlex | undefined>[] | undefined;
        boxFlexGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlexGroup | readonly NonNullable<csstype.Property.BoxFlexGroup | undefined>[] | undefined;
        boxLines?: csstype.Property.BoxLines | readonly NonNullable<csstype.Property.BoxLines | undefined>[] | readonly csstype.Property.BoxLines[] | undefined;
        boxOrdinalGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxOrdinalGroup | readonly NonNullable<csstype.Property.BoxOrdinalGroup | undefined>[] | undefined;
        boxOrient?: csstype.Property.BoxOrient | readonly NonNullable<csstype.Property.BoxOrient | undefined>[] | readonly csstype.Property.BoxOrient[] | undefined;
        boxPack?: csstype.Property.BoxPack | readonly NonNullable<csstype.Property.BoxPack | undefined>[] | readonly csstype.Property.BoxPack[] | undefined;
        clip?: readonly string[] | csstype.Property.Clip | readonly csstype.Property.Clip[] | undefined;
        gridColumnGap?: readonly (string | (string & {}))[] | csstype.Property.GridColumnGap<string | number> | readonly NonNullable<csstype.Property.GridColumnGap<string | number> | undefined>[] | undefined;
        gridGap?: readonly (string | (string & {}))[] | csstype.Property.GridGap<string | number> | readonly NonNullable<csstype.Property.GridGap<string | number> | undefined>[] | undefined;
        gridRowGap?: readonly (string | (string & {}))[] | csstype.Property.GridRowGap<string | number> | readonly NonNullable<csstype.Property.GridRowGap<string | number> | undefined>[] | undefined;
        imeMode?: csstype.Property.ImeMode | readonly NonNullable<csstype.Property.ImeMode | undefined>[] | readonly csstype.Property.ImeMode[] | undefined;
        offsetBlock?: readonly (string | (string & {}))[] | csstype.Property.InsetBlock<string | number> | readonly NonNullable<csstype.Property.InsetBlock<string | number> | undefined>[] | undefined;
        offsetBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.InsetBlockEnd<string | number> | readonly NonNullable<csstype.Property.InsetBlockEnd<string | number> | undefined>[] | undefined;
        offsetBlockStart?: readonly (string | (string & {}))[] | csstype.Property.InsetBlockStart<string | number> | readonly NonNullable<csstype.Property.InsetBlockStart<string | number> | undefined>[] | undefined;
        offsetInline?: readonly (string | (string & {}))[] | csstype.Property.InsetInline<string | number> | readonly NonNullable<csstype.Property.InsetInline<string | number> | undefined>[] | undefined;
        offsetInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.InsetInlineEnd<string | number> | readonly NonNullable<csstype.Property.InsetInlineEnd<string | number> | undefined>[] | undefined;
        offsetInlineStart?: readonly (string | (string & {}))[] | csstype.Property.InsetInlineStart<string | number> | readonly NonNullable<csstype.Property.InsetInlineStart<string | number> | undefined>[] | undefined;
        scrollSnapCoordinate?: readonly (string | (string & {}))[] | csstype.Property.ScrollSnapCoordinate<string | number> | readonly NonNullable<csstype.Property.ScrollSnapCoordinate<string | number> | undefined>[] | undefined;
        scrollSnapDestination?: readonly (string | (string & {}))[] | csstype.Property.ScrollSnapDestination<string | number> | readonly NonNullable<csstype.Property.ScrollSnapDestination<string | number> | undefined>[] | undefined;
        scrollSnapPointsX?: readonly string[] | csstype.Property.ScrollSnapPointsX | readonly csstype.Property.ScrollSnapPointsX[] | undefined;
        scrollSnapPointsY?: readonly string[] | csstype.Property.ScrollSnapPointsY | readonly csstype.Property.ScrollSnapPointsY[] | undefined;
        scrollSnapTypeX?: csstype.Property.ScrollSnapTypeX | readonly NonNullable<csstype.Property.ScrollSnapTypeX | undefined>[] | readonly csstype.Property.ScrollSnapTypeX[] | undefined;
        scrollSnapTypeY?: csstype.Property.ScrollSnapTypeY | readonly NonNullable<csstype.Property.ScrollSnapTypeY | undefined>[] | readonly csstype.Property.ScrollSnapTypeY[] | undefined;
        KhtmlBoxAlign?: csstype.Property.BoxAlign | readonly NonNullable<csstype.Property.BoxAlign | undefined>[] | readonly csstype.Property.BoxAlign[] | undefined;
        KhtmlBoxDirection?: csstype.Property.BoxDirection | readonly NonNullable<csstype.Property.BoxDirection | undefined>[] | readonly csstype.Property.BoxDirection[] | undefined;
        KhtmlBoxFlex?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlex | readonly NonNullable<csstype.Property.BoxFlex | undefined>[] | undefined;
        KhtmlBoxFlexGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlexGroup | readonly NonNullable<csstype.Property.BoxFlexGroup | undefined>[] | undefined;
        KhtmlBoxLines?: csstype.Property.BoxLines | readonly NonNullable<csstype.Property.BoxLines | undefined>[] | readonly csstype.Property.BoxLines[] | undefined;
        KhtmlBoxOrdinalGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxOrdinalGroup | readonly NonNullable<csstype.Property.BoxOrdinalGroup | undefined>[] | undefined;
        KhtmlBoxOrient?: csstype.Property.BoxOrient | readonly NonNullable<csstype.Property.BoxOrient | undefined>[] | readonly csstype.Property.BoxOrient[] | undefined;
        KhtmlBoxPack?: csstype.Property.BoxPack | readonly NonNullable<csstype.Property.BoxPack | undefined>[] | readonly csstype.Property.BoxPack[] | undefined;
        KhtmlLineBreak?: csstype.Property.LineBreak | readonly NonNullable<csstype.Property.LineBreak | undefined>[] | readonly csstype.Property.LineBreak[] | undefined;
        KhtmlOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Opacity | readonly NonNullable<csstype.Property.Opacity | undefined>[] | undefined;
        KhtmlUserSelect?: csstype.Property.UserSelect | readonly NonNullable<csstype.Property.UserSelect | undefined>[] | readonly csstype.Property.UserSelect[] | undefined;
        MozBackfaceVisibility?: csstype.Property.BackfaceVisibility | readonly NonNullable<csstype.Property.BackfaceVisibility | undefined>[] | readonly csstype.Property.BackfaceVisibility[] | undefined;
        MozBackgroundClip?: readonly string[] | csstype.Property.BackgroundClip | readonly csstype.Property.BackgroundClip[] | undefined;
        MozBackgroundInlinePolicy?: csstype.Property.BoxDecorationBreak | readonly NonNullable<csstype.Property.BoxDecorationBreak | undefined>[] | readonly csstype.Property.BoxDecorationBreak[] | undefined;
        MozBackgroundOrigin?: readonly string[] | csstype.Property.BackgroundOrigin | readonly csstype.Property.BackgroundOrigin[] | undefined;
        MozBackgroundSize?: readonly (string | (string & {}))[] | csstype.Property.BackgroundSize<string | number> | readonly NonNullable<csstype.Property.BackgroundSize<string | number> | undefined>[] | undefined;
        MozBorderRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderRadius<string | number> | readonly NonNullable<csstype.Property.BorderRadius<string | number> | undefined>[] | undefined;
        MozBorderRadiusBottomleft?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomLeftRadius<string | number> | undefined>[] | undefined;
        MozBorderRadiusBottomright?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomRightRadius<string | number> | undefined>[] | undefined;
        MozBorderRadiusTopleft?: readonly (string | (string & {}))[] | csstype.Property.BorderTopLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopLeftRadius<string | number> | undefined>[] | undefined;
        MozBorderRadiusTopright?: readonly (string | (string & {}))[] | csstype.Property.BorderTopRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopRightRadius<string | number> | undefined>[] | undefined;
        MozBoxAlign?: csstype.Property.BoxAlign | readonly NonNullable<csstype.Property.BoxAlign | undefined>[] | readonly csstype.Property.BoxAlign[] | undefined;
        MozBoxDirection?: csstype.Property.BoxDirection | readonly NonNullable<csstype.Property.BoxDirection | undefined>[] | readonly csstype.Property.BoxDirection[] | undefined;
        MozBoxFlex?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlex | readonly NonNullable<csstype.Property.BoxFlex | undefined>[] | undefined;
        MozBoxOrdinalGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxOrdinalGroup | readonly NonNullable<csstype.Property.BoxOrdinalGroup | undefined>[] | undefined;
        MozBoxOrient?: csstype.Property.BoxOrient | readonly NonNullable<csstype.Property.BoxOrient | undefined>[] | readonly csstype.Property.BoxOrient[] | undefined;
        MozBoxPack?: csstype.Property.BoxPack | readonly NonNullable<csstype.Property.BoxPack | undefined>[] | readonly csstype.Property.BoxPack[] | undefined;
        MozBoxShadow?: readonly string[] | csstype.Property.BoxShadow | readonly csstype.Property.BoxShadow[] | undefined;
        MozFloatEdge?: csstype.Property.MozFloatEdge | readonly NonNullable<csstype.Property.MozFloatEdge | undefined>[] | readonly csstype.Property.MozFloatEdge[] | undefined;
        MozForceBrokenImageIcon?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.MozForceBrokenImageIcon | readonly NonNullable<csstype.Property.MozForceBrokenImageIcon | undefined>[] | undefined;
        MozOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Opacity | readonly NonNullable<csstype.Property.Opacity | undefined>[] | undefined;
        MozOutline?: readonly (string | (string & {}))[] | csstype.Property.Outline<string | number> | readonly NonNullable<csstype.Property.Outline<string | number> | undefined>[] | undefined;
        MozOutlineColor?: readonly string[] | csstype.Property.OutlineColor | readonly csstype.Property.OutlineColor[] | undefined;
        MozOutlineStyle?: readonly string[] | csstype.Property.OutlineStyle | readonly csstype.Property.OutlineStyle[] | undefined;
        MozOutlineWidth?: readonly string[] | csstype.Property.OutlineWidth<string | number> | readonly NonNullable<csstype.Property.OutlineWidth<string | number> | undefined>[] | undefined;
        MozPerspective?: readonly string[] | csstype.Property.Perspective<string | number> | readonly NonNullable<csstype.Property.Perspective<string | number> | undefined>[] | undefined;
        MozPerspectiveOrigin?: readonly (string | (string & {}))[] | csstype.Property.PerspectiveOrigin<string | number> | readonly NonNullable<csstype.Property.PerspectiveOrigin<string | number> | undefined>[] | undefined;
        MozTextAlignLast?: csstype.Property.TextAlignLast | readonly NonNullable<csstype.Property.TextAlignLast | undefined>[] | readonly csstype.Property.TextAlignLast[] | undefined;
        MozTextDecorationColor?: readonly string[] | csstype.Property.TextDecorationColor | readonly csstype.Property.TextDecorationColor[] | undefined;
        MozTextDecorationLine?: readonly string[] | csstype.Property.TextDecorationLine | readonly csstype.Property.TextDecorationLine[] | undefined;
        MozTextDecorationStyle?: csstype.Property.TextDecorationStyle | readonly NonNullable<csstype.Property.TextDecorationStyle | undefined>[] | readonly csstype.Property.TextDecorationStyle[] | undefined;
        MozTransform?: readonly string[] | csstype.Property.Transform | readonly csstype.Property.Transform[] | undefined;
        MozTransformOrigin?: readonly (string | (string & {}))[] | csstype.Property.TransformOrigin<string | number> | readonly NonNullable<csstype.Property.TransformOrigin<string | number> | undefined>[] | undefined;
        MozTransformStyle?: csstype.Property.TransformStyle | readonly NonNullable<csstype.Property.TransformStyle | undefined>[] | readonly csstype.Property.TransformStyle[] | undefined;
        MozTransition?: readonly string[] | csstype.Property.Transition<string & {}> | readonly csstype.Property.Transition<string & {}>[] | undefined;
        MozTransitionDelay?: readonly string[] | csstype.Property.TransitionDelay<string & {}> | readonly csstype.Property.TransitionDelay<string & {}>[] | undefined;
        MozTransitionDuration?: readonly string[] | csstype.Property.TransitionDuration<string & {}> | readonly csstype.Property.TransitionDuration<string & {}>[] | undefined;
        MozTransitionProperty?: readonly string[] | csstype.Property.TransitionProperty | readonly csstype.Property.TransitionProperty[] | undefined;
        MozTransitionTimingFunction?: readonly string[] | csstype.Property.TransitionTimingFunction | readonly csstype.Property.TransitionTimingFunction[] | undefined;
        MozUserInput?: csstype.Property.MozUserInput | readonly NonNullable<csstype.Property.MozUserInput | undefined>[] | readonly csstype.Property.MozUserInput[] | undefined;
        msImeMode?: csstype.Property.ImeMode | readonly NonNullable<csstype.Property.ImeMode | undefined>[] | readonly csstype.Property.ImeMode[] | undefined;
        OAnimation?: csstype.Property.Animation<string & {}> | readonly NonNullable<csstype.Property.Animation<string & {}> | undefined>[] | readonly ("linear" | "auto" | "none" | "normal" | "reverse" | "paused" | (string & {}) | csstype.Globals | "ease" | "ease-in" | "ease-in-out" | "ease-out" | "step-end" | "step-start" | "alternate" | "alternate-reverse" | "backwards" | "both" | "forwards" | "infinite" | "running")[] | undefined;
        OAnimationDelay?: readonly string[] | csstype.Property.AnimationDelay<string & {}> | readonly csstype.Property.AnimationDelay<string & {}>[] | undefined;
        OAnimationDirection?: readonly string[] | csstype.Property.AnimationDirection | readonly csstype.Property.AnimationDirection[] | undefined;
        OAnimationDuration?: readonly string[] | csstype.Property.AnimationDuration<string & {}> | readonly csstype.Property.AnimationDuration<string & {}>[] | undefined;
        OAnimationFillMode?: readonly string[] | csstype.Property.AnimationFillMode | readonly csstype.Property.AnimationFillMode[] | undefined;
        OAnimationIterationCount?: csstype.Property.AnimationIterationCount | readonly NonNullable<csstype.Property.AnimationIterationCount | undefined>[] | readonly ((string & {}) | csstype.Globals | "infinite")[] | undefined;
        OAnimationName?: readonly string[] | csstype.Property.AnimationName | readonly csstype.Property.AnimationName[] | undefined;
        OAnimationPlayState?: readonly string[] | csstype.Property.AnimationPlayState | readonly csstype.Property.AnimationPlayState[] | undefined;
        OAnimationTimingFunction?: readonly string[] | csstype.Property.AnimationTimingFunction | readonly csstype.Property.AnimationTimingFunction[] | undefined;
        OBackgroundSize?: readonly (string | (string & {}))[] | csstype.Property.BackgroundSize<string | number> | readonly NonNullable<csstype.Property.BackgroundSize<string | number> | undefined>[] | undefined;
        OBorderImage?: csstype.Property.BorderImage | readonly NonNullable<csstype.Property.BorderImage | undefined>[] | readonly ("none" | "repeat" | "round" | (string & {}) | csstype.Globals | "space" | "stretch")[] | undefined;
        OObjectFit?: csstype.Property.ObjectFit | readonly NonNullable<csstype.Property.ObjectFit | undefined>[] | readonly csstype.Property.ObjectFit[] | undefined;
        OObjectPosition?: readonly (string | (string & {}))[] | csstype.Property.ObjectPosition<string | number> | readonly NonNullable<csstype.Property.ObjectPosition<string | number> | undefined>[] | undefined;
        OTabSize?: readonly (string | (string & {}))[] | csstype.Property.TabSize<string | number> | readonly NonNullable<csstype.Property.TabSize<string | number> | undefined>[] | undefined;
        OTextOverflow?: readonly string[] | csstype.Property.TextOverflow | readonly csstype.Property.TextOverflow[] | undefined;
        OTransform?: readonly string[] | csstype.Property.Transform | readonly csstype.Property.Transform[] | undefined;
        OTransformOrigin?: readonly (string | (string & {}))[] | csstype.Property.TransformOrigin<string | number> | readonly NonNullable<csstype.Property.TransformOrigin<string | number> | undefined>[] | undefined;
        OTransition?: readonly string[] | csstype.Property.Transition<string & {}> | readonly csstype.Property.Transition<string & {}>[] | undefined;
        OTransitionDelay?: readonly string[] | csstype.Property.TransitionDelay<string & {}> | readonly csstype.Property.TransitionDelay<string & {}>[] | undefined;
        OTransitionDuration?: readonly string[] | csstype.Property.TransitionDuration<string & {}> | readonly csstype.Property.TransitionDuration<string & {}>[] | undefined;
        OTransitionProperty?: readonly string[] | csstype.Property.TransitionProperty | readonly csstype.Property.TransitionProperty[] | undefined;
        OTransitionTimingFunction?: readonly string[] | csstype.Property.TransitionTimingFunction | readonly csstype.Property.TransitionTimingFunction[] | undefined;
        WebkitBoxAlign?: csstype.Property.BoxAlign | readonly NonNullable<csstype.Property.BoxAlign | undefined>[] | readonly csstype.Property.BoxAlign[] | undefined;
        WebkitBoxDirection?: csstype.Property.BoxDirection | readonly NonNullable<csstype.Property.BoxDirection | undefined>[] | readonly csstype.Property.BoxDirection[] | undefined;
        WebkitBoxFlex?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlex | readonly NonNullable<csstype.Property.BoxFlex | undefined>[] | undefined;
        WebkitBoxFlexGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlexGroup | readonly NonNullable<csstype.Property.BoxFlexGroup | undefined>[] | undefined;
        WebkitBoxLines?: csstype.Property.BoxLines | readonly NonNullable<csstype.Property.BoxLines | undefined>[] | readonly csstype.Property.BoxLines[] | undefined;
        WebkitBoxOrdinalGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxOrdinalGroup | readonly NonNullable<csstype.Property.BoxOrdinalGroup | undefined>[] | undefined;
        WebkitBoxOrient?: csstype.Property.BoxOrient | readonly NonNullable<csstype.Property.BoxOrient | undefined>[] | readonly csstype.Property.BoxOrient[] | undefined;
        WebkitBoxPack?: csstype.Property.BoxPack | readonly NonNullable<csstype.Property.BoxPack | undefined>[] | readonly csstype.Property.BoxPack[] | undefined;
        alignmentBaseline?: csstype.Property.AlignmentBaseline | readonly NonNullable<csstype.Property.AlignmentBaseline | undefined>[] | readonly csstype.Property.AlignmentBaseline[] | undefined;
        baselineShift?: readonly (string | (string & {}))[] | csstype.Property.BaselineShift<string | number> | readonly NonNullable<csstype.Property.BaselineShift<string | number> | undefined>[] | undefined;
        clipRule?: csstype.Property.ClipRule | readonly NonNullable<csstype.Property.ClipRule | undefined>[] | readonly csstype.Property.ClipRule[] | undefined;
        colorInterpolation?: csstype.Property.ColorInterpolation | readonly NonNullable<csstype.Property.ColorInterpolation | undefined>[] | readonly csstype.Property.ColorInterpolation[] | undefined;
        colorRendering?: csstype.Property.ColorRendering | readonly NonNullable<csstype.Property.ColorRendering | undefined>[] | readonly csstype.Property.ColorRendering[] | undefined;
        dominantBaseline?: csstype.Property.DominantBaseline | readonly NonNullable<csstype.Property.DominantBaseline | undefined>[] | readonly csstype.Property.DominantBaseline[] | undefined;
        fill?: readonly string[] | csstype.Property.Fill | readonly csstype.Property.Fill[] | undefined;
        fillOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.FillOpacity | readonly NonNullable<csstype.Property.FillOpacity | undefined>[] | undefined;
        fillRule?: csstype.Property.FillRule | readonly NonNullable<csstype.Property.FillRule | undefined>[] | readonly csstype.Property.FillRule[] | undefined;
        floodColor?: readonly string[] | csstype.Property.FloodColor | readonly csstype.Property.FloodColor[] | undefined;
        floodOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.FloodOpacity | readonly NonNullable<csstype.Property.FloodOpacity | undefined>[] | undefined;
        glyphOrientationVertical?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GlyphOrientationVertical | readonly NonNullable<csstype.Property.GlyphOrientationVertical | undefined>[] | undefined;
        lightingColor?: readonly string[] | csstype.Property.LightingColor | readonly csstype.Property.LightingColor[] | undefined;
        marker?: readonly string[] | csstype.Property.Marker | readonly csstype.Property.Marker[] | undefined;
        markerEnd?: readonly string[] | csstype.Property.MarkerEnd | readonly csstype.Property.MarkerEnd[] | undefined;
        markerMid?: readonly string[] | csstype.Property.MarkerMid | readonly csstype.Property.MarkerMid[] | undefined;
        markerStart?: readonly string[] | csstype.Property.MarkerStart | readonly csstype.Property.MarkerStart[] | undefined;
        shapeRendering?: csstype.Property.ShapeRendering | readonly NonNullable<csstype.Property.ShapeRendering | undefined>[] | readonly csstype.Property.ShapeRendering[] | undefined;
        stopColor?: readonly string[] | csstype.Property.StopColor | readonly csstype.Property.StopColor[] | undefined;
        stopOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.StopOpacity | readonly NonNullable<csstype.Property.StopOpacity | undefined>[] | undefined;
        stroke?: readonly string[] | csstype.Property.Stroke | readonly csstype.Property.Stroke[] | undefined;
        strokeDasharray?: readonly (string | (string & {}))[] | csstype.Property.StrokeDasharray<string | number> | readonly NonNullable<csstype.Property.StrokeDasharray<string | number> | undefined>[] | undefined;
        strokeDashoffset?: readonly (string | (string & {}))[] | csstype.Property.StrokeDashoffset<string | number> | readonly NonNullable<csstype.Property.StrokeDashoffset<string | number> | undefined>[] | undefined;
        strokeLinecap?: csstype.Property.StrokeLinecap | readonly NonNullable<csstype.Property.StrokeLinecap | undefined>[] | readonly csstype.Property.StrokeLinecap[] | undefined;
        strokeLinejoin?: csstype.Property.StrokeLinejoin | readonly NonNullable<csstype.Property.StrokeLinejoin | undefined>[] | readonly csstype.Property.StrokeLinejoin[] | undefined;
        strokeMiterlimit?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.StrokeMiterlimit | readonly NonNullable<csstype.Property.StrokeMiterlimit | undefined>[] | undefined;
        strokeOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.StrokeOpacity | readonly NonNullable<csstype.Property.StrokeOpacity | undefined>[] | undefined;
        strokeWidth?: readonly (string | (string & {}))[] | csstype.Property.StrokeWidth<string | number> | readonly NonNullable<csstype.Property.StrokeWidth<string | number> | undefined>[] | undefined;
        textAnchor?: csstype.Property.TextAnchor | readonly NonNullable<csstype.Property.TextAnchor | undefined>[] | readonly csstype.Property.TextAnchor[] | undefined;
        vectorEffect?: csstype.Property.VectorEffect | readonly NonNullable<csstype.Property.VectorEffect | undefined>[] | readonly csstype.Property.VectorEffect[] | undefined;
        ":-moz-any()"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-dir"?: _emotion_serialize.CSSObject | undefined;
        ":-webkit-any()"?: _emotion_serialize.CSSObject | undefined;
        "::cue"?: _emotion_serialize.CSSObject | undefined;
        "::cue-region"?: _emotion_serialize.CSSObject | undefined;
        "::part"?: _emotion_serialize.CSSObject | undefined;
        "::slotted"?: _emotion_serialize.CSSObject | undefined;
        "::view-transition-group"?: _emotion_serialize.CSSObject | undefined;
        "::view-transition-image-pair"?: _emotion_serialize.CSSObject | undefined;
        "::view-transition-new"?: _emotion_serialize.CSSObject | undefined;
        "::view-transition-old"?: _emotion_serialize.CSSObject | undefined;
        ":dir"?: _emotion_serialize.CSSObject | undefined;
        ":has"?: _emotion_serialize.CSSObject | undefined;
        ":host"?: _emotion_serialize.CSSObject | undefined;
        ":host-context"?: _emotion_serialize.CSSObject | undefined;
        ":is"?: _emotion_serialize.CSSObject | undefined;
        ":lang"?: _emotion_serialize.CSSObject | undefined;
        ":matches()"?: _emotion_serialize.CSSObject | undefined;
        ":not"?: _emotion_serialize.CSSObject | undefined;
        ":nth-child"?: _emotion_serialize.CSSObject | undefined;
        ":nth-last-child"?: _emotion_serialize.CSSObject | undefined;
        ":nth-last-of-type"?: _emotion_serialize.CSSObject | undefined;
        ":nth-of-type"?: _emotion_serialize.CSSObject | undefined;
        ":where"?: _emotion_serialize.CSSObject | undefined;
        ":-khtml-any-link"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-any-link"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-focusring"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-full-screen"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-placeholder"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-read-only"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-read-write"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-ui-invalid"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-ui-valid"?: _emotion_serialize.CSSObject | undefined;
        ":-ms-fullscreen"?: _emotion_serialize.CSSObject | undefined;
        ":-ms-input-placeholder"?: _emotion_serialize.CSSObject | undefined;
        ":-webkit-any-link"?: _emotion_serialize.CSSObject | undefined;
        ":-webkit-full-screen"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-placeholder"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-progress-bar"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-range-progress"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-range-thumb"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-range-track"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-selection"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-backdrop"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-browse"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-check"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-clear"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-expand"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-fill"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-fill-lower"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-fill-upper"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-input-placeholder"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-reveal"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-thumb"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-ticks-after"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-ticks-before"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-tooltip"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-track"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-value"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-backdrop"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-input-placeholder"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-progress-bar"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-progress-inner-value"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-progress-value"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-slider-runnable-track"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-slider-thumb"?: _emotion_serialize.CSSObject | undefined;
        "::after"?: _emotion_serialize.CSSObject | undefined;
        "::backdrop"?: _emotion_serialize.CSSObject | undefined;
        "::before"?: _emotion_serialize.CSSObject | undefined;
        "::first-letter"?: _emotion_serialize.CSSObject | undefined;
        "::first-line"?: _emotion_serialize.CSSObject | undefined;
        "::grammar-error"?: _emotion_serialize.CSSObject | undefined;
        "::marker"?: _emotion_serialize.CSSObject | undefined;
        "::placeholder"?: _emotion_serialize.CSSObject | undefined;
        "::selection"?: _emotion_serialize.CSSObject | undefined;
        "::spelling-error"?: _emotion_serialize.CSSObject | undefined;
        "::target-text"?: _emotion_serialize.CSSObject | undefined;
        "::view-transition"?: _emotion_serialize.CSSObject | undefined;
        ":active"?: _emotion_serialize.CSSObject | undefined;
        ":after"?: _emotion_serialize.CSSObject | undefined;
        ":any-link"?: _emotion_serialize.CSSObject | undefined;
        ":before"?: _emotion_serialize.CSSObject | undefined;
        ":blank"?: _emotion_serialize.CSSObject | undefined;
        ":checked"?: _emotion_serialize.CSSObject | undefined;
        ":current"?: _emotion_serialize.CSSObject | undefined;
        ":default"?: _emotion_serialize.CSSObject | undefined;
        ":defined"?: _emotion_serialize.CSSObject | undefined;
        ":disabled"?: _emotion_serialize.CSSObject | undefined;
        ":empty"?: _emotion_serialize.CSSObject | undefined;
        ":enabled"?: _emotion_serialize.CSSObject | undefined;
        ":first"?: _emotion_serialize.CSSObject | undefined;
        ":first-child"?: _emotion_serialize.CSSObject | undefined;
        ":first-letter"?: _emotion_serialize.CSSObject | undefined;
        ":first-line"?: _emotion_serialize.CSSObject | undefined;
        ":first-of-type"?: _emotion_serialize.CSSObject | undefined;
        ":focus"?: _emotion_serialize.CSSObject | undefined;
        ":focus-visible"?: _emotion_serialize.CSSObject | undefined;
        ":focus-within"?: _emotion_serialize.CSSObject | undefined;
        ":fullscreen"?: _emotion_serialize.CSSObject | undefined;
        ":future"?: _emotion_serialize.CSSObject | undefined;
        ":hover"?: _emotion_serialize.CSSObject | undefined;
        ":in-range"?: _emotion_serialize.CSSObject | undefined;
        ":indeterminate"?: _emotion_serialize.CSSObject | undefined;
        ":invalid"?: _emotion_serialize.CSSObject | undefined;
        ":last-child"?: _emotion_serialize.CSSObject | undefined;
        ":last-of-type"?: _emotion_serialize.CSSObject | undefined;
        ":left"?: _emotion_serialize.CSSObject | undefined;
        ":link"?: _emotion_serialize.CSSObject | undefined;
        ":local-link"?: _emotion_serialize.CSSObject | undefined;
        ":nth-col"?: _emotion_serialize.CSSObject | undefined;
        ":nth-last-col"?: _emotion_serialize.CSSObject | undefined;
        ":only-child"?: _emotion_serialize.CSSObject | undefined;
        ":only-of-type"?: _emotion_serialize.CSSObject | undefined;
        ":optional"?: _emotion_serialize.CSSObject | undefined;
        ":out-of-range"?: _emotion_serialize.CSSObject | undefined;
        ":past"?: _emotion_serialize.CSSObject | undefined;
        ":paused"?: _emotion_serialize.CSSObject | undefined;
        ":picture-in-picture"?: _emotion_serialize.CSSObject | undefined;
        ":placeholder-shown"?: _emotion_serialize.CSSObject | undefined;
        ":playing"?: _emotion_serialize.CSSObject | undefined;
        ":read-only"?: _emotion_serialize.CSSObject | undefined;
        ":read-write"?: _emotion_serialize.CSSObject | undefined;
        ":required"?: _emotion_serialize.CSSObject | undefined;
        ":right"?: _emotion_serialize.CSSObject | undefined;
        ":root"?: _emotion_serialize.CSSObject | undefined;
        ":scope"?: _emotion_serialize.CSSObject | undefined;
        ":target"?: _emotion_serialize.CSSObject | undefined;
        ":target-within"?: _emotion_serialize.CSSObject | undefined;
        ":user-invalid"?: _emotion_serialize.CSSObject | undefined;
        ":user-valid"?: _emotion_serialize.CSSObject | undefined;
        ":valid"?: _emotion_serialize.CSSObject | undefined;
        ":visited"?: _emotion_serialize.CSSObject | undefined;
        label?: string;
    };
    loadingIndicator: () => {};
    loadingMessage: () => {};
    menu: () => {};
    menuList: ({ maxHeight }: {
        maxHeight: number;
    }) => {
        maxHeight: number;
    };
    multiValue: () => {};
    multiValueLabel: () => {
        overflow: string;
        textOverflow: string;
    };
    multiValueRemove: () => {};
    noOptionsMessage: () => {};
    option: () => {};
    placeholder: (originalStyles: CSSObjectWithLabel) => {
        color: string;
        accentColor?: readonly string[] | csstype.Property.AccentColor | readonly csstype.Property.AccentColor[] | undefined;
        alignContent?: readonly string[] | csstype.Property.AlignContent | readonly csstype.Property.AlignContent[] | undefined;
        alignItems?: readonly string[] | csstype.Property.AlignItems | readonly csstype.Property.AlignItems[] | undefined;
        alignSelf?: readonly string[] | csstype.Property.AlignSelf | readonly csstype.Property.AlignSelf[] | undefined;
        alignTracks?: readonly string[] | csstype.Property.AlignTracks | readonly csstype.Property.AlignTracks[] | undefined;
        animationComposition?: readonly string[] | csstype.Property.AnimationComposition | readonly csstype.Property.AnimationComposition[] | undefined;
        animationDelay?: readonly string[] | csstype.Property.AnimationDelay<string & {}> | readonly csstype.Property.AnimationDelay<string & {}>[] | undefined;
        animationDirection?: readonly string[] | csstype.Property.AnimationDirection | readonly csstype.Property.AnimationDirection[] | undefined;
        animationDuration?: readonly string[] | csstype.Property.AnimationDuration<string & {}> | readonly csstype.Property.AnimationDuration<string & {}>[] | undefined;
        animationFillMode?: readonly string[] | csstype.Property.AnimationFillMode | readonly csstype.Property.AnimationFillMode[] | undefined;
        animationIterationCount?: csstype.Property.AnimationIterationCount | readonly NonNullable<csstype.Property.AnimationIterationCount | undefined>[] | readonly ((string & {}) | csstype.Globals | "infinite")[] | undefined;
        animationName?: readonly string[] | csstype.Property.AnimationName | readonly csstype.Property.AnimationName[] | undefined;
        animationPlayState?: readonly string[] | csstype.Property.AnimationPlayState | readonly csstype.Property.AnimationPlayState[] | undefined;
        animationRangeEnd?: readonly (string | (string & {}))[] | csstype.Property.AnimationRangeEnd<string | number> | readonly NonNullable<csstype.Property.AnimationRangeEnd<string | number> | undefined>[] | undefined;
        animationRangeStart?: readonly (string | (string & {}))[] | csstype.Property.AnimationRangeStart<string | number> | readonly NonNullable<csstype.Property.AnimationRangeStart<string | number> | undefined>[] | undefined;
        animationTimeline?: readonly string[] | csstype.Property.AnimationTimeline | readonly csstype.Property.AnimationTimeline[] | undefined;
        animationTimingFunction?: readonly string[] | csstype.Property.AnimationTimingFunction | readonly csstype.Property.AnimationTimingFunction[] | undefined;
        appearance?: csstype.Property.Appearance | readonly NonNullable<csstype.Property.Appearance | undefined>[] | readonly csstype.Property.Appearance[] | undefined;
        aspectRatio?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.AspectRatio | readonly NonNullable<csstype.Property.AspectRatio | undefined>[] | undefined;
        backdropFilter?: readonly string[] | csstype.Property.BackdropFilter | readonly csstype.Property.BackdropFilter[] | undefined;
        backfaceVisibility?: csstype.Property.BackfaceVisibility | readonly NonNullable<csstype.Property.BackfaceVisibility | undefined>[] | readonly csstype.Property.BackfaceVisibility[] | undefined;
        backgroundAttachment?: readonly string[] | csstype.Property.BackgroundAttachment | readonly csstype.Property.BackgroundAttachment[] | undefined;
        backgroundBlendMode?: readonly string[] | csstype.Property.BackgroundBlendMode | readonly csstype.Property.BackgroundBlendMode[] | undefined;
        backgroundClip?: readonly string[] | csstype.Property.BackgroundClip | readonly csstype.Property.BackgroundClip[] | undefined;
        backgroundColor?: readonly string[] | csstype.Property.BackgroundColor | readonly csstype.Property.BackgroundColor[] | undefined;
        backgroundImage?: readonly string[] | csstype.Property.BackgroundImage | readonly csstype.Property.BackgroundImage[] | undefined;
        backgroundOrigin?: readonly string[] | csstype.Property.BackgroundOrigin | readonly csstype.Property.BackgroundOrigin[] | undefined;
        backgroundPositionX?: readonly (string | (string & {}))[] | csstype.Property.BackgroundPositionX<string | number> | readonly NonNullable<csstype.Property.BackgroundPositionX<string | number> | undefined>[] | undefined;
        backgroundPositionY?: readonly (string | (string & {}))[] | csstype.Property.BackgroundPositionY<string | number> | readonly NonNullable<csstype.Property.BackgroundPositionY<string | number> | undefined>[] | undefined;
        backgroundRepeat?: readonly string[] | csstype.Property.BackgroundRepeat | readonly csstype.Property.BackgroundRepeat[] | undefined;
        backgroundSize?: readonly (string | (string & {}))[] | csstype.Property.BackgroundSize<string | number> | readonly NonNullable<csstype.Property.BackgroundSize<string | number> | undefined>[] | undefined;
        blockOverflow?: readonly string[] | csstype.Property.BlockOverflow | readonly csstype.Property.BlockOverflow[] | undefined;
        blockSize?: readonly (string | (string & {}))[] | csstype.Property.BlockSize<string | number> | readonly NonNullable<csstype.Property.BlockSize<string | number> | undefined>[] | undefined;
        borderBlockColor?: readonly string[] | csstype.Property.BorderBlockColor | readonly csstype.Property.BorderBlockColor[] | undefined;
        borderBlockEndColor?: readonly string[] | csstype.Property.BorderBlockEndColor | readonly csstype.Property.BorderBlockEndColor[] | undefined;
        borderBlockEndStyle?: csstype.Property.BorderBlockEndStyle | readonly NonNullable<csstype.Property.BorderBlockEndStyle | undefined>[] | readonly csstype.Property.BorderBlockEndStyle[] | undefined;
        borderBlockEndWidth?: readonly string[] | csstype.Property.BorderBlockEndWidth<string | number> | readonly NonNullable<csstype.Property.BorderBlockEndWidth<string | number> | undefined>[] | undefined;
        borderBlockStartColor?: readonly string[] | csstype.Property.BorderBlockStartColor | readonly csstype.Property.BorderBlockStartColor[] | undefined;
        borderBlockStartStyle?: csstype.Property.BorderBlockStartStyle | readonly NonNullable<csstype.Property.BorderBlockStartStyle | undefined>[] | readonly csstype.Property.BorderBlockStartStyle[] | undefined;
        borderBlockStartWidth?: readonly string[] | csstype.Property.BorderBlockStartWidth<string | number> | readonly NonNullable<csstype.Property.BorderBlockStartWidth<string | number> | undefined>[] | undefined;
        borderBlockStyle?: csstype.Property.BorderBlockStyle | readonly NonNullable<csstype.Property.BorderBlockStyle | undefined>[] | readonly csstype.Property.BorderBlockStyle[] | undefined;
        borderBlockWidth?: readonly string[] | csstype.Property.BorderBlockWidth<string | number> | readonly NonNullable<csstype.Property.BorderBlockWidth<string | number> | undefined>[] | undefined;
        borderBottomColor?: readonly string[] | csstype.Property.BorderBottomColor | readonly csstype.Property.BorderBottomColor[] | undefined;
        borderBottomLeftRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomLeftRadius<string | number> | undefined>[] | undefined;
        borderBottomRightRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomRightRadius<string | number> | undefined>[] | undefined;
        borderBottomStyle?: csstype.Property.BorderBottomStyle | readonly NonNullable<csstype.Property.BorderBottomStyle | undefined>[] | readonly csstype.Property.BorderBottomStyle[] | undefined;
        borderBottomWidth?: readonly string[] | csstype.Property.BorderBottomWidth<string | number> | readonly NonNullable<csstype.Property.BorderBottomWidth<string | number> | undefined>[] | undefined;
        borderCollapse?: csstype.Property.BorderCollapse | readonly NonNullable<csstype.Property.BorderCollapse | undefined>[] | readonly csstype.Property.BorderCollapse[] | undefined;
        borderEndEndRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderEndEndRadius<string | number> | readonly NonNullable<csstype.Property.BorderEndEndRadius<string | number> | undefined>[] | undefined;
        borderEndStartRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderEndStartRadius<string | number> | readonly NonNullable<csstype.Property.BorderEndStartRadius<string | number> | undefined>[] | undefined;
        borderImageOutset?: readonly (string | (string & {}))[] | csstype.Property.BorderImageOutset<string | number> | readonly NonNullable<csstype.Property.BorderImageOutset<string | number> | undefined>[] | undefined;
        borderImageRepeat?: readonly string[] | csstype.Property.BorderImageRepeat | readonly csstype.Property.BorderImageRepeat[] | undefined;
        borderImageSlice?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BorderImageSlice | readonly NonNullable<csstype.Property.BorderImageSlice | undefined>[] | undefined;
        borderImageSource?: readonly string[] | csstype.Property.BorderImageSource | readonly csstype.Property.BorderImageSource[] | undefined;
        borderImageWidth?: readonly (string | (string & {}))[] | csstype.Property.BorderImageWidth<string | number> | readonly NonNullable<csstype.Property.BorderImageWidth<string | number> | undefined>[] | undefined;
        borderInlineColor?: readonly string[] | csstype.Property.BorderInlineColor | readonly csstype.Property.BorderInlineColor[] | undefined;
        borderInlineEndColor?: readonly string[] | csstype.Property.BorderInlineEndColor | readonly csstype.Property.BorderInlineEndColor[] | undefined;
        borderInlineEndStyle?: csstype.Property.BorderInlineEndStyle | readonly NonNullable<csstype.Property.BorderInlineEndStyle | undefined>[] | readonly csstype.Property.BorderInlineEndStyle[] | undefined;
        borderInlineEndWidth?: readonly string[] | csstype.Property.BorderInlineEndWidth<string | number> | readonly NonNullable<csstype.Property.BorderInlineEndWidth<string | number> | undefined>[] | undefined;
        borderInlineStartColor?: readonly string[] | csstype.Property.BorderInlineStartColor | readonly csstype.Property.BorderInlineStartColor[] | undefined;
        borderInlineStartStyle?: csstype.Property.BorderInlineStartStyle | readonly NonNullable<csstype.Property.BorderInlineStartStyle | undefined>[] | readonly csstype.Property.BorderInlineStartStyle[] | undefined;
        borderInlineStartWidth?: readonly string[] | csstype.Property.BorderInlineStartWidth<string | number> | readonly NonNullable<csstype.Property.BorderInlineStartWidth<string | number> | undefined>[] | undefined;
        borderInlineStyle?: csstype.Property.BorderInlineStyle | readonly NonNullable<csstype.Property.BorderInlineStyle | undefined>[] | readonly csstype.Property.BorderInlineStyle[] | undefined;
        borderInlineWidth?: readonly string[] | csstype.Property.BorderInlineWidth<string | number> | readonly NonNullable<csstype.Property.BorderInlineWidth<string | number> | undefined>[] | undefined;
        borderLeftColor?: readonly string[] | csstype.Property.BorderLeftColor | readonly csstype.Property.BorderLeftColor[] | undefined;
        borderLeftStyle?: csstype.Property.BorderLeftStyle | readonly NonNullable<csstype.Property.BorderLeftStyle | undefined>[] | readonly csstype.Property.BorderLeftStyle[] | undefined;
        borderLeftWidth?: readonly string[] | csstype.Property.BorderLeftWidth<string | number> | readonly NonNullable<csstype.Property.BorderLeftWidth<string | number> | undefined>[] | undefined;
        borderRightColor?: readonly string[] | csstype.Property.BorderRightColor | readonly csstype.Property.BorderRightColor[] | undefined;
        borderRightStyle?: csstype.Property.BorderRightStyle | readonly NonNullable<csstype.Property.BorderRightStyle | undefined>[] | readonly csstype.Property.BorderRightStyle[] | undefined;
        borderRightWidth?: readonly string[] | csstype.Property.BorderRightWidth<string | number> | readonly NonNullable<csstype.Property.BorderRightWidth<string | number> | undefined>[] | undefined;
        borderSpacing?: readonly (string | (string & {}))[] | csstype.Property.BorderSpacing<string | number> | readonly NonNullable<csstype.Property.BorderSpacing<string | number> | undefined>[] | undefined;
        borderStartEndRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderStartEndRadius<string | number> | readonly NonNullable<csstype.Property.BorderStartEndRadius<string | number> | undefined>[] | undefined;
        borderStartStartRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderStartStartRadius<string | number> | readonly NonNullable<csstype.Property.BorderStartStartRadius<string | number> | undefined>[] | undefined;
        borderTopColor?: readonly string[] | csstype.Property.BorderTopColor | readonly csstype.Property.BorderTopColor[] | undefined;
        borderTopLeftRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderTopLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopLeftRadius<string | number> | undefined>[] | undefined;
        borderTopRightRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderTopRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopRightRadius<string | number> | undefined>[] | undefined;
        borderTopStyle?: csstype.Property.BorderTopStyle | readonly NonNullable<csstype.Property.BorderTopStyle | undefined>[] | readonly csstype.Property.BorderTopStyle[] | undefined;
        borderTopWidth?: readonly string[] | csstype.Property.BorderTopWidth<string | number> | readonly NonNullable<csstype.Property.BorderTopWidth<string | number> | undefined>[] | undefined;
        bottom?: readonly (string | (string & {}))[] | csstype.Property.Bottom<string | number> | readonly NonNullable<csstype.Property.Bottom<string | number> | undefined>[] | undefined;
        boxDecorationBreak?: csstype.Property.BoxDecorationBreak | readonly NonNullable<csstype.Property.BoxDecorationBreak | undefined>[] | readonly csstype.Property.BoxDecorationBreak[] | undefined;
        boxShadow?: readonly string[] | csstype.Property.BoxShadow | readonly csstype.Property.BoxShadow[] | undefined;
        boxSizing?: csstype.Property.BoxSizing | readonly NonNullable<csstype.Property.BoxSizing | undefined>[] | readonly csstype.Property.BoxSizing[] | undefined;
        breakAfter?: csstype.Property.BreakAfter | readonly NonNullable<csstype.Property.BreakAfter | undefined>[] | readonly csstype.Property.BreakAfter[] | undefined;
        breakBefore?: csstype.Property.BreakBefore | readonly NonNullable<csstype.Property.BreakBefore | undefined>[] | readonly csstype.Property.BreakBefore[] | undefined;
        breakInside?: csstype.Property.BreakInside | readonly NonNullable<csstype.Property.BreakInside | undefined>[] | readonly csstype.Property.BreakInside[] | undefined;
        captionSide?: csstype.Property.CaptionSide | readonly NonNullable<csstype.Property.CaptionSide | undefined>[] | readonly csstype.Property.CaptionSide[] | undefined;
        caretColor?: readonly string[] | csstype.Property.CaretColor | readonly csstype.Property.CaretColor[] | undefined;
        caretShape?: csstype.Property.CaretShape | readonly NonNullable<csstype.Property.CaretShape | undefined>[] | readonly csstype.Property.CaretShape[] | undefined;
        clear?: csstype.Property.Clear | readonly NonNullable<csstype.Property.Clear | undefined>[] | readonly csstype.Property.Clear[] | undefined;
        clipPath?: readonly string[] | csstype.Property.ClipPath | readonly csstype.Property.ClipPath[] | undefined;
        colorAdjust?: csstype.Property.PrintColorAdjust | readonly NonNullable<csstype.Property.PrintColorAdjust | undefined>[] | readonly csstype.Property.PrintColorAdjust[] | undefined;
        colorScheme?: readonly string[] | csstype.Property.ColorScheme | readonly csstype.Property.ColorScheme[] | undefined;
        columnCount?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.ColumnCount | readonly NonNullable<csstype.Property.ColumnCount | undefined>[] | undefined;
        columnFill?: csstype.Property.ColumnFill | readonly NonNullable<csstype.Property.ColumnFill | undefined>[] | readonly csstype.Property.ColumnFill[] | undefined;
        columnGap?: readonly (string | (string & {}))[] | csstype.Property.ColumnGap<string | number> | readonly NonNullable<csstype.Property.ColumnGap<string | number> | undefined>[] | undefined;
        columnRuleColor?: readonly string[] | csstype.Property.ColumnRuleColor | readonly csstype.Property.ColumnRuleColor[] | undefined;
        columnRuleStyle?: readonly string[] | csstype.Property.ColumnRuleStyle | readonly csstype.Property.ColumnRuleStyle[] | undefined;
        columnRuleWidth?: readonly (string | (string & {}))[] | csstype.Property.ColumnRuleWidth<string | number> | readonly NonNullable<csstype.Property.ColumnRuleWidth<string | number> | undefined>[] | undefined;
        columnSpan?: csstype.Property.ColumnSpan | readonly NonNullable<csstype.Property.ColumnSpan | undefined>[] | readonly csstype.Property.ColumnSpan[] | undefined;
        columnWidth?: readonly string[] | csstype.Property.ColumnWidth<string | number> | readonly NonNullable<csstype.Property.ColumnWidth<string | number> | undefined>[] | undefined;
        contain?: readonly string[] | csstype.Property.Contain | readonly csstype.Property.Contain[] | undefined;
        containIntrinsicBlockSize?: readonly (string | (string & {}))[] | csstype.Property.ContainIntrinsicBlockSize<string | number> | readonly NonNullable<csstype.Property.ContainIntrinsicBlockSize<string | number> | undefined>[] | undefined;
        containIntrinsicHeight?: readonly (string | (string & {}))[] | csstype.Property.ContainIntrinsicHeight<string | number> | readonly NonNullable<csstype.Property.ContainIntrinsicHeight<string | number> | undefined>[] | undefined;
        containIntrinsicInlineSize?: readonly (string | (string & {}))[] | csstype.Property.ContainIntrinsicInlineSize<string | number> | readonly NonNullable<csstype.Property.ContainIntrinsicInlineSize<string | number> | undefined>[] | undefined;
        containIntrinsicWidth?: readonly (string | (string & {}))[] | csstype.Property.ContainIntrinsicWidth<string | number> | readonly NonNullable<csstype.Property.ContainIntrinsicWidth<string | number> | undefined>[] | undefined;
        containerName?: readonly string[] | csstype.Property.ContainerName | readonly csstype.Property.ContainerName[] | undefined;
        containerType?: csstype.Property.ContainerType | readonly NonNullable<csstype.Property.ContainerType | undefined>[] | readonly csstype.Property.ContainerType[] | undefined;
        content?: readonly string[] | csstype.Property.Content | readonly csstype.Property.Content[] | undefined;
        contentVisibility?: csstype.Property.ContentVisibility | readonly NonNullable<csstype.Property.ContentVisibility | undefined>[] | readonly csstype.Property.ContentVisibility[] | undefined;
        counterIncrement?: readonly string[] | csstype.Property.CounterIncrement | readonly csstype.Property.CounterIncrement[] | undefined;
        counterReset?: readonly string[] | csstype.Property.CounterReset | readonly csstype.Property.CounterReset[] | undefined;
        counterSet?: readonly string[] | csstype.Property.CounterSet | readonly csstype.Property.CounterSet[] | undefined;
        cursor?: readonly string[] | csstype.Property.Cursor | readonly csstype.Property.Cursor[] | undefined;
        direction?: csstype.Property.Direction | readonly NonNullable<csstype.Property.Direction | undefined>[] | readonly csstype.Property.Direction[] | undefined;
        display?: readonly string[] | csstype.Property.Display | readonly csstype.Property.Display[] | undefined;
        emptyCells?: csstype.Property.EmptyCells | readonly NonNullable<csstype.Property.EmptyCells | undefined>[] | readonly csstype.Property.EmptyCells[] | undefined;
        filter?: readonly string[] | csstype.Property.Filter | readonly csstype.Property.Filter[] | undefined;
        flexBasis?: readonly (string | (string & {}))[] | csstype.Property.FlexBasis<string | number> | readonly NonNullable<csstype.Property.FlexBasis<string | number> | undefined>[] | undefined;
        flexDirection?: csstype.Property.FlexDirection | readonly NonNullable<csstype.Property.FlexDirection | undefined>[] | readonly csstype.Property.FlexDirection[] | undefined;
        flexGrow?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.FlexGrow | readonly NonNullable<csstype.Property.FlexGrow | undefined>[] | undefined;
        flexShrink?: csstype.Property.FlexShrink | readonly NonNullable<csstype.Property.FlexShrink | undefined>[] | readonly ((string & {}) | csstype.Globals)[] | undefined;
        flexWrap?: csstype.Property.FlexWrap | readonly NonNullable<csstype.Property.FlexWrap | undefined>[] | readonly csstype.Property.FlexWrap[] | undefined;
        float?: csstype.Property.Float | readonly NonNullable<csstype.Property.Float | undefined>[] | readonly csstype.Property.Float[] | undefined;
        fontFamily?: readonly string[] | csstype.Property.FontFamily | readonly csstype.Property.FontFamily[] | undefined;
        fontFeatureSettings?: readonly string[] | csstype.Property.FontFeatureSettings | readonly csstype.Property.FontFeatureSettings[] | undefined;
        fontKerning?: csstype.Property.FontKerning | readonly NonNullable<csstype.Property.FontKerning | undefined>[] | readonly csstype.Property.FontKerning[] | undefined;
        fontLanguageOverride?: readonly string[] | csstype.Property.FontLanguageOverride | readonly csstype.Property.FontLanguageOverride[] | undefined;
        fontOpticalSizing?: csstype.Property.FontOpticalSizing | readonly NonNullable<csstype.Property.FontOpticalSizing | undefined>[] | readonly csstype.Property.FontOpticalSizing[] | undefined;
        fontPalette?: readonly string[] | csstype.Property.FontPalette | readonly csstype.Property.FontPalette[] | undefined;
        fontSize?: readonly (string | (string & {}))[] | csstype.Property.FontSize<string | number> | readonly NonNullable<csstype.Property.FontSize<string | number> | undefined>[] | undefined;
        fontSizeAdjust?: csstype.Property.FontSizeAdjust | readonly NonNullable<csstype.Property.FontSizeAdjust | undefined>[] | readonly ("none" | (string & {}) | csstype.Globals | "from-font")[] | undefined;
        fontSmooth?: readonly string[] | csstype.Property.FontSmooth<string | number> | readonly NonNullable<csstype.Property.FontSmooth<string | number> | undefined>[] | undefined;
        fontStretch?: readonly string[] | csstype.Property.FontStretch | readonly csstype.Property.FontStretch[] | undefined;
        fontStyle?: readonly string[] | csstype.Property.FontStyle | readonly csstype.Property.FontStyle[] | undefined;
        fontSynthesis?: readonly string[] | csstype.Property.FontSynthesis | readonly csstype.Property.FontSynthesis[] | undefined;
        fontSynthesisPosition?: csstype.Property.FontSynthesisPosition | readonly NonNullable<csstype.Property.FontSynthesisPosition | undefined>[] | readonly csstype.Property.FontSynthesisPosition[] | undefined;
        fontSynthesisSmallCaps?: csstype.Property.FontSynthesisSmallCaps | readonly NonNullable<csstype.Property.FontSynthesisSmallCaps | undefined>[] | readonly csstype.Property.FontSynthesisSmallCaps[] | undefined;
        fontSynthesisStyle?: csstype.Property.FontSynthesisStyle | readonly NonNullable<csstype.Property.FontSynthesisStyle | undefined>[] | readonly csstype.Property.FontSynthesisStyle[] | undefined;
        fontSynthesisWeight?: csstype.Property.FontSynthesisWeight | readonly NonNullable<csstype.Property.FontSynthesisWeight | undefined>[] | readonly csstype.Property.FontSynthesisWeight[] | undefined;
        fontVariant?: readonly string[] | csstype.Property.FontVariant | readonly csstype.Property.FontVariant[] | undefined;
        fontVariantAlternates?: readonly string[] | csstype.Property.FontVariantAlternates | readonly csstype.Property.FontVariantAlternates[] | undefined;
        fontVariantCaps?: csstype.Property.FontVariantCaps | readonly NonNullable<csstype.Property.FontVariantCaps | undefined>[] | readonly csstype.Property.FontVariantCaps[] | undefined;
        fontVariantEastAsian?: readonly string[] | csstype.Property.FontVariantEastAsian | readonly csstype.Property.FontVariantEastAsian[] | undefined;
        fontVariantEmoji?: csstype.Property.FontVariantEmoji | readonly NonNullable<csstype.Property.FontVariantEmoji | undefined>[] | readonly csstype.Property.FontVariantEmoji[] | undefined;
        fontVariantLigatures?: readonly string[] | csstype.Property.FontVariantLigatures | readonly csstype.Property.FontVariantLigatures[] | undefined;
        fontVariantNumeric?: readonly string[] | csstype.Property.FontVariantNumeric | readonly csstype.Property.FontVariantNumeric[] | undefined;
        fontVariantPosition?: csstype.Property.FontVariantPosition | readonly NonNullable<csstype.Property.FontVariantPosition | undefined>[] | readonly csstype.Property.FontVariantPosition[] | undefined;
        fontVariationSettings?: readonly string[] | csstype.Property.FontVariationSettings | readonly csstype.Property.FontVariationSettings[] | undefined;
        fontWeight?: csstype.Property.FontWeight | readonly NonNullable<csstype.Property.FontWeight | undefined>[] | readonly ("normal" | "bold" | (string & {}) | csstype.Globals | "bolder" | "lighter")[] | undefined;
        forcedColorAdjust?: csstype.Property.ForcedColorAdjust | readonly NonNullable<csstype.Property.ForcedColorAdjust | undefined>[] | readonly csstype.Property.ForcedColorAdjust[] | undefined;
        gridAutoColumns?: readonly (string | (string & {}))[] | csstype.Property.GridAutoColumns<string | number> | readonly NonNullable<csstype.Property.GridAutoColumns<string | number> | undefined>[] | undefined;
        gridAutoFlow?: readonly string[] | csstype.Property.GridAutoFlow | readonly csstype.Property.GridAutoFlow[] | undefined;
        gridAutoRows?: readonly (string | (string & {}))[] | csstype.Property.GridAutoRows<string | number> | readonly NonNullable<csstype.Property.GridAutoRows<string | number> | undefined>[] | undefined;
        gridColumnEnd?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridColumnEnd | readonly NonNullable<csstype.Property.GridColumnEnd | undefined>[] | undefined;
        gridColumnStart?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridColumnStart | readonly NonNullable<csstype.Property.GridColumnStart | undefined>[] | undefined;
        gridRowEnd?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridRowEnd | readonly NonNullable<csstype.Property.GridRowEnd | undefined>[] | undefined;
        gridRowStart?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridRowStart | readonly NonNullable<csstype.Property.GridRowStart | undefined>[] | undefined;
        gridTemplateAreas?: readonly string[] | csstype.Property.GridTemplateAreas | readonly csstype.Property.GridTemplateAreas[] | undefined;
        gridTemplateColumns?: readonly (string | (string & {}))[] | csstype.Property.GridTemplateColumns<string | number> | readonly NonNullable<csstype.Property.GridTemplateColumns<string | number> | undefined>[] | undefined;
        gridTemplateRows?: readonly (string | (string & {}))[] | csstype.Property.GridTemplateRows<string | number> | readonly NonNullable<csstype.Property.GridTemplateRows<string | number> | undefined>[] | undefined;
        hangingPunctuation?: readonly string[] | csstype.Property.HangingPunctuation | readonly csstype.Property.HangingPunctuation[] | undefined;
        height?: readonly (string | (string & {}))[] | csstype.Property.Height<string | number> | readonly NonNullable<csstype.Property.Height<string | number> | undefined>[] | undefined;
        hyphenateCharacter?: readonly string[] | csstype.Property.HyphenateCharacter | readonly csstype.Property.HyphenateCharacter[] | undefined;
        hyphenateLimitChars?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.HyphenateLimitChars | readonly NonNullable<csstype.Property.HyphenateLimitChars | undefined>[] | undefined;
        hyphens?: csstype.Property.Hyphens | readonly NonNullable<csstype.Property.Hyphens | undefined>[] | readonly csstype.Property.Hyphens[] | undefined;
        imageOrientation?: readonly string[] | csstype.Property.ImageOrientation | readonly csstype.Property.ImageOrientation[] | undefined;
        imageRendering?: csstype.Property.ImageRendering | readonly NonNullable<csstype.Property.ImageRendering | undefined>[] | readonly csstype.Property.ImageRendering[] | undefined;
        imageResolution?: readonly string[] | csstype.Property.ImageResolution | readonly csstype.Property.ImageResolution[] | undefined;
        initialLetter?: csstype.Property.InitialLetter | readonly NonNullable<csstype.Property.InitialLetter | undefined>[] | readonly ("normal" | (string & {}) | csstype.Globals)[] | undefined;
        inlineSize?: readonly (string | (string & {}))[] | csstype.Property.InlineSize<string | number> | readonly NonNullable<csstype.Property.InlineSize<string | number> | undefined>[] | undefined;
        inputSecurity?: csstype.Property.InputSecurity | readonly NonNullable<csstype.Property.InputSecurity | undefined>[] | readonly csstype.Property.InputSecurity[] | undefined;
        insetBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.InsetBlockEnd<string | number> | readonly NonNullable<csstype.Property.InsetBlockEnd<string | number> | undefined>[] | undefined;
        insetBlockStart?: readonly (string | (string & {}))[] | csstype.Property.InsetBlockStart<string | number> | readonly NonNullable<csstype.Property.InsetBlockStart<string | number> | undefined>[] | undefined;
        insetInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.InsetInlineEnd<string | number> | readonly NonNullable<csstype.Property.InsetInlineEnd<string | number> | undefined>[] | undefined;
        insetInlineStart?: readonly (string | (string & {}))[] | csstype.Property.InsetInlineStart<string | number> | readonly NonNullable<csstype.Property.InsetInlineStart<string | number> | undefined>[] | undefined;
        isolation?: csstype.Property.Isolation | readonly NonNullable<csstype.Property.Isolation | undefined>[] | readonly csstype.Property.Isolation[] | undefined;
        justifyContent?: readonly string[] | csstype.Property.JustifyContent | readonly csstype.Property.JustifyContent[] | undefined;
        justifyItems?: readonly string[] | csstype.Property.JustifyItems | readonly csstype.Property.JustifyItems[] | undefined;
        justifySelf?: readonly string[] | csstype.Property.JustifySelf | readonly csstype.Property.JustifySelf[] | undefined;
        justifyTracks?: readonly string[] | csstype.Property.JustifyTracks | readonly csstype.Property.JustifyTracks[] | undefined;
        left?: readonly (string | (string & {}))[] | csstype.Property.Left<string | number> | readonly NonNullable<csstype.Property.Left<string | number> | undefined>[] | undefined;
        letterSpacing?: readonly string[] | csstype.Property.LetterSpacing<string | number> | readonly NonNullable<csstype.Property.LetterSpacing<string | number> | undefined>[] | undefined;
        lineBreak?: csstype.Property.LineBreak | readonly NonNullable<csstype.Property.LineBreak | undefined>[] | readonly csstype.Property.LineBreak[] | undefined;
        lineHeight?: csstype.Property.LineHeight<string | number> | readonly NonNullable<csstype.Property.LineHeight<string | number> | undefined>[] | readonly (string | (string & {}))[] | undefined;
        lineHeightStep?: readonly string[] | csstype.Property.LineHeightStep<string | number> | readonly NonNullable<csstype.Property.LineHeightStep<string | number> | undefined>[] | undefined;
        listStyleImage?: readonly string[] | csstype.Property.ListStyleImage | readonly csstype.Property.ListStyleImage[] | undefined;
        listStylePosition?: csstype.Property.ListStylePosition | readonly NonNullable<csstype.Property.ListStylePosition | undefined>[] | readonly csstype.Property.ListStylePosition[] | undefined;
        listStyleType?: readonly string[] | csstype.Property.ListStyleType | readonly csstype.Property.ListStyleType[] | undefined;
        marginBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.MarginBlockEnd<string | number> | readonly NonNullable<csstype.Property.MarginBlockEnd<string | number> | undefined>[] | undefined;
        marginBlockStart?: readonly (string | (string & {}))[] | csstype.Property.MarginBlockStart<string | number> | readonly NonNullable<csstype.Property.MarginBlockStart<string | number> | undefined>[] | undefined;
        marginBottom?: readonly (string | (string & {}))[] | csstype.Property.MarginBottom<string | number> | readonly NonNullable<csstype.Property.MarginBottom<string | number> | undefined>[] | undefined;
        marginInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineEnd<string | number> | readonly NonNullable<csstype.Property.MarginInlineEnd<string | number> | undefined>[] | undefined;
        marginInlineStart?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineStart<string | number> | readonly NonNullable<csstype.Property.MarginInlineStart<string | number> | undefined>[] | undefined;
        marginLeft?: readonly (string | (string & {}))[] | csstype.Property.MarginLeft<string | number> | readonly NonNullable<csstype.Property.MarginLeft<string | number> | undefined>[] | undefined;
        marginRight?: readonly (string | (string & {}))[] | csstype.Property.MarginRight<string | number> | readonly NonNullable<csstype.Property.MarginRight<string | number> | undefined>[] | undefined;
        marginTop?: readonly (string | (string & {}))[] | csstype.Property.MarginTop<string | number> | readonly NonNullable<csstype.Property.MarginTop<string | number> | undefined>[] | undefined;
        marginTrim?: csstype.Property.MarginTrim | readonly NonNullable<csstype.Property.MarginTrim | undefined>[] | readonly csstype.Property.MarginTrim[] | undefined;
        maskBorderMode?: csstype.Property.MaskBorderMode | readonly NonNullable<csstype.Property.MaskBorderMode | undefined>[] | readonly csstype.Property.MaskBorderMode[] | undefined;
        maskBorderOutset?: readonly (string | (string & {}))[] | csstype.Property.MaskBorderOutset<string | number> | readonly NonNullable<csstype.Property.MaskBorderOutset<string | number> | undefined>[] | undefined;
        maskBorderRepeat?: readonly string[] | csstype.Property.MaskBorderRepeat | readonly csstype.Property.MaskBorderRepeat[] | undefined;
        maskBorderSlice?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.MaskBorderSlice | readonly NonNullable<csstype.Property.MaskBorderSlice | undefined>[] | undefined;
        maskBorderSource?: readonly string[] | csstype.Property.MaskBorderSource | readonly csstype.Property.MaskBorderSource[] | undefined;
        maskBorderWidth?: readonly (string | (string & {}))[] | csstype.Property.MaskBorderWidth<string | number> | readonly NonNullable<csstype.Property.MaskBorderWidth<string | number> | undefined>[] | undefined;
        maskClip?: readonly string[] | csstype.Property.MaskClip | readonly csstype.Property.MaskClip[] | undefined;
        maskComposite?: readonly string[] | csstype.Property.MaskComposite | readonly csstype.Property.MaskComposite[] | undefined;
        maskImage?: readonly string[] | csstype.Property.MaskImage | readonly csstype.Property.MaskImage[] | undefined;
        maskMode?: readonly string[] | csstype.Property.MaskMode | readonly csstype.Property.MaskMode[] | undefined;
        maskOrigin?: readonly string[] | csstype.Property.MaskOrigin | readonly csstype.Property.MaskOrigin[] | undefined;
        maskPosition?: readonly (string | (string & {}))[] | csstype.Property.MaskPosition<string | number> | readonly NonNullable<csstype.Property.MaskPosition<string | number> | undefined>[] | undefined;
        maskRepeat?: readonly string[] | csstype.Property.MaskRepeat | readonly csstype.Property.MaskRepeat[] | undefined;
        maskSize?: readonly (string | (string & {}))[] | csstype.Property.MaskSize<string | number> | readonly NonNullable<csstype.Property.MaskSize<string | number> | undefined>[] | undefined;
        maskType?: csstype.Property.MaskType | readonly NonNullable<csstype.Property.MaskType | undefined>[] | readonly csstype.Property.MaskType[] | undefined;
        masonryAutoFlow?: readonly string[] | csstype.Property.MasonryAutoFlow | readonly csstype.Property.MasonryAutoFlow[] | undefined;
        mathDepth?: csstype.Property.MathDepth | readonly NonNullable<csstype.Property.MathDepth | undefined>[] | readonly ((string & {}) | csstype.Globals | "auto-add")[] | undefined;
        mathShift?: csstype.Property.MathShift | readonly NonNullable<csstype.Property.MathShift | undefined>[] | readonly csstype.Property.MathShift[] | undefined;
        mathStyle?: csstype.Property.MathStyle | readonly NonNullable<csstype.Property.MathStyle | undefined>[] | readonly csstype.Property.MathStyle[] | undefined;
        maxBlockSize?: readonly (string | (string & {}))[] | csstype.Property.MaxBlockSize<string | number> | readonly NonNullable<csstype.Property.MaxBlockSize<string | number> | undefined>[] | undefined;
        maxHeight?: readonly (string | (string & {}))[] | csstype.Property.MaxHeight<string | number> | readonly NonNullable<csstype.Property.MaxHeight<string | number> | undefined>[] | undefined;
        maxInlineSize?: readonly (string | (string & {}))[] | csstype.Property.MaxInlineSize<string | number> | readonly NonNullable<csstype.Property.MaxInlineSize<string | number> | undefined>[] | undefined;
        maxLines?: csstype.Property.MaxLines | readonly NonNullable<csstype.Property.MaxLines | undefined>[] | readonly ("none" | (string & {}) | csstype.Globals)[] | undefined;
        maxWidth?: readonly (string | (string & {}))[] | csstype.Property.MaxWidth<string | number> | readonly NonNullable<csstype.Property.MaxWidth<string | number> | undefined>[] | undefined;
        minBlockSize?: readonly (string | (string & {}))[] | csstype.Property.MinBlockSize<string | number> | readonly NonNullable<csstype.Property.MinBlockSize<string | number> | undefined>[] | undefined;
        minHeight?: readonly (string | (string & {}))[] | csstype.Property.MinHeight<string | number> | readonly NonNullable<csstype.Property.MinHeight<string | number> | undefined>[] | undefined;
        minInlineSize?: readonly (string | (string & {}))[] | csstype.Property.MinInlineSize<string | number> | readonly NonNullable<csstype.Property.MinInlineSize<string | number> | undefined>[] | undefined;
        minWidth?: readonly (string | (string & {}))[] | csstype.Property.MinWidth<string | number> | readonly NonNullable<csstype.Property.MinWidth<string | number> | undefined>[] | undefined;
        mixBlendMode?: csstype.Property.MixBlendMode | readonly NonNullable<csstype.Property.MixBlendMode | undefined>[] | readonly csstype.Property.MixBlendMode[] | undefined;
        motionDistance?: readonly (string | (string & {}))[] | csstype.Property.OffsetDistance<string | number> | readonly NonNullable<csstype.Property.OffsetDistance<string | number> | undefined>[] | undefined;
        motionPath?: readonly string[] | csstype.Property.OffsetPath | readonly csstype.Property.OffsetPath[] | undefined;
        motionRotation?: readonly string[] | csstype.Property.OffsetRotate | readonly csstype.Property.OffsetRotate[] | undefined;
        objectFit?: csstype.Property.ObjectFit | readonly NonNullable<csstype.Property.ObjectFit | undefined>[] | readonly csstype.Property.ObjectFit[] | undefined;
        objectPosition?: readonly (string | (string & {}))[] | csstype.Property.ObjectPosition<string | number> | readonly NonNullable<csstype.Property.ObjectPosition<string | number> | undefined>[] | undefined;
        offsetAnchor?: readonly (string | (string & {}))[] | csstype.Property.OffsetAnchor<string | number> | readonly NonNullable<csstype.Property.OffsetAnchor<string | number> | undefined>[] | undefined;
        offsetDistance?: readonly (string | (string & {}))[] | csstype.Property.OffsetDistance<string | number> | readonly NonNullable<csstype.Property.OffsetDistance<string | number> | undefined>[] | undefined;
        offsetPath?: readonly string[] | csstype.Property.OffsetPath | readonly csstype.Property.OffsetPath[] | undefined;
        offsetPosition?: readonly (string | (string & {}))[] | csstype.Property.OffsetPosition<string | number> | readonly NonNullable<csstype.Property.OffsetPosition<string | number> | undefined>[] | undefined;
        offsetRotate?: readonly string[] | csstype.Property.OffsetRotate | readonly csstype.Property.OffsetRotate[] | undefined;
        offsetRotation?: readonly string[] | csstype.Property.OffsetRotate | readonly csstype.Property.OffsetRotate[] | undefined;
        opacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Opacity | readonly NonNullable<csstype.Property.Opacity | undefined>[] | undefined;
        order?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Order | readonly NonNullable<csstype.Property.Order | undefined>[] | undefined;
        orphans?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Orphans | readonly NonNullable<csstype.Property.Orphans | undefined>[] | undefined;
        outlineColor?: readonly string[] | csstype.Property.OutlineColor | readonly csstype.Property.OutlineColor[] | undefined;
        outlineOffset?: readonly string[] | csstype.Property.OutlineOffset<string | number> | readonly NonNullable<csstype.Property.OutlineOffset<string | number> | undefined>[] | undefined;
        outlineStyle?: readonly string[] | csstype.Property.OutlineStyle | readonly csstype.Property.OutlineStyle[] | undefined;
        outlineWidth?: readonly string[] | csstype.Property.OutlineWidth<string | number> | readonly NonNullable<csstype.Property.OutlineWidth<string | number> | undefined>[] | undefined;
        overflowAnchor?: csstype.Property.OverflowAnchor | readonly NonNullable<csstype.Property.OverflowAnchor | undefined>[] | readonly csstype.Property.OverflowAnchor[] | undefined;
        overflowBlock?: csstype.Property.OverflowBlock | readonly NonNullable<csstype.Property.OverflowBlock | undefined>[] | readonly csstype.Property.OverflowBlock[] | undefined;
        overflowClipBox?: csstype.Property.OverflowClipBox | readonly NonNullable<csstype.Property.OverflowClipBox | undefined>[] | readonly csstype.Property.OverflowClipBox[] | undefined;
        overflowClipMargin?: readonly (string | (string & {}))[] | csstype.Property.OverflowClipMargin<string | number> | readonly NonNullable<csstype.Property.OverflowClipMargin<string | number> | undefined>[] | undefined;
        overflowInline?: csstype.Property.OverflowInline | readonly NonNullable<csstype.Property.OverflowInline | undefined>[] | readonly csstype.Property.OverflowInline[] | undefined;
        overflowWrap?: csstype.Property.OverflowWrap | readonly NonNullable<csstype.Property.OverflowWrap | undefined>[] | readonly csstype.Property.OverflowWrap[] | undefined;
        overflowX?: csstype.Property.OverflowX | readonly NonNullable<csstype.Property.OverflowX | undefined>[] | readonly csstype.Property.OverflowX[] | undefined;
        overflowY?: csstype.Property.OverflowY | readonly NonNullable<csstype.Property.OverflowY | undefined>[] | readonly csstype.Property.OverflowY[] | undefined;
        overlay?: csstype.Property.Overlay | readonly NonNullable<csstype.Property.Overlay | undefined>[] | readonly csstype.Property.Overlay[] | undefined;
        overscrollBehaviorBlock?: csstype.Property.OverscrollBehaviorBlock | readonly NonNullable<csstype.Property.OverscrollBehaviorBlock | undefined>[] | readonly csstype.Property.OverscrollBehaviorBlock[] | undefined;
        overscrollBehaviorInline?: csstype.Property.OverscrollBehaviorInline | readonly NonNullable<csstype.Property.OverscrollBehaviorInline | undefined>[] | readonly csstype.Property.OverscrollBehaviorInline[] | undefined;
        overscrollBehaviorX?: csstype.Property.OverscrollBehaviorX | readonly NonNullable<csstype.Property.OverscrollBehaviorX | undefined>[] | readonly csstype.Property.OverscrollBehaviorX[] | undefined;
        overscrollBehaviorY?: csstype.Property.OverscrollBehaviorY | readonly NonNullable<csstype.Property.OverscrollBehaviorY | undefined>[] | readonly csstype.Property.OverscrollBehaviorY[] | undefined;
        paddingBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.PaddingBlockEnd<string | number> | readonly NonNullable<csstype.Property.PaddingBlockEnd<string | number> | undefined>[] | undefined;
        paddingBlockStart?: readonly (string | (string & {}))[] | csstype.Property.PaddingBlockStart<string | number> | readonly NonNullable<csstype.Property.PaddingBlockStart<string | number> | undefined>[] | undefined;
        paddingBottom?: readonly (string | (string & {}))[] | csstype.Property.PaddingBottom<string | number> | readonly NonNullable<csstype.Property.PaddingBottom<string | number> | undefined>[] | undefined;
        paddingInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineEnd<string | number> | readonly NonNullable<csstype.Property.PaddingInlineEnd<string | number> | undefined>[] | undefined;
        paddingInlineStart?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineStart<string | number> | readonly NonNullable<csstype.Property.PaddingInlineStart<string | number> | undefined>[] | undefined;
        paddingLeft?: readonly (string | (string & {}))[] | csstype.Property.PaddingLeft<string | number> | readonly NonNullable<csstype.Property.PaddingLeft<string | number> | undefined>[] | undefined;
        paddingRight?: readonly (string | (string & {}))[] | csstype.Property.PaddingRight<string | number> | readonly NonNullable<csstype.Property.PaddingRight<string | number> | undefined>[] | undefined;
        paddingTop?: readonly (string | (string & {}))[] | csstype.Property.PaddingTop<string | number> | readonly NonNullable<csstype.Property.PaddingTop<string | number> | undefined>[] | undefined;
        page?: readonly string[] | csstype.Property.Page | readonly csstype.Property.Page[] | undefined;
        pageBreakAfter?: csstype.Property.PageBreakAfter | readonly NonNullable<csstype.Property.PageBreakAfter | undefined>[] | readonly csstype.Property.PageBreakAfter[] | undefined;
        pageBreakBefore?: csstype.Property.PageBreakBefore | readonly NonNullable<csstype.Property.PageBreakBefore | undefined>[] | readonly csstype.Property.PageBreakBefore[] | undefined;
        pageBreakInside?: csstype.Property.PageBreakInside | readonly NonNullable<csstype.Property.PageBreakInside | undefined>[] | readonly csstype.Property.PageBreakInside[] | undefined;
        paintOrder?: readonly string[] | csstype.Property.PaintOrder | readonly csstype.Property.PaintOrder[] | undefined;
        perspective?: readonly string[] | csstype.Property.Perspective<string | number> | readonly NonNullable<csstype.Property.Perspective<string | number> | undefined>[] | undefined;
        perspectiveOrigin?: readonly (string | (string & {}))[] | csstype.Property.PerspectiveOrigin<string | number> | readonly NonNullable<csstype.Property.PerspectiveOrigin<string | number> | undefined>[] | undefined;
        pointerEvents?: csstype.Property.PointerEvents | readonly NonNullable<csstype.Property.PointerEvents | undefined>[] | readonly csstype.Property.PointerEvents[] | undefined;
        position?: csstype.Property.Position | readonly NonNullable<csstype.Property.Position | undefined>[] | readonly csstype.Property.Position[] | undefined;
        printColorAdjust?: csstype.Property.PrintColorAdjust | readonly NonNullable<csstype.Property.PrintColorAdjust | undefined>[] | readonly csstype.Property.PrintColorAdjust[] | undefined;
        quotes?: readonly string[] | csstype.Property.Quotes | readonly csstype.Property.Quotes[] | undefined;
        resize?: csstype.Property.Resize | readonly NonNullable<csstype.Property.Resize | undefined>[] | readonly csstype.Property.Resize[] | undefined;
        right?: readonly (string | (string & {}))[] | csstype.Property.Right<string | number> | readonly NonNullable<csstype.Property.Right<string | number> | undefined>[] | undefined;
        rotate?: readonly string[] | csstype.Property.Rotate | readonly csstype.Property.Rotate[] | undefined;
        rowGap?: readonly (string | (string & {}))[] | csstype.Property.RowGap<string | number> | readonly NonNullable<csstype.Property.RowGap<string | number> | undefined>[] | undefined;
        rubyAlign?: csstype.Property.RubyAlign | readonly NonNullable<csstype.Property.RubyAlign | undefined>[] | readonly csstype.Property.RubyAlign[] | undefined;
        rubyMerge?: csstype.Property.RubyMerge | readonly NonNullable<csstype.Property.RubyMerge | undefined>[] | readonly csstype.Property.RubyMerge[] | undefined;
        rubyPosition?: readonly string[] | csstype.Property.RubyPosition | readonly csstype.Property.RubyPosition[] | undefined;
        scale?: readonly ("none" | (string & {}) | csstype.Globals)[] | csstype.Property.Scale | readonly NonNullable<csstype.Property.Scale | undefined>[] | undefined;
        scrollBehavior?: csstype.Property.ScrollBehavior | readonly NonNullable<csstype.Property.ScrollBehavior | undefined>[] | readonly csstype.Property.ScrollBehavior[] | undefined;
        scrollMarginBlockEnd?: readonly string[] | csstype.Property.ScrollMarginBlockEnd<string | number> | readonly NonNullable<csstype.Property.ScrollMarginBlockEnd<string | number> | undefined>[] | undefined;
        scrollMarginBlockStart?: readonly string[] | csstype.Property.ScrollMarginBlockStart<string | number> | readonly NonNullable<csstype.Property.ScrollMarginBlockStart<string | number> | undefined>[] | undefined;
        scrollMarginBottom?: readonly string[] | csstype.Property.ScrollMarginBottom<string | number> | readonly NonNullable<csstype.Property.ScrollMarginBottom<string | number> | undefined>[] | undefined;
        scrollMarginInlineEnd?: readonly string[] | csstype.Property.ScrollMarginInlineEnd<string | number> | readonly NonNullable<csstype.Property.ScrollMarginInlineEnd<string | number> | undefined>[] | undefined;
        scrollMarginInlineStart?: readonly string[] | csstype.Property.ScrollMarginInlineStart<string | number> | readonly NonNullable<csstype.Property.ScrollMarginInlineStart<string | number> | undefined>[] | undefined;
        scrollMarginLeft?: readonly string[] | csstype.Property.ScrollMarginLeft<string | number> | readonly NonNullable<csstype.Property.ScrollMarginLeft<string | number> | undefined>[] | undefined;
        scrollMarginRight?: readonly string[] | csstype.Property.ScrollMarginRight<string | number> | readonly NonNullable<csstype.Property.ScrollMarginRight<string | number> | undefined>[] | undefined;
        scrollMarginTop?: readonly string[] | csstype.Property.ScrollMarginTop<string | number> | readonly NonNullable<csstype.Property.ScrollMarginTop<string | number> | undefined>[] | undefined;
        scrollPaddingBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingBlockEnd<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingBlockEnd<string | number> | undefined>[] | undefined;
        scrollPaddingBlockStart?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingBlockStart<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingBlockStart<string | number> | undefined>[] | undefined;
        scrollPaddingBottom?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingBottom<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingBottom<string | number> | undefined>[] | undefined;
        scrollPaddingInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingInlineEnd<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingInlineEnd<string | number> | undefined>[] | undefined;
        scrollPaddingInlineStart?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingInlineStart<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingInlineStart<string | number> | undefined>[] | undefined;
        scrollPaddingLeft?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingLeft<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingLeft<string | number> | undefined>[] | undefined;
        scrollPaddingRight?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingRight<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingRight<string | number> | undefined>[] | undefined;
        scrollPaddingTop?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingTop<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingTop<string | number> | undefined>[] | undefined;
        scrollSnapAlign?: readonly string[] | csstype.Property.ScrollSnapAlign | readonly csstype.Property.ScrollSnapAlign[] | undefined;
        scrollSnapMarginBottom?: readonly string[] | csstype.Property.ScrollMarginBottom<string | number> | readonly NonNullable<csstype.Property.ScrollMarginBottom<string | number> | undefined>[] | undefined;
        scrollSnapMarginLeft?: readonly string[] | csstype.Property.ScrollMarginLeft<string | number> | readonly NonNullable<csstype.Property.ScrollMarginLeft<string | number> | undefined>[] | undefined;
        scrollSnapMarginRight?: readonly string[] | csstype.Property.ScrollMarginRight<string | number> | readonly NonNullable<csstype.Property.ScrollMarginRight<string | number> | undefined>[] | undefined;
        scrollSnapMarginTop?: readonly string[] | csstype.Property.ScrollMarginTop<string | number> | readonly NonNullable<csstype.Property.ScrollMarginTop<string | number> | undefined>[] | undefined;
        scrollSnapStop?: csstype.Property.ScrollSnapStop | readonly NonNullable<csstype.Property.ScrollSnapStop | undefined>[] | readonly csstype.Property.ScrollSnapStop[] | undefined;
        scrollSnapType?: readonly string[] | csstype.Property.ScrollSnapType | readonly csstype.Property.ScrollSnapType[] | undefined;
        scrollTimelineAxis?: readonly string[] | csstype.Property.ScrollTimelineAxis | readonly csstype.Property.ScrollTimelineAxis[] | undefined;
        scrollTimelineName?: readonly string[] | csstype.Property.ScrollTimelineName | readonly csstype.Property.ScrollTimelineName[] | undefined;
        scrollbarColor?: readonly string[] | csstype.Property.ScrollbarColor | readonly csstype.Property.ScrollbarColor[] | undefined;
        scrollbarGutter?: readonly string[] | csstype.Property.ScrollbarGutter | readonly csstype.Property.ScrollbarGutter[] | undefined;
        scrollbarWidth?: csstype.Property.ScrollbarWidth | readonly NonNullable<csstype.Property.ScrollbarWidth | undefined>[] | readonly csstype.Property.ScrollbarWidth[] | undefined;
        shapeImageThreshold?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.ShapeImageThreshold | readonly NonNullable<csstype.Property.ShapeImageThreshold | undefined>[] | undefined;
        shapeMargin?: readonly (string | (string & {}))[] | csstype.Property.ShapeMargin<string | number> | readonly NonNullable<csstype.Property.ShapeMargin<string | number> | undefined>[] | undefined;
        shapeOutside?: readonly string[] | csstype.Property.ShapeOutside | readonly csstype.Property.ShapeOutside[] | undefined;
        tabSize?: readonly (string | (string & {}))[] | csstype.Property.TabSize<string | number> | readonly NonNullable<csstype.Property.TabSize<string | number> | undefined>[] | undefined;
        tableLayout?: csstype.Property.TableLayout | readonly NonNullable<csstype.Property.TableLayout | undefined>[] | readonly csstype.Property.TableLayout[] | undefined;
        textAlign?: csstype.Property.TextAlign | readonly NonNullable<csstype.Property.TextAlign | undefined>[] | readonly csstype.Property.TextAlign[] | undefined;
        textAlignLast?: csstype.Property.TextAlignLast | readonly NonNullable<csstype.Property.TextAlignLast | undefined>[] | readonly csstype.Property.TextAlignLast[] | undefined;
        textCombineUpright?: readonly string[] | csstype.Property.TextCombineUpright | readonly csstype.Property.TextCombineUpright[] | undefined;
        textDecorationColor?: readonly string[] | csstype.Property.TextDecorationColor | readonly csstype.Property.TextDecorationColor[] | undefined;
        textDecorationLine?: readonly string[] | csstype.Property.TextDecorationLine | readonly csstype.Property.TextDecorationLine[] | undefined;
        textDecorationSkip?: readonly string[] | csstype.Property.TextDecorationSkip | readonly csstype.Property.TextDecorationSkip[] | undefined;
        textDecorationSkipInk?: csstype.Property.TextDecorationSkipInk | readonly NonNullable<csstype.Property.TextDecorationSkipInk | undefined>[] | readonly csstype.Property.TextDecorationSkipInk[] | undefined;
        textDecorationStyle?: csstype.Property.TextDecorationStyle | readonly NonNullable<csstype.Property.TextDecorationStyle | undefined>[] | readonly csstype.Property.TextDecorationStyle[] | undefined;
        textDecorationThickness?: readonly (string | (string & {}))[] | csstype.Property.TextDecorationThickness<string | number> | readonly NonNullable<csstype.Property.TextDecorationThickness<string | number> | undefined>[] | undefined;
        textEmphasisColor?: readonly string[] | csstype.Property.TextEmphasisColor | readonly csstype.Property.TextEmphasisColor[] | undefined;
        textEmphasisPosition?: readonly string[] | csstype.Property.TextEmphasisPosition | readonly csstype.Property.TextEmphasisPosition[] | undefined;
        textEmphasisStyle?: readonly string[] | csstype.Property.TextEmphasisStyle | readonly csstype.Property.TextEmphasisStyle[] | undefined;
        textIndent?: readonly (string | (string & {}))[] | csstype.Property.TextIndent<string | number> | readonly NonNullable<csstype.Property.TextIndent<string | number> | undefined>[] | undefined;
        textJustify?: csstype.Property.TextJustify | readonly NonNullable<csstype.Property.TextJustify | undefined>[] | readonly csstype.Property.TextJustify[] | undefined;
        textOrientation?: csstype.Property.TextOrientation | readonly NonNullable<csstype.Property.TextOrientation | undefined>[] | readonly csstype.Property.TextOrientation[] | undefined;
        textOverflow?: readonly string[] | csstype.Property.TextOverflow | readonly csstype.Property.TextOverflow[] | undefined;
        textRendering?: csstype.Property.TextRendering | readonly NonNullable<csstype.Property.TextRendering | undefined>[] | readonly csstype.Property.TextRendering[] | undefined;
        textShadow?: readonly string[] | csstype.Property.TextShadow | readonly csstype.Property.TextShadow[] | undefined;
        textSizeAdjust?: readonly string[] | csstype.Property.TextSizeAdjust | readonly csstype.Property.TextSizeAdjust[] | undefined;
        textTransform?: csstype.Property.TextTransform | readonly NonNullable<csstype.Property.TextTransform | undefined>[] | readonly csstype.Property.TextTransform[] | undefined;
        textUnderlineOffset?: readonly (string | (string & {}))[] | csstype.Property.TextUnderlineOffset<string | number> | readonly NonNullable<csstype.Property.TextUnderlineOffset<string | number> | undefined>[] | undefined;
        textUnderlinePosition?: readonly string[] | csstype.Property.TextUnderlinePosition | readonly csstype.Property.TextUnderlinePosition[] | undefined;
        textWrap?: csstype.Property.TextWrap | readonly NonNullable<csstype.Property.TextWrap | undefined>[] | readonly csstype.Property.TextWrap[] | undefined;
        timelineScope?: readonly string[] | csstype.Property.TimelineScope | readonly csstype.Property.TimelineScope[] | undefined;
        top?: readonly (string | (string & {}))[] | csstype.Property.Top<string | number> | readonly NonNullable<csstype.Property.Top<string | number> | undefined>[] | undefined;
        touchAction?: readonly string[] | csstype.Property.TouchAction | readonly csstype.Property.TouchAction[] | undefined;
        transform?: readonly string[] | csstype.Property.Transform | readonly csstype.Property.Transform[] | undefined;
        transformBox?: csstype.Property.TransformBox | readonly NonNullable<csstype.Property.TransformBox | undefined>[] | readonly csstype.Property.TransformBox[] | undefined;
        transformOrigin?: readonly (string | (string & {}))[] | csstype.Property.TransformOrigin<string | number> | readonly NonNullable<csstype.Property.TransformOrigin<string | number> | undefined>[] | undefined;
        transformStyle?: csstype.Property.TransformStyle | readonly NonNullable<csstype.Property.TransformStyle | undefined>[] | readonly csstype.Property.TransformStyle[] | undefined;
        transitionBehavior?: readonly string[] | csstype.Property.TransitionBehavior | readonly csstype.Property.TransitionBehavior[] | undefined;
        transitionDelay?: readonly string[] | csstype.Property.TransitionDelay<string & {}> | readonly csstype.Property.TransitionDelay<string & {}>[] | undefined;
        transitionDuration?: readonly string[] | csstype.Property.TransitionDuration<string & {}> | readonly csstype.Property.TransitionDuration<string & {}>[] | undefined;
        transitionProperty?: readonly string[] | csstype.Property.TransitionProperty | readonly csstype.Property.TransitionProperty[] | undefined;
        transitionTimingFunction?: readonly string[] | csstype.Property.TransitionTimingFunction | readonly csstype.Property.TransitionTimingFunction[] | undefined;
        translate?: readonly (string | (string & {}))[] | csstype.Property.Translate<string | number> | readonly NonNullable<csstype.Property.Translate<string | number> | undefined>[] | undefined;
        unicodeBidi?: csstype.Property.UnicodeBidi | readonly NonNullable<csstype.Property.UnicodeBidi | undefined>[] | readonly csstype.Property.UnicodeBidi[] | undefined;
        userSelect?: csstype.Property.UserSelect | readonly NonNullable<csstype.Property.UserSelect | undefined>[] | readonly csstype.Property.UserSelect[] | undefined;
        verticalAlign?: readonly (string | (string & {}))[] | csstype.Property.VerticalAlign<string | number> | readonly NonNullable<csstype.Property.VerticalAlign<string | number> | undefined>[] | undefined;
        viewTimelineAxis?: readonly string[] | csstype.Property.ViewTimelineAxis | readonly csstype.Property.ViewTimelineAxis[] | undefined;
        viewTimelineInset?: readonly (string | (string & {}))[] | csstype.Property.ViewTimelineInset<string | number> | readonly NonNullable<csstype.Property.ViewTimelineInset<string | number> | undefined>[] | undefined;
        viewTimelineName?: readonly string[] | csstype.Property.ViewTimelineName | readonly csstype.Property.ViewTimelineName[] | undefined;
        viewTransitionName?: readonly string[] | csstype.Property.ViewTransitionName | readonly csstype.Property.ViewTransitionName[] | undefined;
        visibility?: csstype.Property.Visibility | readonly NonNullable<csstype.Property.Visibility | undefined>[] | readonly csstype.Property.Visibility[] | undefined;
        whiteSpace?: readonly string[] | csstype.Property.WhiteSpace | readonly csstype.Property.WhiteSpace[] | undefined;
        whiteSpaceCollapse?: csstype.Property.WhiteSpaceCollapse | readonly NonNullable<csstype.Property.WhiteSpaceCollapse | undefined>[] | readonly csstype.Property.WhiteSpaceCollapse[] | undefined;
        whiteSpaceTrim?: readonly string[] | csstype.Property.WhiteSpaceTrim | readonly csstype.Property.WhiteSpaceTrim[] | undefined;
        widows?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Widows | readonly NonNullable<csstype.Property.Widows | undefined>[] | undefined;
        width?: readonly (string | (string & {}))[] | csstype.Property.Width<string | number> | readonly NonNullable<csstype.Property.Width<string | number> | undefined>[] | undefined;
        willChange?: readonly string[] | csstype.Property.WillChange | readonly csstype.Property.WillChange[] | undefined;
        wordBreak?: csstype.Property.WordBreak | readonly NonNullable<csstype.Property.WordBreak | undefined>[] | readonly csstype.Property.WordBreak[] | undefined;
        wordSpacing?: readonly string[] | csstype.Property.WordSpacing<string | number> | readonly NonNullable<csstype.Property.WordSpacing<string | number> | undefined>[] | undefined;
        wordWrap?: csstype.Property.WordWrap | readonly NonNullable<csstype.Property.WordWrap | undefined>[] | readonly csstype.Property.WordWrap[] | undefined;
        writingMode?: csstype.Property.WritingMode | readonly NonNullable<csstype.Property.WritingMode | undefined>[] | readonly csstype.Property.WritingMode[] | undefined;
        zIndex?: csstype.Property.ZIndex | readonly NonNullable<csstype.Property.ZIndex | undefined>[] | readonly ("auto" | (string & {}) | csstype.Globals)[] | undefined;
        zoom?: csstype.Property.Zoom | readonly NonNullable<csstype.Property.Zoom | undefined>[] | readonly ("normal" | "reset" | (string & {}) | csstype.Globals)[] | undefined;
        all?: csstype.Globals | readonly NonNullable<csstype.Globals | undefined>[] | readonly csstype.Globals[] | undefined;
        animation?: csstype.Property.Animation<string & {}> | readonly NonNullable<csstype.Property.Animation<string & {}> | undefined>[] | readonly ("linear" | "auto" | "none" | "normal" | "reverse" | "paused" | (string & {}) | csstype.Globals | "ease" | "ease-in" | "ease-in-out" | "ease-out" | "step-end" | "step-start" | "alternate" | "alternate-reverse" | "backwards" | "both" | "forwards" | "infinite" | "running")[] | undefined;
        animationRange?: readonly (string | (string & {}))[] | csstype.Property.AnimationRange<string | number> | readonly NonNullable<csstype.Property.AnimationRange<string | number> | undefined>[] | undefined;
        background?: readonly (string | (string & {}))[] | csstype.Property.Background<string | number> | readonly NonNullable<csstype.Property.Background<string | number> | undefined>[] | undefined;
        backgroundPosition?: readonly (string | (string & {}))[] | csstype.Property.BackgroundPosition<string | number> | readonly NonNullable<csstype.Property.BackgroundPosition<string | number> | undefined>[] | undefined;
        border?: readonly (string | (string & {}))[] | csstype.Property.Border<string | number> | readonly NonNullable<csstype.Property.Border<string | number> | undefined>[] | undefined;
        borderBlock?: readonly (string | (string & {}))[] | csstype.Property.BorderBlock<string | number> | readonly NonNullable<csstype.Property.BorderBlock<string | number> | undefined>[] | undefined;
        borderBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.BorderBlockEnd<string | number> | readonly NonNullable<csstype.Property.BorderBlockEnd<string | number> | undefined>[] | undefined;
        borderBlockStart?: readonly (string | (string & {}))[] | csstype.Property.BorderBlockStart<string | number> | readonly NonNullable<csstype.Property.BorderBlockStart<string | number> | undefined>[] | undefined;
        borderBottom?: readonly (string | (string & {}))[] | csstype.Property.BorderBottom<string | number> | readonly NonNullable<csstype.Property.BorderBottom<string | number> | undefined>[] | undefined;
        borderColor?: readonly string[] | csstype.Property.BorderColor | readonly csstype.Property.BorderColor[] | undefined;
        borderImage?: csstype.Property.BorderImage | readonly NonNullable<csstype.Property.BorderImage | undefined>[] | readonly ("none" | "repeat" | "round" | (string & {}) | csstype.Globals | "space" | "stretch")[] | undefined;
        borderInline?: readonly (string | (string & {}))[] | csstype.Property.BorderInline<string | number> | readonly NonNullable<csstype.Property.BorderInline<string | number> | undefined>[] | undefined;
        borderInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.BorderInlineEnd<string | number> | readonly NonNullable<csstype.Property.BorderInlineEnd<string | number> | undefined>[] | undefined;
        borderInlineStart?: readonly (string | (string & {}))[] | csstype.Property.BorderInlineStart<string | number> | readonly NonNullable<csstype.Property.BorderInlineStart<string | number> | undefined>[] | undefined;
        borderLeft?: readonly (string | (string & {}))[] | csstype.Property.BorderLeft<string | number> | readonly NonNullable<csstype.Property.BorderLeft<string | number> | undefined>[] | undefined;
        borderRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderRadius<string | number> | readonly NonNullable<csstype.Property.BorderRadius<string | number> | undefined>[] | undefined;
        borderRight?: readonly (string | (string & {}))[] | csstype.Property.BorderRight<string | number> | readonly NonNullable<csstype.Property.BorderRight<string | number> | undefined>[] | undefined;
        borderStyle?: readonly string[] | csstype.Property.BorderStyle | readonly csstype.Property.BorderStyle[] | undefined;
        borderTop?: readonly (string | (string & {}))[] | csstype.Property.BorderTop<string | number> | readonly NonNullable<csstype.Property.BorderTop<string | number> | undefined>[] | undefined;
        borderWidth?: readonly (string | (string & {}))[] | csstype.Property.BorderWidth<string | number> | readonly NonNullable<csstype.Property.BorderWidth<string | number> | undefined>[] | undefined;
        caret?: readonly string[] | csstype.Property.Caret | readonly csstype.Property.Caret[] | undefined;
        columnRule?: readonly (string | (string & {}))[] | csstype.Property.ColumnRule<string | number> | readonly NonNullable<csstype.Property.ColumnRule<string | number> | undefined>[] | undefined;
        columns?: readonly (string | (string & {}))[] | csstype.Property.Columns<string | number> | readonly NonNullable<csstype.Property.Columns<string | number> | undefined>[] | undefined;
        containIntrinsicSize?: readonly (string | (string & {}))[] | csstype.Property.ContainIntrinsicSize<string | number> | readonly NonNullable<csstype.Property.ContainIntrinsicSize<string | number> | undefined>[] | undefined;
        container?: readonly string[] | csstype.Property.Container | readonly csstype.Property.Container[] | undefined;
        flex?: readonly (string | (string & {}))[] | csstype.Property.Flex<string | number> | readonly NonNullable<csstype.Property.Flex<string | number> | undefined>[] | undefined;
        flexFlow?: readonly string[] | csstype.Property.FlexFlow | readonly csstype.Property.FlexFlow[] | undefined;
        font?: readonly string[] | csstype.Property.Font | readonly csstype.Property.Font[] | undefined;
        gap?: readonly (string | (string & {}))[] | csstype.Property.Gap<string | number> | readonly NonNullable<csstype.Property.Gap<string | number> | undefined>[] | undefined;
        grid?: readonly string[] | csstype.Property.Grid | readonly csstype.Property.Grid[] | undefined;
        gridArea?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridArea | readonly NonNullable<csstype.Property.GridArea | undefined>[] | undefined;
        gridColumn?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridColumn | readonly NonNullable<csstype.Property.GridColumn | undefined>[] | undefined;
        gridRow?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GridRow | readonly NonNullable<csstype.Property.GridRow | undefined>[] | undefined;
        gridTemplate?: readonly string[] | csstype.Property.GridTemplate | readonly csstype.Property.GridTemplate[] | undefined;
        inset?: readonly (string | (string & {}))[] | csstype.Property.Inset<string | number> | readonly NonNullable<csstype.Property.Inset<string | number> | undefined>[] | undefined;
        insetBlock?: readonly (string | (string & {}))[] | csstype.Property.InsetBlock<string | number> | readonly NonNullable<csstype.Property.InsetBlock<string | number> | undefined>[] | undefined;
        insetInline?: readonly (string | (string & {}))[] | csstype.Property.InsetInline<string | number> | readonly NonNullable<csstype.Property.InsetInline<string | number> | undefined>[] | undefined;
        lineClamp?: readonly ("none" | (string & {}) | csstype.Globals)[] | csstype.Property.LineClamp | readonly NonNullable<csstype.Property.LineClamp | undefined>[] | undefined;
        listStyle?: readonly string[] | csstype.Property.ListStyle | readonly csstype.Property.ListStyle[] | undefined;
        margin?: readonly (string | (string & {}))[] | csstype.Property.Margin<string | number> | readonly NonNullable<csstype.Property.Margin<string | number> | undefined>[] | undefined;
        marginBlock?: readonly (string | (string & {}))[] | csstype.Property.MarginBlock<string | number> | readonly NonNullable<csstype.Property.MarginBlock<string | number> | undefined>[] | undefined;
        marginInline?: readonly (string | (string & {}))[] | csstype.Property.MarginInline<string | number> | readonly NonNullable<csstype.Property.MarginInline<string | number> | undefined>[] | undefined;
        mask?: readonly (string | (string & {}))[] | csstype.Property.Mask<string | number> | readonly NonNullable<csstype.Property.Mask<string | number> | undefined>[] | undefined;
        maskBorder?: csstype.Property.MaskBorder | readonly NonNullable<csstype.Property.MaskBorder | undefined>[] | readonly ("none" | "repeat" | "alpha" | "round" | (string & {}) | csstype.Globals | "space" | "stretch" | "luminance")[] | undefined;
        motion?: readonly (string | (string & {}))[] | csstype.Property.Offset<string | number> | readonly NonNullable<csstype.Property.Offset<string | number> | undefined>[] | undefined;
        offset?: readonly (string | (string & {}))[] | csstype.Property.Offset<string | number> | readonly NonNullable<csstype.Property.Offset<string | number> | undefined>[] | undefined;
        outline?: readonly (string | (string & {}))[] | csstype.Property.Outline<string | number> | readonly NonNullable<csstype.Property.Outline<string | number> | undefined>[] | undefined;
        overflow?: readonly string[] | csstype.Property.Overflow | readonly csstype.Property.Overflow[] | undefined;
        overscrollBehavior?: readonly string[] | csstype.Property.OverscrollBehavior | readonly csstype.Property.OverscrollBehavior[] | undefined;
        padding?: readonly (string | (string & {}))[] | csstype.Property.Padding<string | number> | readonly NonNullable<csstype.Property.Padding<string | number> | undefined>[] | undefined;
        paddingBlock?: readonly (string | (string & {}))[] | csstype.Property.PaddingBlock<string | number> | readonly NonNullable<csstype.Property.PaddingBlock<string | number> | undefined>[] | undefined;
        paddingInline?: readonly (string | (string & {}))[] | csstype.Property.PaddingInline<string | number> | readonly NonNullable<csstype.Property.PaddingInline<string | number> | undefined>[] | undefined;
        placeContent?: readonly string[] | csstype.Property.PlaceContent | readonly csstype.Property.PlaceContent[] | undefined;
        placeItems?: readonly string[] | csstype.Property.PlaceItems | readonly csstype.Property.PlaceItems[] | undefined;
        placeSelf?: readonly string[] | csstype.Property.PlaceSelf | readonly csstype.Property.PlaceSelf[] | undefined;
        scrollMargin?: readonly (string | (string & {}))[] | csstype.Property.ScrollMargin<string | number> | readonly NonNullable<csstype.Property.ScrollMargin<string | number> | undefined>[] | undefined;
        scrollMarginBlock?: readonly (string | (string & {}))[] | csstype.Property.ScrollMarginBlock<string | number> | readonly NonNullable<csstype.Property.ScrollMarginBlock<string | number> | undefined>[] | undefined;
        scrollMarginInline?: readonly (string | (string & {}))[] | csstype.Property.ScrollMarginInline<string | number> | readonly NonNullable<csstype.Property.ScrollMarginInline<string | number> | undefined>[] | undefined;
        scrollPadding?: readonly (string | (string & {}))[] | csstype.Property.ScrollPadding<string | number> | readonly NonNullable<csstype.Property.ScrollPadding<string | number> | undefined>[] | undefined;
        scrollPaddingBlock?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingBlock<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingBlock<string | number> | undefined>[] | undefined;
        scrollPaddingInline?: readonly (string | (string & {}))[] | csstype.Property.ScrollPaddingInline<string | number> | readonly NonNullable<csstype.Property.ScrollPaddingInline<string | number> | undefined>[] | undefined;
        scrollSnapMargin?: readonly (string | (string & {}))[] | csstype.Property.ScrollMargin<string | number> | readonly NonNullable<csstype.Property.ScrollMargin<string | number> | undefined>[] | undefined;
        scrollTimeline?: readonly string[] | csstype.Property.ScrollTimeline | readonly csstype.Property.ScrollTimeline[] | undefined;
        textDecoration?: readonly (string | (string & {}))[] | csstype.Property.TextDecoration<string | number> | readonly NonNullable<csstype.Property.TextDecoration<string | number> | undefined>[] | undefined;
        textEmphasis?: readonly string[] | csstype.Property.TextEmphasis | readonly csstype.Property.TextEmphasis[] | undefined;
        transition?: readonly string[] | csstype.Property.Transition<string & {}> | readonly csstype.Property.Transition<string & {}>[] | undefined;
        viewTimeline?: readonly string[] | csstype.Property.ViewTimeline | readonly csstype.Property.ViewTimeline[] | undefined;
        MozAnimationDelay?: readonly string[] | csstype.Property.AnimationDelay<string & {}> | readonly csstype.Property.AnimationDelay<string & {}>[] | undefined;
        MozAnimationDirection?: readonly string[] | csstype.Property.AnimationDirection | readonly csstype.Property.AnimationDirection[] | undefined;
        MozAnimationDuration?: readonly string[] | csstype.Property.AnimationDuration<string & {}> | readonly csstype.Property.AnimationDuration<string & {}>[] | undefined;
        MozAnimationFillMode?: readonly string[] | csstype.Property.AnimationFillMode | readonly csstype.Property.AnimationFillMode[] | undefined;
        MozAnimationIterationCount?: csstype.Property.AnimationIterationCount | readonly NonNullable<csstype.Property.AnimationIterationCount | undefined>[] | readonly ((string & {}) | csstype.Globals | "infinite")[] | undefined;
        MozAnimationName?: readonly string[] | csstype.Property.AnimationName | readonly csstype.Property.AnimationName[] | undefined;
        MozAnimationPlayState?: readonly string[] | csstype.Property.AnimationPlayState | readonly csstype.Property.AnimationPlayState[] | undefined;
        MozAnimationTimingFunction?: readonly string[] | csstype.Property.AnimationTimingFunction | readonly csstype.Property.AnimationTimingFunction[] | undefined;
        MozAppearance?: csstype.Property.MozAppearance | readonly NonNullable<csstype.Property.MozAppearance | undefined>[] | readonly csstype.Property.MozAppearance[] | undefined;
        MozBinding?: readonly string[] | csstype.Property.MozBinding | readonly csstype.Property.MozBinding[] | undefined;
        MozBorderBottomColors?: readonly string[] | csstype.Property.MozBorderBottomColors | readonly csstype.Property.MozBorderBottomColors[] | undefined;
        MozBorderEndColor?: readonly string[] | csstype.Property.BorderInlineEndColor | readonly csstype.Property.BorderInlineEndColor[] | undefined;
        MozBorderEndStyle?: csstype.Property.BorderInlineEndStyle | readonly NonNullable<csstype.Property.BorderInlineEndStyle | undefined>[] | readonly csstype.Property.BorderInlineEndStyle[] | undefined;
        MozBorderEndWidth?: readonly string[] | csstype.Property.BorderInlineEndWidth<string | number> | readonly NonNullable<csstype.Property.BorderInlineEndWidth<string | number> | undefined>[] | undefined;
        MozBorderLeftColors?: readonly string[] | csstype.Property.MozBorderLeftColors | readonly csstype.Property.MozBorderLeftColors[] | undefined;
        MozBorderRightColors?: readonly string[] | csstype.Property.MozBorderRightColors | readonly csstype.Property.MozBorderRightColors[] | undefined;
        MozBorderStartColor?: readonly string[] | csstype.Property.BorderInlineStartColor | readonly csstype.Property.BorderInlineStartColor[] | undefined;
        MozBorderStartStyle?: csstype.Property.BorderInlineStartStyle | readonly NonNullable<csstype.Property.BorderInlineStartStyle | undefined>[] | readonly csstype.Property.BorderInlineStartStyle[] | undefined;
        MozBorderTopColors?: readonly string[] | csstype.Property.MozBorderTopColors | readonly csstype.Property.MozBorderTopColors[] | undefined;
        MozBoxSizing?: csstype.Property.BoxSizing | readonly NonNullable<csstype.Property.BoxSizing | undefined>[] | readonly csstype.Property.BoxSizing[] | undefined;
        MozColumnCount?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.ColumnCount | readonly NonNullable<csstype.Property.ColumnCount | undefined>[] | undefined;
        MozColumnFill?: csstype.Property.ColumnFill | readonly NonNullable<csstype.Property.ColumnFill | undefined>[] | readonly csstype.Property.ColumnFill[] | undefined;
        MozColumnRuleColor?: readonly string[] | csstype.Property.ColumnRuleColor | readonly csstype.Property.ColumnRuleColor[] | undefined;
        MozColumnRuleStyle?: readonly string[] | csstype.Property.ColumnRuleStyle | readonly csstype.Property.ColumnRuleStyle[] | undefined;
        MozColumnRuleWidth?: readonly (string | (string & {}))[] | csstype.Property.ColumnRuleWidth<string | number> | readonly NonNullable<csstype.Property.ColumnRuleWidth<string | number> | undefined>[] | undefined;
        MozColumnWidth?: readonly string[] | csstype.Property.ColumnWidth<string | number> | readonly NonNullable<csstype.Property.ColumnWidth<string | number> | undefined>[] | undefined;
        MozContextProperties?: readonly string[] | csstype.Property.MozContextProperties | readonly csstype.Property.MozContextProperties[] | undefined;
        MozFontFeatureSettings?: readonly string[] | csstype.Property.FontFeatureSettings | readonly csstype.Property.FontFeatureSettings[] | undefined;
        MozFontLanguageOverride?: readonly string[] | csstype.Property.FontLanguageOverride | readonly csstype.Property.FontLanguageOverride[] | undefined;
        MozHyphens?: csstype.Property.Hyphens | readonly NonNullable<csstype.Property.Hyphens | undefined>[] | readonly csstype.Property.Hyphens[] | undefined;
        MozImageRegion?: readonly string[] | csstype.Property.MozImageRegion | readonly csstype.Property.MozImageRegion[] | undefined;
        MozMarginEnd?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineEnd<string | number> | readonly NonNullable<csstype.Property.MarginInlineEnd<string | number> | undefined>[] | undefined;
        MozMarginStart?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineStart<string | number> | readonly NonNullable<csstype.Property.MarginInlineStart<string | number> | undefined>[] | undefined;
        MozOrient?: csstype.Property.MozOrient | readonly NonNullable<csstype.Property.MozOrient | undefined>[] | readonly csstype.Property.MozOrient[] | undefined;
        MozOsxFontSmoothing?: readonly string[] | csstype.Property.FontSmooth<string | number> | readonly NonNullable<csstype.Property.FontSmooth<string | number> | undefined>[] | undefined;
        MozOutlineRadiusBottomleft?: readonly (string | (string & {}))[] | csstype.Property.MozOutlineRadiusBottomleft<string | number> | readonly NonNullable<csstype.Property.MozOutlineRadiusBottomleft<string | number> | undefined>[] | undefined;
        MozOutlineRadiusBottomright?: readonly (string | (string & {}))[] | csstype.Property.MozOutlineRadiusBottomright<string | number> | readonly NonNullable<csstype.Property.MozOutlineRadiusBottomright<string | number> | undefined>[] | undefined;
        MozOutlineRadiusTopleft?: readonly (string | (string & {}))[] | csstype.Property.MozOutlineRadiusTopleft<string | number> | readonly NonNullable<csstype.Property.MozOutlineRadiusTopleft<string | number> | undefined>[] | undefined;
        MozOutlineRadiusTopright?: readonly (string | (string & {}))[] | csstype.Property.MozOutlineRadiusTopright<string | number> | readonly NonNullable<csstype.Property.MozOutlineRadiusTopright<string | number> | undefined>[] | undefined;
        MozPaddingEnd?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineEnd<string | number> | readonly NonNullable<csstype.Property.PaddingInlineEnd<string | number> | undefined>[] | undefined;
        MozPaddingStart?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineStart<string | number> | readonly NonNullable<csstype.Property.PaddingInlineStart<string | number> | undefined>[] | undefined;
        MozStackSizing?: csstype.Property.MozStackSizing | readonly NonNullable<csstype.Property.MozStackSizing | undefined>[] | readonly csstype.Property.MozStackSizing[] | undefined;
        MozTabSize?: readonly (string | (string & {}))[] | csstype.Property.TabSize<string | number> | readonly NonNullable<csstype.Property.TabSize<string | number> | undefined>[] | undefined;
        MozTextBlink?: csstype.Property.MozTextBlink | readonly NonNullable<csstype.Property.MozTextBlink | undefined>[] | readonly csstype.Property.MozTextBlink[] | undefined;
        MozTextSizeAdjust?: readonly string[] | csstype.Property.TextSizeAdjust | readonly csstype.Property.TextSizeAdjust[] | undefined;
        MozUserFocus?: csstype.Property.MozUserFocus | readonly NonNullable<csstype.Property.MozUserFocus | undefined>[] | readonly csstype.Property.MozUserFocus[] | undefined;
        MozUserModify?: csstype.Property.MozUserModify | readonly NonNullable<csstype.Property.MozUserModify | undefined>[] | readonly csstype.Property.MozUserModify[] | undefined;
        MozUserSelect?: csstype.Property.UserSelect | readonly NonNullable<csstype.Property.UserSelect | undefined>[] | readonly csstype.Property.UserSelect[] | undefined;
        MozWindowDragging?: csstype.Property.MozWindowDragging | readonly NonNullable<csstype.Property.MozWindowDragging | undefined>[] | readonly csstype.Property.MozWindowDragging[] | undefined;
        MozWindowShadow?: csstype.Property.MozWindowShadow | readonly NonNullable<csstype.Property.MozWindowShadow | undefined>[] | readonly csstype.Property.MozWindowShadow[] | undefined;
        msAccelerator?: csstype.Property.MsAccelerator | readonly NonNullable<csstype.Property.MsAccelerator | undefined>[] | readonly csstype.Property.MsAccelerator[] | undefined;
        msBlockProgression?: csstype.Property.MsBlockProgression | readonly NonNullable<csstype.Property.MsBlockProgression | undefined>[] | readonly csstype.Property.MsBlockProgression[] | undefined;
        msContentZoomChaining?: csstype.Property.MsContentZoomChaining | readonly NonNullable<csstype.Property.MsContentZoomChaining | undefined>[] | readonly csstype.Property.MsContentZoomChaining[] | undefined;
        msContentZoomLimitMax?: readonly string[] | csstype.Property.MsContentZoomLimitMax | readonly csstype.Property.MsContentZoomLimitMax[] | undefined;
        msContentZoomLimitMin?: readonly string[] | csstype.Property.MsContentZoomLimitMin | readonly csstype.Property.MsContentZoomLimitMin[] | undefined;
        msContentZoomSnapPoints?: readonly string[] | csstype.Property.MsContentZoomSnapPoints | readonly csstype.Property.MsContentZoomSnapPoints[] | undefined;
        msContentZoomSnapType?: csstype.Property.MsContentZoomSnapType | readonly NonNullable<csstype.Property.MsContentZoomSnapType | undefined>[] | readonly csstype.Property.MsContentZoomSnapType[] | undefined;
        msContentZooming?: csstype.Property.MsContentZooming | readonly NonNullable<csstype.Property.MsContentZooming | undefined>[] | readonly csstype.Property.MsContentZooming[] | undefined;
        msFilter?: readonly string[] | csstype.Property.MsFilter | readonly csstype.Property.MsFilter[] | undefined;
        msFlexDirection?: csstype.Property.FlexDirection | readonly NonNullable<csstype.Property.FlexDirection | undefined>[] | readonly csstype.Property.FlexDirection[] | undefined;
        msFlexPositive?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.FlexGrow | readonly NonNullable<csstype.Property.FlexGrow | undefined>[] | undefined;
        msFlowFrom?: readonly string[] | csstype.Property.MsFlowFrom | readonly csstype.Property.MsFlowFrom[] | undefined;
        msFlowInto?: readonly string[] | csstype.Property.MsFlowInto | readonly csstype.Property.MsFlowInto[] | undefined;
        msGridColumns?: readonly (string | (string & {}))[] | csstype.Property.MsGridColumns<string | number> | readonly NonNullable<csstype.Property.MsGridColumns<string | number> | undefined>[] | undefined;
        msGridRows?: readonly (string | (string & {}))[] | csstype.Property.MsGridRows<string | number> | readonly NonNullable<csstype.Property.MsGridRows<string | number> | undefined>[] | undefined;
        msHighContrastAdjust?: csstype.Property.MsHighContrastAdjust | readonly NonNullable<csstype.Property.MsHighContrastAdjust | undefined>[] | readonly csstype.Property.MsHighContrastAdjust[] | undefined;
        msHyphenateLimitChars?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.MsHyphenateLimitChars | readonly NonNullable<csstype.Property.MsHyphenateLimitChars | undefined>[] | undefined;
        msHyphenateLimitLines?: csstype.Property.MsHyphenateLimitLines | readonly NonNullable<csstype.Property.MsHyphenateLimitLines | undefined>[] | readonly ((string & {}) | csstype.Globals | "no-limit")[] | undefined;
        msHyphenateLimitZone?: readonly (string | (string & {}))[] | csstype.Property.MsHyphenateLimitZone<string | number> | readonly NonNullable<csstype.Property.MsHyphenateLimitZone<string | number> | undefined>[] | undefined;
        msHyphens?: csstype.Property.Hyphens | readonly NonNullable<csstype.Property.Hyphens | undefined>[] | readonly csstype.Property.Hyphens[] | undefined;
        msImeAlign?: csstype.Property.MsImeAlign | readonly NonNullable<csstype.Property.MsImeAlign | undefined>[] | readonly csstype.Property.MsImeAlign[] | undefined;
        msLineBreak?: csstype.Property.LineBreak | readonly NonNullable<csstype.Property.LineBreak | undefined>[] | readonly csstype.Property.LineBreak[] | undefined;
        msOrder?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Order | readonly NonNullable<csstype.Property.Order | undefined>[] | undefined;
        msOverflowStyle?: csstype.Property.MsOverflowStyle | readonly NonNullable<csstype.Property.MsOverflowStyle | undefined>[] | readonly csstype.Property.MsOverflowStyle[] | undefined;
        msOverflowX?: csstype.Property.OverflowX | readonly NonNullable<csstype.Property.OverflowX | undefined>[] | readonly csstype.Property.OverflowX[] | undefined;
        msOverflowY?: csstype.Property.OverflowY | readonly NonNullable<csstype.Property.OverflowY | undefined>[] | readonly csstype.Property.OverflowY[] | undefined;
        msScrollChaining?: csstype.Property.MsScrollChaining | readonly NonNullable<csstype.Property.MsScrollChaining | undefined>[] | readonly csstype.Property.MsScrollChaining[] | undefined;
        msScrollLimitXMax?: readonly string[] | csstype.Property.MsScrollLimitXMax<string | number> | readonly NonNullable<csstype.Property.MsScrollLimitXMax<string | number> | undefined>[] | undefined;
        msScrollLimitXMin?: readonly string[] | csstype.Property.MsScrollLimitXMin<string | number> | readonly NonNullable<csstype.Property.MsScrollLimitXMin<string | number> | undefined>[] | undefined;
        msScrollLimitYMax?: readonly string[] | csstype.Property.MsScrollLimitYMax<string | number> | readonly NonNullable<csstype.Property.MsScrollLimitYMax<string | number> | undefined>[] | undefined;
        msScrollLimitYMin?: readonly string[] | csstype.Property.MsScrollLimitYMin<string | number> | readonly NonNullable<csstype.Property.MsScrollLimitYMin<string | number> | undefined>[] | undefined;
        msScrollRails?: csstype.Property.MsScrollRails | readonly NonNullable<csstype.Property.MsScrollRails | undefined>[] | readonly csstype.Property.MsScrollRails[] | undefined;
        msScrollSnapPointsX?: readonly string[] | csstype.Property.MsScrollSnapPointsX | readonly csstype.Property.MsScrollSnapPointsX[] | undefined;
        msScrollSnapPointsY?: readonly string[] | csstype.Property.MsScrollSnapPointsY | readonly csstype.Property.MsScrollSnapPointsY[] | undefined;
        msScrollSnapType?: csstype.Property.MsScrollSnapType | readonly NonNullable<csstype.Property.MsScrollSnapType | undefined>[] | readonly csstype.Property.MsScrollSnapType[] | undefined;
        msScrollTranslation?: csstype.Property.MsScrollTranslation | readonly NonNullable<csstype.Property.MsScrollTranslation | undefined>[] | readonly csstype.Property.MsScrollTranslation[] | undefined;
        msScrollbar3dlightColor?: readonly string[] | csstype.Property.MsScrollbar3dlightColor | readonly csstype.Property.MsScrollbar3dlightColor[] | undefined;
        msScrollbarArrowColor?: readonly string[] | csstype.Property.MsScrollbarArrowColor | readonly csstype.Property.MsScrollbarArrowColor[] | undefined;
        msScrollbarBaseColor?: readonly string[] | csstype.Property.MsScrollbarBaseColor | readonly csstype.Property.MsScrollbarBaseColor[] | undefined;
        msScrollbarDarkshadowColor?: readonly string[] | csstype.Property.MsScrollbarDarkshadowColor | readonly csstype.Property.MsScrollbarDarkshadowColor[] | undefined;
        msScrollbarFaceColor?: readonly string[] | csstype.Property.MsScrollbarFaceColor | readonly csstype.Property.MsScrollbarFaceColor[] | undefined;
        msScrollbarHighlightColor?: readonly string[] | csstype.Property.MsScrollbarHighlightColor | readonly csstype.Property.MsScrollbarHighlightColor[] | undefined;
        msScrollbarShadowColor?: readonly string[] | csstype.Property.MsScrollbarShadowColor | readonly csstype.Property.MsScrollbarShadowColor[] | undefined;
        msScrollbarTrackColor?: readonly string[] | csstype.Property.MsScrollbarTrackColor | readonly csstype.Property.MsScrollbarTrackColor[] | undefined;
        msTextAutospace?: csstype.Property.MsTextAutospace | readonly NonNullable<csstype.Property.MsTextAutospace | undefined>[] | readonly csstype.Property.MsTextAutospace[] | undefined;
        msTextCombineHorizontal?: readonly string[] | csstype.Property.TextCombineUpright | readonly csstype.Property.TextCombineUpright[] | undefined;
        msTextOverflow?: readonly string[] | csstype.Property.TextOverflow | readonly csstype.Property.TextOverflow[] | undefined;
        msTouchAction?: readonly string[] | csstype.Property.TouchAction | readonly csstype.Property.TouchAction[] | undefined;
        msTouchSelect?: csstype.Property.MsTouchSelect | readonly NonNullable<csstype.Property.MsTouchSelect | undefined>[] | readonly csstype.Property.MsTouchSelect[] | undefined;
        msTransform?: readonly string[] | csstype.Property.Transform | readonly csstype.Property.Transform[] | undefined;
        msTransformOrigin?: readonly (string | (string & {}))[] | csstype.Property.TransformOrigin<string | number> | readonly NonNullable<csstype.Property.TransformOrigin<string | number> | undefined>[] | undefined;
        msTransitionDelay?: readonly string[] | csstype.Property.TransitionDelay<string & {}> | readonly csstype.Property.TransitionDelay<string & {}>[] | undefined;
        msTransitionDuration?: readonly string[] | csstype.Property.TransitionDuration<string & {}> | readonly csstype.Property.TransitionDuration<string & {}>[] | undefined;
        msTransitionProperty?: readonly string[] | csstype.Property.TransitionProperty | readonly csstype.Property.TransitionProperty[] | undefined;
        msTransitionTimingFunction?: readonly string[] | csstype.Property.TransitionTimingFunction | readonly csstype.Property.TransitionTimingFunction[] | undefined;
        msUserSelect?: csstype.Property.MsUserSelect | readonly NonNullable<csstype.Property.MsUserSelect | undefined>[] | readonly csstype.Property.MsUserSelect[] | undefined;
        msWordBreak?: csstype.Property.WordBreak | readonly NonNullable<csstype.Property.WordBreak | undefined>[] | readonly csstype.Property.WordBreak[] | undefined;
        msWrapFlow?: csstype.Property.MsWrapFlow | readonly NonNullable<csstype.Property.MsWrapFlow | undefined>[] | readonly csstype.Property.MsWrapFlow[] | undefined;
        msWrapMargin?: readonly string[] | csstype.Property.MsWrapMargin<string | number> | readonly NonNullable<csstype.Property.MsWrapMargin<string | number> | undefined>[] | undefined;
        msWrapThrough?: csstype.Property.MsWrapThrough | readonly NonNullable<csstype.Property.MsWrapThrough | undefined>[] | readonly csstype.Property.MsWrapThrough[] | undefined;
        msWritingMode?: csstype.Property.WritingMode | readonly NonNullable<csstype.Property.WritingMode | undefined>[] | readonly csstype.Property.WritingMode[] | undefined;
        WebkitAlignContent?: readonly string[] | csstype.Property.AlignContent | readonly csstype.Property.AlignContent[] | undefined;
        WebkitAlignItems?: readonly string[] | csstype.Property.AlignItems | readonly csstype.Property.AlignItems[] | undefined;
        WebkitAlignSelf?: readonly string[] | csstype.Property.AlignSelf | readonly csstype.Property.AlignSelf[] | undefined;
        WebkitAnimationDelay?: readonly string[] | csstype.Property.AnimationDelay<string & {}> | readonly csstype.Property.AnimationDelay<string & {}>[] | undefined;
        WebkitAnimationDirection?: readonly string[] | csstype.Property.AnimationDirection | readonly csstype.Property.AnimationDirection[] | undefined;
        WebkitAnimationDuration?: readonly string[] | csstype.Property.AnimationDuration<string & {}> | readonly csstype.Property.AnimationDuration<string & {}>[] | undefined;
        WebkitAnimationFillMode?: readonly string[] | csstype.Property.AnimationFillMode | readonly csstype.Property.AnimationFillMode[] | undefined;
        WebkitAnimationIterationCount?: csstype.Property.AnimationIterationCount | readonly NonNullable<csstype.Property.AnimationIterationCount | undefined>[] | readonly ((string & {}) | csstype.Globals | "infinite")[] | undefined;
        WebkitAnimationName?: readonly string[] | csstype.Property.AnimationName | readonly csstype.Property.AnimationName[] | undefined;
        WebkitAnimationPlayState?: readonly string[] | csstype.Property.AnimationPlayState | readonly csstype.Property.AnimationPlayState[] | undefined;
        WebkitAnimationTimingFunction?: readonly string[] | csstype.Property.AnimationTimingFunction | readonly csstype.Property.AnimationTimingFunction[] | undefined;
        WebkitAppearance?: csstype.Property.WebkitAppearance | readonly NonNullable<csstype.Property.WebkitAppearance | undefined>[] | readonly csstype.Property.WebkitAppearance[] | undefined;
        WebkitBackdropFilter?: readonly string[] | csstype.Property.BackdropFilter | readonly csstype.Property.BackdropFilter[] | undefined;
        WebkitBackfaceVisibility?: csstype.Property.BackfaceVisibility | readonly NonNullable<csstype.Property.BackfaceVisibility | undefined>[] | readonly csstype.Property.BackfaceVisibility[] | undefined;
        WebkitBackgroundClip?: readonly string[] | csstype.Property.BackgroundClip | readonly csstype.Property.BackgroundClip[] | undefined;
        WebkitBackgroundOrigin?: readonly string[] | csstype.Property.BackgroundOrigin | readonly csstype.Property.BackgroundOrigin[] | undefined;
        WebkitBackgroundSize?: readonly (string | (string & {}))[] | csstype.Property.BackgroundSize<string | number> | readonly NonNullable<csstype.Property.BackgroundSize<string | number> | undefined>[] | undefined;
        WebkitBorderBeforeColor?: readonly string[] | csstype.Property.WebkitBorderBeforeColor | readonly csstype.Property.WebkitBorderBeforeColor[] | undefined;
        WebkitBorderBeforeStyle?: readonly string[] | csstype.Property.WebkitBorderBeforeStyle | readonly csstype.Property.WebkitBorderBeforeStyle[] | undefined;
        WebkitBorderBeforeWidth?: readonly (string | (string & {}))[] | csstype.Property.WebkitBorderBeforeWidth<string | number> | readonly NonNullable<csstype.Property.WebkitBorderBeforeWidth<string | number> | undefined>[] | undefined;
        WebkitBorderBottomLeftRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomLeftRadius<string | number> | undefined>[] | undefined;
        WebkitBorderBottomRightRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomRightRadius<string | number> | undefined>[] | undefined;
        WebkitBorderImageSlice?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BorderImageSlice | readonly NonNullable<csstype.Property.BorderImageSlice | undefined>[] | undefined;
        WebkitBorderTopLeftRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderTopLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopLeftRadius<string | number> | undefined>[] | undefined;
        WebkitBorderTopRightRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderTopRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopRightRadius<string | number> | undefined>[] | undefined;
        WebkitBoxDecorationBreak?: csstype.Property.BoxDecorationBreak | readonly NonNullable<csstype.Property.BoxDecorationBreak | undefined>[] | readonly csstype.Property.BoxDecorationBreak[] | undefined;
        WebkitBoxReflect?: readonly (string | (string & {}))[] | csstype.Property.WebkitBoxReflect<string | number> | readonly NonNullable<csstype.Property.WebkitBoxReflect<string | number> | undefined>[] | undefined;
        WebkitBoxShadow?: readonly string[] | csstype.Property.BoxShadow | readonly csstype.Property.BoxShadow[] | undefined;
        WebkitBoxSizing?: csstype.Property.BoxSizing | readonly NonNullable<csstype.Property.BoxSizing | undefined>[] | readonly csstype.Property.BoxSizing[] | undefined;
        WebkitClipPath?: readonly string[] | csstype.Property.ClipPath | readonly csstype.Property.ClipPath[] | undefined;
        WebkitColumnCount?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.ColumnCount | readonly NonNullable<csstype.Property.ColumnCount | undefined>[] | undefined;
        WebkitColumnFill?: csstype.Property.ColumnFill | readonly NonNullable<csstype.Property.ColumnFill | undefined>[] | readonly csstype.Property.ColumnFill[] | undefined;
        WebkitColumnRuleColor?: readonly string[] | csstype.Property.ColumnRuleColor | readonly csstype.Property.ColumnRuleColor[] | undefined;
        WebkitColumnRuleStyle?: readonly string[] | csstype.Property.ColumnRuleStyle | readonly csstype.Property.ColumnRuleStyle[] | undefined;
        WebkitColumnRuleWidth?: readonly (string | (string & {}))[] | csstype.Property.ColumnRuleWidth<string | number> | readonly NonNullable<csstype.Property.ColumnRuleWidth<string | number> | undefined>[] | undefined;
        WebkitColumnSpan?: csstype.Property.ColumnSpan | readonly NonNullable<csstype.Property.ColumnSpan | undefined>[] | readonly csstype.Property.ColumnSpan[] | undefined;
        WebkitColumnWidth?: readonly string[] | csstype.Property.ColumnWidth<string | number> | readonly NonNullable<csstype.Property.ColumnWidth<string | number> | undefined>[] | undefined;
        WebkitFilter?: readonly string[] | csstype.Property.Filter | readonly csstype.Property.Filter[] | undefined;
        WebkitFlexBasis?: readonly (string | (string & {}))[] | csstype.Property.FlexBasis<string | number> | readonly NonNullable<csstype.Property.FlexBasis<string | number> | undefined>[] | undefined;
        WebkitFlexDirection?: csstype.Property.FlexDirection | readonly NonNullable<csstype.Property.FlexDirection | undefined>[] | readonly csstype.Property.FlexDirection[] | undefined;
        WebkitFlexGrow?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.FlexGrow | readonly NonNullable<csstype.Property.FlexGrow | undefined>[] | undefined;
        WebkitFlexShrink?: csstype.Property.FlexShrink | readonly NonNullable<csstype.Property.FlexShrink | undefined>[] | readonly ((string & {}) | csstype.Globals)[] | undefined;
        WebkitFlexWrap?: csstype.Property.FlexWrap | readonly NonNullable<csstype.Property.FlexWrap | undefined>[] | readonly csstype.Property.FlexWrap[] | undefined;
        WebkitFontFeatureSettings?: readonly string[] | csstype.Property.FontFeatureSettings | readonly csstype.Property.FontFeatureSettings[] | undefined;
        WebkitFontKerning?: csstype.Property.FontKerning | readonly NonNullable<csstype.Property.FontKerning | undefined>[] | readonly csstype.Property.FontKerning[] | undefined;
        WebkitFontSmoothing?: readonly string[] | csstype.Property.FontSmooth<string | number> | readonly NonNullable<csstype.Property.FontSmooth<string | number> | undefined>[] | undefined;
        WebkitFontVariantLigatures?: readonly string[] | csstype.Property.FontVariantLigatures | readonly csstype.Property.FontVariantLigatures[] | undefined;
        WebkitHyphenateCharacter?: readonly string[] | csstype.Property.HyphenateCharacter | readonly csstype.Property.HyphenateCharacter[] | undefined;
        WebkitHyphens?: csstype.Property.Hyphens | readonly NonNullable<csstype.Property.Hyphens | undefined>[] | readonly csstype.Property.Hyphens[] | undefined;
        WebkitInitialLetter?: csstype.Property.InitialLetter | readonly NonNullable<csstype.Property.InitialLetter | undefined>[] | readonly ("normal" | (string & {}) | csstype.Globals)[] | undefined;
        WebkitJustifyContent?: readonly string[] | csstype.Property.JustifyContent | readonly csstype.Property.JustifyContent[] | undefined;
        WebkitLineBreak?: csstype.Property.LineBreak | readonly NonNullable<csstype.Property.LineBreak | undefined>[] | readonly csstype.Property.LineBreak[] | undefined;
        WebkitLineClamp?: readonly ("none" | (string & {}) | csstype.Globals)[] | csstype.Property.WebkitLineClamp | readonly NonNullable<csstype.Property.WebkitLineClamp | undefined>[] | undefined;
        WebkitMarginEnd?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineEnd<string | number> | readonly NonNullable<csstype.Property.MarginInlineEnd<string | number> | undefined>[] | undefined;
        WebkitMarginStart?: readonly (string | (string & {}))[] | csstype.Property.MarginInlineStart<string | number> | readonly NonNullable<csstype.Property.MarginInlineStart<string | number> | undefined>[] | undefined;
        WebkitMaskAttachment?: readonly string[] | csstype.Property.WebkitMaskAttachment | readonly csstype.Property.WebkitMaskAttachment[] | undefined;
        WebkitMaskBoxImageOutset?: readonly (string | (string & {}))[] | csstype.Property.MaskBorderOutset<string | number> | readonly NonNullable<csstype.Property.MaskBorderOutset<string | number> | undefined>[] | undefined;
        WebkitMaskBoxImageRepeat?: readonly string[] | csstype.Property.MaskBorderRepeat | readonly csstype.Property.MaskBorderRepeat[] | undefined;
        WebkitMaskBoxImageSlice?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.MaskBorderSlice | readonly NonNullable<csstype.Property.MaskBorderSlice | undefined>[] | undefined;
        WebkitMaskBoxImageSource?: readonly string[] | csstype.Property.MaskBorderSource | readonly csstype.Property.MaskBorderSource[] | undefined;
        WebkitMaskBoxImageWidth?: readonly (string | (string & {}))[] | csstype.Property.MaskBorderWidth<string | number> | readonly NonNullable<csstype.Property.MaskBorderWidth<string | number> | undefined>[] | undefined;
        WebkitMaskClip?: readonly string[] | csstype.Property.WebkitMaskClip | readonly csstype.Property.WebkitMaskClip[] | undefined;
        WebkitMaskComposite?: readonly string[] | csstype.Property.WebkitMaskComposite | readonly csstype.Property.WebkitMaskComposite[] | undefined;
        WebkitMaskImage?: readonly string[] | csstype.Property.WebkitMaskImage | readonly csstype.Property.WebkitMaskImage[] | undefined;
        WebkitMaskOrigin?: readonly string[] | csstype.Property.WebkitMaskOrigin | readonly csstype.Property.WebkitMaskOrigin[] | undefined;
        WebkitMaskPosition?: readonly (string | (string & {}))[] | csstype.Property.WebkitMaskPosition<string | number> | readonly NonNullable<csstype.Property.WebkitMaskPosition<string | number> | undefined>[] | undefined;
        WebkitMaskPositionX?: readonly (string | (string & {}))[] | csstype.Property.WebkitMaskPositionX<string | number> | readonly NonNullable<csstype.Property.WebkitMaskPositionX<string | number> | undefined>[] | undefined;
        WebkitMaskPositionY?: readonly (string | (string & {}))[] | csstype.Property.WebkitMaskPositionY<string | number> | readonly NonNullable<csstype.Property.WebkitMaskPositionY<string | number> | undefined>[] | undefined;
        WebkitMaskRepeat?: readonly string[] | csstype.Property.WebkitMaskRepeat | readonly csstype.Property.WebkitMaskRepeat[] | undefined;
        WebkitMaskRepeatX?: csstype.Property.WebkitMaskRepeatX | readonly NonNullable<csstype.Property.WebkitMaskRepeatX | undefined>[] | readonly csstype.Property.WebkitMaskRepeatX[] | undefined;
        WebkitMaskRepeatY?: csstype.Property.WebkitMaskRepeatY | readonly NonNullable<csstype.Property.WebkitMaskRepeatY | undefined>[] | readonly csstype.Property.WebkitMaskRepeatY[] | undefined;
        WebkitMaskSize?: readonly (string | (string & {}))[] | csstype.Property.WebkitMaskSize<string | number> | readonly NonNullable<csstype.Property.WebkitMaskSize<string | number> | undefined>[] | undefined;
        WebkitMaxInlineSize?: readonly (string | (string & {}))[] | csstype.Property.MaxInlineSize<string | number> | readonly NonNullable<csstype.Property.MaxInlineSize<string | number> | undefined>[] | undefined;
        WebkitOrder?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Order | readonly NonNullable<csstype.Property.Order | undefined>[] | undefined;
        WebkitOverflowScrolling?: csstype.Property.WebkitOverflowScrolling | readonly NonNullable<csstype.Property.WebkitOverflowScrolling | undefined>[] | readonly csstype.Property.WebkitOverflowScrolling[] | undefined;
        WebkitPaddingEnd?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineEnd<string | number> | readonly NonNullable<csstype.Property.PaddingInlineEnd<string | number> | undefined>[] | undefined;
        WebkitPaddingStart?: readonly (string | (string & {}))[] | csstype.Property.PaddingInlineStart<string | number> | readonly NonNullable<csstype.Property.PaddingInlineStart<string | number> | undefined>[] | undefined;
        WebkitPerspective?: readonly string[] | csstype.Property.Perspective<string | number> | readonly NonNullable<csstype.Property.Perspective<string | number> | undefined>[] | undefined;
        WebkitPerspectiveOrigin?: readonly (string | (string & {}))[] | csstype.Property.PerspectiveOrigin<string | number> | readonly NonNullable<csstype.Property.PerspectiveOrigin<string | number> | undefined>[] | undefined;
        WebkitPrintColorAdjust?: csstype.Property.PrintColorAdjust | readonly NonNullable<csstype.Property.PrintColorAdjust | undefined>[] | readonly csstype.Property.PrintColorAdjust[] | undefined;
        WebkitRubyPosition?: readonly string[] | csstype.Property.RubyPosition | readonly csstype.Property.RubyPosition[] | undefined;
        WebkitScrollSnapType?: readonly string[] | csstype.Property.ScrollSnapType | readonly csstype.Property.ScrollSnapType[] | undefined;
        WebkitShapeMargin?: readonly (string | (string & {}))[] | csstype.Property.ShapeMargin<string | number> | readonly NonNullable<csstype.Property.ShapeMargin<string | number> | undefined>[] | undefined;
        WebkitTapHighlightColor?: readonly string[] | csstype.Property.WebkitTapHighlightColor | readonly csstype.Property.WebkitTapHighlightColor[] | undefined;
        WebkitTextCombine?: readonly string[] | csstype.Property.TextCombineUpright | readonly csstype.Property.TextCombineUpright[] | undefined;
        WebkitTextDecorationColor?: readonly string[] | csstype.Property.TextDecorationColor | readonly csstype.Property.TextDecorationColor[] | undefined;
        WebkitTextDecorationLine?: readonly string[] | csstype.Property.TextDecorationLine | readonly csstype.Property.TextDecorationLine[] | undefined;
        WebkitTextDecorationSkip?: readonly string[] | csstype.Property.TextDecorationSkip | readonly csstype.Property.TextDecorationSkip[] | undefined;
        WebkitTextDecorationStyle?: csstype.Property.TextDecorationStyle | readonly NonNullable<csstype.Property.TextDecorationStyle | undefined>[] | readonly csstype.Property.TextDecorationStyle[] | undefined;
        WebkitTextEmphasisColor?: readonly string[] | csstype.Property.TextEmphasisColor | readonly csstype.Property.TextEmphasisColor[] | undefined;
        WebkitTextEmphasisPosition?: readonly string[] | csstype.Property.TextEmphasisPosition | readonly csstype.Property.TextEmphasisPosition[] | undefined;
        WebkitTextEmphasisStyle?: readonly string[] | csstype.Property.TextEmphasisStyle | readonly csstype.Property.TextEmphasisStyle[] | undefined;
        WebkitTextFillColor?: readonly string[] | csstype.Property.WebkitTextFillColor | readonly csstype.Property.WebkitTextFillColor[] | undefined;
        WebkitTextOrientation?: csstype.Property.TextOrientation | readonly NonNullable<csstype.Property.TextOrientation | undefined>[] | readonly csstype.Property.TextOrientation[] | undefined;
        WebkitTextSizeAdjust?: readonly string[] | csstype.Property.TextSizeAdjust | readonly csstype.Property.TextSizeAdjust[] | undefined;
        WebkitTextStrokeColor?: readonly string[] | csstype.Property.WebkitTextStrokeColor | readonly csstype.Property.WebkitTextStrokeColor[] | undefined;
        WebkitTextStrokeWidth?: readonly string[] | csstype.Property.WebkitTextStrokeWidth<string | number> | readonly NonNullable<csstype.Property.WebkitTextStrokeWidth<string | number> | undefined>[] | undefined;
        WebkitTextUnderlinePosition?: readonly string[] | csstype.Property.TextUnderlinePosition | readonly csstype.Property.TextUnderlinePosition[] | undefined;
        WebkitTouchCallout?: csstype.Property.WebkitTouchCallout | readonly NonNullable<csstype.Property.WebkitTouchCallout | undefined>[] | readonly csstype.Property.WebkitTouchCallout[] | undefined;
        WebkitTransform?: readonly string[] | csstype.Property.Transform | readonly csstype.Property.Transform[] | undefined;
        WebkitTransformOrigin?: readonly (string | (string & {}))[] | csstype.Property.TransformOrigin<string | number> | readonly NonNullable<csstype.Property.TransformOrigin<string | number> | undefined>[] | undefined;
        WebkitTransformStyle?: csstype.Property.TransformStyle | readonly NonNullable<csstype.Property.TransformStyle | undefined>[] | readonly csstype.Property.TransformStyle[] | undefined;
        WebkitTransitionDelay?: readonly string[] | csstype.Property.TransitionDelay<string & {}> | readonly csstype.Property.TransitionDelay<string & {}>[] | undefined;
        WebkitTransitionDuration?: readonly string[] | csstype.Property.TransitionDuration<string & {}> | readonly csstype.Property.TransitionDuration<string & {}>[] | undefined;
        WebkitTransitionProperty?: readonly string[] | csstype.Property.TransitionProperty | readonly csstype.Property.TransitionProperty[] | undefined;
        WebkitTransitionTimingFunction?: readonly string[] | csstype.Property.TransitionTimingFunction | readonly csstype.Property.TransitionTimingFunction[] | undefined;
        WebkitUserModify?: csstype.Property.WebkitUserModify | readonly NonNullable<csstype.Property.WebkitUserModify | undefined>[] | readonly csstype.Property.WebkitUserModify[] | undefined;
        WebkitUserSelect?: csstype.Property.UserSelect | readonly NonNullable<csstype.Property.UserSelect | undefined>[] | readonly csstype.Property.UserSelect[] | undefined;
        WebkitWritingMode?: csstype.Property.WritingMode | readonly NonNullable<csstype.Property.WritingMode | undefined>[] | readonly csstype.Property.WritingMode[] | undefined;
        MozAnimation?: csstype.Property.Animation<string & {}> | readonly NonNullable<csstype.Property.Animation<string & {}> | undefined>[] | readonly ("linear" | "auto" | "none" | "normal" | "reverse" | "paused" | (string & {}) | csstype.Globals | "ease" | "ease-in" | "ease-in-out" | "ease-out" | "step-end" | "step-start" | "alternate" | "alternate-reverse" | "backwards" | "both" | "forwards" | "infinite" | "running")[] | undefined;
        MozBorderImage?: csstype.Property.BorderImage | readonly NonNullable<csstype.Property.BorderImage | undefined>[] | readonly ("none" | "repeat" | "round" | (string & {}) | csstype.Globals | "space" | "stretch")[] | undefined;
        MozColumnRule?: readonly (string | (string & {}))[] | csstype.Property.ColumnRule<string | number> | readonly NonNullable<csstype.Property.ColumnRule<string | number> | undefined>[] | undefined;
        MozColumns?: readonly (string | (string & {}))[] | csstype.Property.Columns<string | number> | readonly NonNullable<csstype.Property.Columns<string | number> | undefined>[] | undefined;
        MozOutlineRadius?: readonly (string | (string & {}))[] | csstype.Property.MozOutlineRadius<string | number> | readonly NonNullable<csstype.Property.MozOutlineRadius<string | number> | undefined>[] | undefined;
        msContentZoomLimit?: readonly string[] | csstype.Property.MsContentZoomLimit | readonly csstype.Property.MsContentZoomLimit[] | undefined;
        msContentZoomSnap?: readonly string[] | csstype.Property.MsContentZoomSnap | readonly csstype.Property.MsContentZoomSnap[] | undefined;
        msFlex?: readonly (string | (string & {}))[] | csstype.Property.Flex<string | number> | readonly NonNullable<csstype.Property.Flex<string | number> | undefined>[] | undefined;
        msScrollLimit?: readonly string[] | csstype.Property.MsScrollLimit | readonly csstype.Property.MsScrollLimit[] | undefined;
        msScrollSnapX?: readonly string[] | csstype.Property.MsScrollSnapX | readonly csstype.Property.MsScrollSnapX[] | undefined;
        msScrollSnapY?: readonly string[] | csstype.Property.MsScrollSnapY | readonly csstype.Property.MsScrollSnapY[] | undefined;
        msTransition?: readonly string[] | csstype.Property.Transition<string & {}> | readonly csstype.Property.Transition<string & {}>[] | undefined;
        WebkitAnimation?: csstype.Property.Animation<string & {}> | readonly NonNullable<csstype.Property.Animation<string & {}> | undefined>[] | readonly ("linear" | "auto" | "none" | "normal" | "reverse" | "paused" | (string & {}) | csstype.Globals | "ease" | "ease-in" | "ease-in-out" | "ease-out" | "step-end" | "step-start" | "alternate" | "alternate-reverse" | "backwards" | "both" | "forwards" | "infinite" | "running")[] | undefined;
        WebkitBorderBefore?: readonly (string | (string & {}))[] | csstype.Property.WebkitBorderBefore<string | number> | readonly NonNullable<csstype.Property.WebkitBorderBefore<string | number> | undefined>[] | undefined;
        WebkitBorderImage?: csstype.Property.BorderImage | readonly NonNullable<csstype.Property.BorderImage | undefined>[] | readonly ("none" | "repeat" | "round" | (string & {}) | csstype.Globals | "space" | "stretch")[] | undefined;
        WebkitBorderRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderRadius<string | number> | readonly NonNullable<csstype.Property.BorderRadius<string | number> | undefined>[] | undefined;
        WebkitColumnRule?: readonly (string | (string & {}))[] | csstype.Property.ColumnRule<string | number> | readonly NonNullable<csstype.Property.ColumnRule<string | number> | undefined>[] | undefined;
        WebkitColumns?: readonly (string | (string & {}))[] | csstype.Property.Columns<string | number> | readonly NonNullable<csstype.Property.Columns<string | number> | undefined>[] | undefined;
        WebkitFlex?: readonly (string | (string & {}))[] | csstype.Property.Flex<string | number> | readonly NonNullable<csstype.Property.Flex<string | number> | undefined>[] | undefined;
        WebkitFlexFlow?: readonly string[] | csstype.Property.FlexFlow | readonly csstype.Property.FlexFlow[] | undefined;
        WebkitMask?: readonly (string | (string & {}))[] | csstype.Property.WebkitMask<string | number> | readonly NonNullable<csstype.Property.WebkitMask<string | number> | undefined>[] | undefined;
        WebkitMaskBoxImage?: csstype.Property.MaskBorder | readonly NonNullable<csstype.Property.MaskBorder | undefined>[] | readonly ("none" | "repeat" | "alpha" | "round" | (string & {}) | csstype.Globals | "space" | "stretch" | "luminance")[] | undefined;
        WebkitTextEmphasis?: readonly string[] | csstype.Property.TextEmphasis | readonly csstype.Property.TextEmphasis[] | undefined;
        WebkitTextStroke?: readonly (string | (string & {}))[] | csstype.Property.WebkitTextStroke<string | number> | readonly NonNullable<csstype.Property.WebkitTextStroke<string | number> | undefined>[] | undefined;
        WebkitTransition?: readonly string[] | csstype.Property.Transition<string & {}> | readonly csstype.Property.Transition<string & {}>[] | undefined;
        azimuth?: readonly string[] | csstype.Property.Azimuth | readonly csstype.Property.Azimuth[] | undefined;
        boxAlign?: csstype.Property.BoxAlign | readonly NonNullable<csstype.Property.BoxAlign | undefined>[] | readonly csstype.Property.BoxAlign[] | undefined;
        boxDirection?: csstype.Property.BoxDirection | readonly NonNullable<csstype.Property.BoxDirection | undefined>[] | readonly csstype.Property.BoxDirection[] | undefined;
        boxFlex?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlex | readonly NonNullable<csstype.Property.BoxFlex | undefined>[] | undefined;
        boxFlexGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlexGroup | readonly NonNullable<csstype.Property.BoxFlexGroup | undefined>[] | undefined;
        boxLines?: csstype.Property.BoxLines | readonly NonNullable<csstype.Property.BoxLines | undefined>[] | readonly csstype.Property.BoxLines[] | undefined;
        boxOrdinalGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxOrdinalGroup | readonly NonNullable<csstype.Property.BoxOrdinalGroup | undefined>[] | undefined;
        boxOrient?: csstype.Property.BoxOrient | readonly NonNullable<csstype.Property.BoxOrient | undefined>[] | readonly csstype.Property.BoxOrient[] | undefined;
        boxPack?: csstype.Property.BoxPack | readonly NonNullable<csstype.Property.BoxPack | undefined>[] | readonly csstype.Property.BoxPack[] | undefined;
        clip?: readonly string[] | csstype.Property.Clip | readonly csstype.Property.Clip[] | undefined;
        gridColumnGap?: readonly (string | (string & {}))[] | csstype.Property.GridColumnGap<string | number> | readonly NonNullable<csstype.Property.GridColumnGap<string | number> | undefined>[] | undefined;
        gridGap?: readonly (string | (string & {}))[] | csstype.Property.GridGap<string | number> | readonly NonNullable<csstype.Property.GridGap<string | number> | undefined>[] | undefined;
        gridRowGap?: readonly (string | (string & {}))[] | csstype.Property.GridRowGap<string | number> | readonly NonNullable<csstype.Property.GridRowGap<string | number> | undefined>[] | undefined;
        imeMode?: csstype.Property.ImeMode | readonly NonNullable<csstype.Property.ImeMode | undefined>[] | readonly csstype.Property.ImeMode[] | undefined;
        offsetBlock?: readonly (string | (string & {}))[] | csstype.Property.InsetBlock<string | number> | readonly NonNullable<csstype.Property.InsetBlock<string | number> | undefined>[] | undefined;
        offsetBlockEnd?: readonly (string | (string & {}))[] | csstype.Property.InsetBlockEnd<string | number> | readonly NonNullable<csstype.Property.InsetBlockEnd<string | number> | undefined>[] | undefined;
        offsetBlockStart?: readonly (string | (string & {}))[] | csstype.Property.InsetBlockStart<string | number> | readonly NonNullable<csstype.Property.InsetBlockStart<string | number> | undefined>[] | undefined;
        offsetInline?: readonly (string | (string & {}))[] | csstype.Property.InsetInline<string | number> | readonly NonNullable<csstype.Property.InsetInline<string | number> | undefined>[] | undefined;
        offsetInlineEnd?: readonly (string | (string & {}))[] | csstype.Property.InsetInlineEnd<string | number> | readonly NonNullable<csstype.Property.InsetInlineEnd<string | number> | undefined>[] | undefined;
        offsetInlineStart?: readonly (string | (string & {}))[] | csstype.Property.InsetInlineStart<string | number> | readonly NonNullable<csstype.Property.InsetInlineStart<string | number> | undefined>[] | undefined;
        scrollSnapCoordinate?: readonly (string | (string & {}))[] | csstype.Property.ScrollSnapCoordinate<string | number> | readonly NonNullable<csstype.Property.ScrollSnapCoordinate<string | number> | undefined>[] | undefined;
        scrollSnapDestination?: readonly (string | (string & {}))[] | csstype.Property.ScrollSnapDestination<string | number> | readonly NonNullable<csstype.Property.ScrollSnapDestination<string | number> | undefined>[] | undefined;
        scrollSnapPointsX?: readonly string[] | csstype.Property.ScrollSnapPointsX | readonly csstype.Property.ScrollSnapPointsX[] | undefined;
        scrollSnapPointsY?: readonly string[] | csstype.Property.ScrollSnapPointsY | readonly csstype.Property.ScrollSnapPointsY[] | undefined;
        scrollSnapTypeX?: csstype.Property.ScrollSnapTypeX | readonly NonNullable<csstype.Property.ScrollSnapTypeX | undefined>[] | readonly csstype.Property.ScrollSnapTypeX[] | undefined;
        scrollSnapTypeY?: csstype.Property.ScrollSnapTypeY | readonly NonNullable<csstype.Property.ScrollSnapTypeY | undefined>[] | readonly csstype.Property.ScrollSnapTypeY[] | undefined;
        KhtmlBoxAlign?: csstype.Property.BoxAlign | readonly NonNullable<csstype.Property.BoxAlign | undefined>[] | readonly csstype.Property.BoxAlign[] | undefined;
        KhtmlBoxDirection?: csstype.Property.BoxDirection | readonly NonNullable<csstype.Property.BoxDirection | undefined>[] | readonly csstype.Property.BoxDirection[] | undefined;
        KhtmlBoxFlex?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlex | readonly NonNullable<csstype.Property.BoxFlex | undefined>[] | undefined;
        KhtmlBoxFlexGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlexGroup | readonly NonNullable<csstype.Property.BoxFlexGroup | undefined>[] | undefined;
        KhtmlBoxLines?: csstype.Property.BoxLines | readonly NonNullable<csstype.Property.BoxLines | undefined>[] | readonly csstype.Property.BoxLines[] | undefined;
        KhtmlBoxOrdinalGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxOrdinalGroup | readonly NonNullable<csstype.Property.BoxOrdinalGroup | undefined>[] | undefined;
        KhtmlBoxOrient?: csstype.Property.BoxOrient | readonly NonNullable<csstype.Property.BoxOrient | undefined>[] | readonly csstype.Property.BoxOrient[] | undefined;
        KhtmlBoxPack?: csstype.Property.BoxPack | readonly NonNullable<csstype.Property.BoxPack | undefined>[] | readonly csstype.Property.BoxPack[] | undefined;
        KhtmlLineBreak?: csstype.Property.LineBreak | readonly NonNullable<csstype.Property.LineBreak | undefined>[] | readonly csstype.Property.LineBreak[] | undefined;
        KhtmlOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Opacity | readonly NonNullable<csstype.Property.Opacity | undefined>[] | undefined;
        KhtmlUserSelect?: csstype.Property.UserSelect | readonly NonNullable<csstype.Property.UserSelect | undefined>[] | readonly csstype.Property.UserSelect[] | undefined;
        MozBackfaceVisibility?: csstype.Property.BackfaceVisibility | readonly NonNullable<csstype.Property.BackfaceVisibility | undefined>[] | readonly csstype.Property.BackfaceVisibility[] | undefined;
        MozBackgroundClip?: readonly string[] | csstype.Property.BackgroundClip | readonly csstype.Property.BackgroundClip[] | undefined;
        MozBackgroundInlinePolicy?: csstype.Property.BoxDecorationBreak | readonly NonNullable<csstype.Property.BoxDecorationBreak | undefined>[] | readonly csstype.Property.BoxDecorationBreak[] | undefined;
        MozBackgroundOrigin?: readonly string[] | csstype.Property.BackgroundOrigin | readonly csstype.Property.BackgroundOrigin[] | undefined;
        MozBackgroundSize?: readonly (string | (string & {}))[] | csstype.Property.BackgroundSize<string | number> | readonly NonNullable<csstype.Property.BackgroundSize<string | number> | undefined>[] | undefined;
        MozBorderRadius?: readonly (string | (string & {}))[] | csstype.Property.BorderRadius<string | number> | readonly NonNullable<csstype.Property.BorderRadius<string | number> | undefined>[] | undefined;
        MozBorderRadiusBottomleft?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomLeftRadius<string | number> | undefined>[] | undefined;
        MozBorderRadiusBottomright?: readonly (string | (string & {}))[] | csstype.Property.BorderBottomRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderBottomRightRadius<string | number> | undefined>[] | undefined;
        MozBorderRadiusTopleft?: readonly (string | (string & {}))[] | csstype.Property.BorderTopLeftRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopLeftRadius<string | number> | undefined>[] | undefined;
        MozBorderRadiusTopright?: readonly (string | (string & {}))[] | csstype.Property.BorderTopRightRadius<string | number> | readonly NonNullable<csstype.Property.BorderTopRightRadius<string | number> | undefined>[] | undefined;
        MozBoxAlign?: csstype.Property.BoxAlign | readonly NonNullable<csstype.Property.BoxAlign | undefined>[] | readonly csstype.Property.BoxAlign[] | undefined;
        MozBoxDirection?: csstype.Property.BoxDirection | readonly NonNullable<csstype.Property.BoxDirection | undefined>[] | readonly csstype.Property.BoxDirection[] | undefined;
        MozBoxFlex?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlex | readonly NonNullable<csstype.Property.BoxFlex | undefined>[] | undefined;
        MozBoxOrdinalGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxOrdinalGroup | readonly NonNullable<csstype.Property.BoxOrdinalGroup | undefined>[] | undefined;
        MozBoxOrient?: csstype.Property.BoxOrient | readonly NonNullable<csstype.Property.BoxOrient | undefined>[] | readonly csstype.Property.BoxOrient[] | undefined;
        MozBoxPack?: csstype.Property.BoxPack | readonly NonNullable<csstype.Property.BoxPack | undefined>[] | readonly csstype.Property.BoxPack[] | undefined;
        MozBoxShadow?: readonly string[] | csstype.Property.BoxShadow | readonly csstype.Property.BoxShadow[] | undefined;
        MozFloatEdge?: csstype.Property.MozFloatEdge | readonly NonNullable<csstype.Property.MozFloatEdge | undefined>[] | readonly csstype.Property.MozFloatEdge[] | undefined;
        MozForceBrokenImageIcon?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.MozForceBrokenImageIcon | readonly NonNullable<csstype.Property.MozForceBrokenImageIcon | undefined>[] | undefined;
        MozOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.Opacity | readonly NonNullable<csstype.Property.Opacity | undefined>[] | undefined;
        MozOutline?: readonly (string | (string & {}))[] | csstype.Property.Outline<string | number> | readonly NonNullable<csstype.Property.Outline<string | number> | undefined>[] | undefined;
        MozOutlineColor?: readonly string[] | csstype.Property.OutlineColor | readonly csstype.Property.OutlineColor[] | undefined;
        MozOutlineStyle?: readonly string[] | csstype.Property.OutlineStyle | readonly csstype.Property.OutlineStyle[] | undefined;
        MozOutlineWidth?: readonly string[] | csstype.Property.OutlineWidth<string | number> | readonly NonNullable<csstype.Property.OutlineWidth<string | number> | undefined>[] | undefined;
        MozPerspective?: readonly string[] | csstype.Property.Perspective<string | number> | readonly NonNullable<csstype.Property.Perspective<string | number> | undefined>[] | undefined;
        MozPerspectiveOrigin?: readonly (string | (string & {}))[] | csstype.Property.PerspectiveOrigin<string | number> | readonly NonNullable<csstype.Property.PerspectiveOrigin<string | number> | undefined>[] | undefined;
        MozTextAlignLast?: csstype.Property.TextAlignLast | readonly NonNullable<csstype.Property.TextAlignLast | undefined>[] | readonly csstype.Property.TextAlignLast[] | undefined;
        MozTextDecorationColor?: readonly string[] | csstype.Property.TextDecorationColor | readonly csstype.Property.TextDecorationColor[] | undefined;
        MozTextDecorationLine?: readonly string[] | csstype.Property.TextDecorationLine | readonly csstype.Property.TextDecorationLine[] | undefined;
        MozTextDecorationStyle?: csstype.Property.TextDecorationStyle | readonly NonNullable<csstype.Property.TextDecorationStyle | undefined>[] | readonly csstype.Property.TextDecorationStyle[] | undefined;
        MozTransform?: readonly string[] | csstype.Property.Transform | readonly csstype.Property.Transform[] | undefined;
        MozTransformOrigin?: readonly (string | (string & {}))[] | csstype.Property.TransformOrigin<string | number> | readonly NonNullable<csstype.Property.TransformOrigin<string | number> | undefined>[] | undefined;
        MozTransformStyle?: csstype.Property.TransformStyle | readonly NonNullable<csstype.Property.TransformStyle | undefined>[] | readonly csstype.Property.TransformStyle[] | undefined;
        MozTransition?: readonly string[] | csstype.Property.Transition<string & {}> | readonly csstype.Property.Transition<string & {}>[] | undefined;
        MozTransitionDelay?: readonly string[] | csstype.Property.TransitionDelay<string & {}> | readonly csstype.Property.TransitionDelay<string & {}>[] | undefined;
        MozTransitionDuration?: readonly string[] | csstype.Property.TransitionDuration<string & {}> | readonly csstype.Property.TransitionDuration<string & {}>[] | undefined;
        MozTransitionProperty?: readonly string[] | csstype.Property.TransitionProperty | readonly csstype.Property.TransitionProperty[] | undefined;
        MozTransitionTimingFunction?: readonly string[] | csstype.Property.TransitionTimingFunction | readonly csstype.Property.TransitionTimingFunction[] | undefined;
        MozUserInput?: csstype.Property.MozUserInput | readonly NonNullable<csstype.Property.MozUserInput | undefined>[] | readonly csstype.Property.MozUserInput[] | undefined;
        msImeMode?: csstype.Property.ImeMode | readonly NonNullable<csstype.Property.ImeMode | undefined>[] | readonly csstype.Property.ImeMode[] | undefined;
        OAnimation?: csstype.Property.Animation<string & {}> | readonly NonNullable<csstype.Property.Animation<string & {}> | undefined>[] | readonly ("linear" | "auto" | "none" | "normal" | "reverse" | "paused" | (string & {}) | csstype.Globals | "ease" | "ease-in" | "ease-in-out" | "ease-out" | "step-end" | "step-start" | "alternate" | "alternate-reverse" | "backwards" | "both" | "forwards" | "infinite" | "running")[] | undefined;
        OAnimationDelay?: readonly string[] | csstype.Property.AnimationDelay<string & {}> | readonly csstype.Property.AnimationDelay<string & {}>[] | undefined;
        OAnimationDirection?: readonly string[] | csstype.Property.AnimationDirection | readonly csstype.Property.AnimationDirection[] | undefined;
        OAnimationDuration?: readonly string[] | csstype.Property.AnimationDuration<string & {}> | readonly csstype.Property.AnimationDuration<string & {}>[] | undefined;
        OAnimationFillMode?: readonly string[] | csstype.Property.AnimationFillMode | readonly csstype.Property.AnimationFillMode[] | undefined;
        OAnimationIterationCount?: csstype.Property.AnimationIterationCount | readonly NonNullable<csstype.Property.AnimationIterationCount | undefined>[] | readonly ((string & {}) | csstype.Globals | "infinite")[] | undefined;
        OAnimationName?: readonly string[] | csstype.Property.AnimationName | readonly csstype.Property.AnimationName[] | undefined;
        OAnimationPlayState?: readonly string[] | csstype.Property.AnimationPlayState | readonly csstype.Property.AnimationPlayState[] | undefined;
        OAnimationTimingFunction?: readonly string[] | csstype.Property.AnimationTimingFunction | readonly csstype.Property.AnimationTimingFunction[] | undefined;
        OBackgroundSize?: readonly (string | (string & {}))[] | csstype.Property.BackgroundSize<string | number> | readonly NonNullable<csstype.Property.BackgroundSize<string | number> | undefined>[] | undefined;
        OBorderImage?: csstype.Property.BorderImage | readonly NonNullable<csstype.Property.BorderImage | undefined>[] | readonly ("none" | "repeat" | "round" | (string & {}) | csstype.Globals | "space" | "stretch")[] | undefined;
        OObjectFit?: csstype.Property.ObjectFit | readonly NonNullable<csstype.Property.ObjectFit | undefined>[] | readonly csstype.Property.ObjectFit[] | undefined;
        OObjectPosition?: readonly (string | (string & {}))[] | csstype.Property.ObjectPosition<string | number> | readonly NonNullable<csstype.Property.ObjectPosition<string | number> | undefined>[] | undefined;
        OTabSize?: readonly (string | (string & {}))[] | csstype.Property.TabSize<string | number> | readonly NonNullable<csstype.Property.TabSize<string | number> | undefined>[] | undefined;
        OTextOverflow?: readonly string[] | csstype.Property.TextOverflow | readonly csstype.Property.TextOverflow[] | undefined;
        OTransform?: readonly string[] | csstype.Property.Transform | readonly csstype.Property.Transform[] | undefined;
        OTransformOrigin?: readonly (string | (string & {}))[] | csstype.Property.TransformOrigin<string | number> | readonly NonNullable<csstype.Property.TransformOrigin<string | number> | undefined>[] | undefined;
        OTransition?: readonly string[] | csstype.Property.Transition<string & {}> | readonly csstype.Property.Transition<string & {}>[] | undefined;
        OTransitionDelay?: readonly string[] | csstype.Property.TransitionDelay<string & {}> | readonly csstype.Property.TransitionDelay<string & {}>[] | undefined;
        OTransitionDuration?: readonly string[] | csstype.Property.TransitionDuration<string & {}> | readonly csstype.Property.TransitionDuration<string & {}>[] | undefined;
        OTransitionProperty?: readonly string[] | csstype.Property.TransitionProperty | readonly csstype.Property.TransitionProperty[] | undefined;
        OTransitionTimingFunction?: readonly string[] | csstype.Property.TransitionTimingFunction | readonly csstype.Property.TransitionTimingFunction[] | undefined;
        WebkitBoxAlign?: csstype.Property.BoxAlign | readonly NonNullable<csstype.Property.BoxAlign | undefined>[] | readonly csstype.Property.BoxAlign[] | undefined;
        WebkitBoxDirection?: csstype.Property.BoxDirection | readonly NonNullable<csstype.Property.BoxDirection | undefined>[] | readonly csstype.Property.BoxDirection[] | undefined;
        WebkitBoxFlex?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlex | readonly NonNullable<csstype.Property.BoxFlex | undefined>[] | undefined;
        WebkitBoxFlexGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxFlexGroup | readonly NonNullable<csstype.Property.BoxFlexGroup | undefined>[] | undefined;
        WebkitBoxLines?: csstype.Property.BoxLines | readonly NonNullable<csstype.Property.BoxLines | undefined>[] | readonly csstype.Property.BoxLines[] | undefined;
        WebkitBoxOrdinalGroup?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.BoxOrdinalGroup | readonly NonNullable<csstype.Property.BoxOrdinalGroup | undefined>[] | undefined;
        WebkitBoxOrient?: csstype.Property.BoxOrient | readonly NonNullable<csstype.Property.BoxOrient | undefined>[] | readonly csstype.Property.BoxOrient[] | undefined;
        WebkitBoxPack?: csstype.Property.BoxPack | readonly NonNullable<csstype.Property.BoxPack | undefined>[] | readonly csstype.Property.BoxPack[] | undefined;
        alignmentBaseline?: csstype.Property.AlignmentBaseline | readonly NonNullable<csstype.Property.AlignmentBaseline | undefined>[] | readonly csstype.Property.AlignmentBaseline[] | undefined;
        baselineShift?: readonly (string | (string & {}))[] | csstype.Property.BaselineShift<string | number> | readonly NonNullable<csstype.Property.BaselineShift<string | number> | undefined>[] | undefined;
        clipRule?: csstype.Property.ClipRule | readonly NonNullable<csstype.Property.ClipRule | undefined>[] | readonly csstype.Property.ClipRule[] | undefined;
        colorInterpolation?: csstype.Property.ColorInterpolation | readonly NonNullable<csstype.Property.ColorInterpolation | undefined>[] | readonly csstype.Property.ColorInterpolation[] | undefined;
        colorRendering?: csstype.Property.ColorRendering | readonly NonNullable<csstype.Property.ColorRendering | undefined>[] | readonly csstype.Property.ColorRendering[] | undefined;
        dominantBaseline?: csstype.Property.DominantBaseline | readonly NonNullable<csstype.Property.DominantBaseline | undefined>[] | readonly csstype.Property.DominantBaseline[] | undefined;
        fill?: readonly string[] | csstype.Property.Fill | readonly csstype.Property.Fill[] | undefined;
        fillOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.FillOpacity | readonly NonNullable<csstype.Property.FillOpacity | undefined>[] | undefined;
        fillRule?: csstype.Property.FillRule | readonly NonNullable<csstype.Property.FillRule | undefined>[] | readonly csstype.Property.FillRule[] | undefined;
        floodColor?: readonly string[] | csstype.Property.FloodColor | readonly csstype.Property.FloodColor[] | undefined;
        floodOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.FloodOpacity | readonly NonNullable<csstype.Property.FloodOpacity | undefined>[] | undefined;
        glyphOrientationVertical?: readonly ("auto" | (string & {}) | csstype.Globals)[] | csstype.Property.GlyphOrientationVertical | readonly NonNullable<csstype.Property.GlyphOrientationVertical | undefined>[] | undefined;
        lightingColor?: readonly string[] | csstype.Property.LightingColor | readonly csstype.Property.LightingColor[] | undefined;
        marker?: readonly string[] | csstype.Property.Marker | readonly csstype.Property.Marker[] | undefined;
        markerEnd?: readonly string[] | csstype.Property.MarkerEnd | readonly csstype.Property.MarkerEnd[] | undefined;
        markerMid?: readonly string[] | csstype.Property.MarkerMid | readonly csstype.Property.MarkerMid[] | undefined;
        markerStart?: readonly string[] | csstype.Property.MarkerStart | readonly csstype.Property.MarkerStart[] | undefined;
        shapeRendering?: csstype.Property.ShapeRendering | readonly NonNullable<csstype.Property.ShapeRendering | undefined>[] | readonly csstype.Property.ShapeRendering[] | undefined;
        stopColor?: readonly string[] | csstype.Property.StopColor | readonly csstype.Property.StopColor[] | undefined;
        stopOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.StopOpacity | readonly NonNullable<csstype.Property.StopOpacity | undefined>[] | undefined;
        stroke?: readonly string[] | csstype.Property.Stroke | readonly csstype.Property.Stroke[] | undefined;
        strokeDasharray?: readonly (string | (string & {}))[] | csstype.Property.StrokeDasharray<string | number> | readonly NonNullable<csstype.Property.StrokeDasharray<string | number> | undefined>[] | undefined;
        strokeDashoffset?: readonly (string | (string & {}))[] | csstype.Property.StrokeDashoffset<string | number> | readonly NonNullable<csstype.Property.StrokeDashoffset<string | number> | undefined>[] | undefined;
        strokeLinecap?: csstype.Property.StrokeLinecap | readonly NonNullable<csstype.Property.StrokeLinecap | undefined>[] | readonly csstype.Property.StrokeLinecap[] | undefined;
        strokeLinejoin?: csstype.Property.StrokeLinejoin | readonly NonNullable<csstype.Property.StrokeLinejoin | undefined>[] | readonly csstype.Property.StrokeLinejoin[] | undefined;
        strokeMiterlimit?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.StrokeMiterlimit | readonly NonNullable<csstype.Property.StrokeMiterlimit | undefined>[] | undefined;
        strokeOpacity?: readonly ((string & {}) | csstype.Globals)[] | csstype.Property.StrokeOpacity | readonly NonNullable<csstype.Property.StrokeOpacity | undefined>[] | undefined;
        strokeWidth?: readonly (string | (string & {}))[] | csstype.Property.StrokeWidth<string | number> | readonly NonNullable<csstype.Property.StrokeWidth<string | number> | undefined>[] | undefined;
        textAnchor?: csstype.Property.TextAnchor | readonly NonNullable<csstype.Property.TextAnchor | undefined>[] | readonly csstype.Property.TextAnchor[] | undefined;
        vectorEffect?: csstype.Property.VectorEffect | readonly NonNullable<csstype.Property.VectorEffect | undefined>[] | readonly csstype.Property.VectorEffect[] | undefined;
        ":-moz-any()"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-dir"?: _emotion_serialize.CSSObject | undefined;
        ":-webkit-any()"?: _emotion_serialize.CSSObject | undefined;
        "::cue"?: _emotion_serialize.CSSObject | undefined;
        "::cue-region"?: _emotion_serialize.CSSObject | undefined;
        "::part"?: _emotion_serialize.CSSObject | undefined;
        "::slotted"?: _emotion_serialize.CSSObject | undefined;
        "::view-transition-group"?: _emotion_serialize.CSSObject | undefined;
        "::view-transition-image-pair"?: _emotion_serialize.CSSObject | undefined;
        "::view-transition-new"?: _emotion_serialize.CSSObject | undefined;
        "::view-transition-old"?: _emotion_serialize.CSSObject | undefined;
        ":dir"?: _emotion_serialize.CSSObject | undefined;
        ":has"?: _emotion_serialize.CSSObject | undefined;
        ":host"?: _emotion_serialize.CSSObject | undefined;
        ":host-context"?: _emotion_serialize.CSSObject | undefined;
        ":is"?: _emotion_serialize.CSSObject | undefined;
        ":lang"?: _emotion_serialize.CSSObject | undefined;
        ":matches()"?: _emotion_serialize.CSSObject | undefined;
        ":not"?: _emotion_serialize.CSSObject | undefined;
        ":nth-child"?: _emotion_serialize.CSSObject | undefined;
        ":nth-last-child"?: _emotion_serialize.CSSObject | undefined;
        ":nth-last-of-type"?: _emotion_serialize.CSSObject | undefined;
        ":nth-of-type"?: _emotion_serialize.CSSObject | undefined;
        ":where"?: _emotion_serialize.CSSObject | undefined;
        ":-khtml-any-link"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-any-link"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-focusring"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-full-screen"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-placeholder"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-read-only"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-read-write"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-ui-invalid"?: _emotion_serialize.CSSObject | undefined;
        ":-moz-ui-valid"?: _emotion_serialize.CSSObject | undefined;
        ":-ms-fullscreen"?: _emotion_serialize.CSSObject | undefined;
        ":-ms-input-placeholder"?: _emotion_serialize.CSSObject | undefined;
        ":-webkit-any-link"?: _emotion_serialize.CSSObject | undefined;
        ":-webkit-full-screen"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-placeholder"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-progress-bar"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-range-progress"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-range-thumb"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-range-track"?: _emotion_serialize.CSSObject | undefined;
        "::-moz-selection"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-backdrop"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-browse"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-check"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-clear"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-expand"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-fill"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-fill-lower"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-fill-upper"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-input-placeholder"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-reveal"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-thumb"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-ticks-after"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-ticks-before"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-tooltip"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-track"?: _emotion_serialize.CSSObject | undefined;
        "::-ms-value"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-backdrop"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-input-placeholder"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-progress-bar"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-progress-inner-value"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-progress-value"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-slider-runnable-track"?: _emotion_serialize.CSSObject | undefined;
        "::-webkit-slider-thumb"?: _emotion_serialize.CSSObject | undefined;
        "::after"?: _emotion_serialize.CSSObject | undefined;
        "::backdrop"?: _emotion_serialize.CSSObject | undefined;
        "::before"?: _emotion_serialize.CSSObject | undefined;
        "::first-letter"?: _emotion_serialize.CSSObject | undefined;
        "::first-line"?: _emotion_serialize.CSSObject | undefined;
        "::grammar-error"?: _emotion_serialize.CSSObject | undefined;
        "::marker"?: _emotion_serialize.CSSObject | undefined;
        "::placeholder"?: _emotion_serialize.CSSObject | undefined;
        "::selection"?: _emotion_serialize.CSSObject | undefined;
        "::spelling-error"?: _emotion_serialize.CSSObject | undefined;
        "::target-text"?: _emotion_serialize.CSSObject | undefined;
        "::view-transition"?: _emotion_serialize.CSSObject | undefined;
        ":active"?: _emotion_serialize.CSSObject | undefined;
        ":after"?: _emotion_serialize.CSSObject | undefined;
        ":any-link"?: _emotion_serialize.CSSObject | undefined;
        ":before"?: _emotion_serialize.CSSObject | undefined;
        ":blank"?: _emotion_serialize.CSSObject | undefined;
        ":checked"?: _emotion_serialize.CSSObject | undefined;
        ":current"?: _emotion_serialize.CSSObject | undefined;
        ":default"?: _emotion_serialize.CSSObject | undefined;
        ":defined"?: _emotion_serialize.CSSObject | undefined;
        ":disabled"?: _emotion_serialize.CSSObject | undefined;
        ":empty"?: _emotion_serialize.CSSObject | undefined;
        ":enabled"?: _emotion_serialize.CSSObject | undefined;
        ":first"?: _emotion_serialize.CSSObject | undefined;
        ":first-child"?: _emotion_serialize.CSSObject | undefined;
        ":first-letter"?: _emotion_serialize.CSSObject | undefined;
        ":first-line"?: _emotion_serialize.CSSObject | undefined;
        ":first-of-type"?: _emotion_serialize.CSSObject | undefined;
        ":focus"?: _emotion_serialize.CSSObject | undefined;
        ":focus-visible"?: _emotion_serialize.CSSObject | undefined;
        ":focus-within"?: _emotion_serialize.CSSObject | undefined;
        ":fullscreen"?: _emotion_serialize.CSSObject | undefined;
        ":future"?: _emotion_serialize.CSSObject | undefined;
        ":hover"?: _emotion_serialize.CSSObject | undefined;
        ":in-range"?: _emotion_serialize.CSSObject | undefined;
        ":indeterminate"?: _emotion_serialize.CSSObject | undefined;
        ":invalid"?: _emotion_serialize.CSSObject | undefined;
        ":last-child"?: _emotion_serialize.CSSObject | undefined;
        ":last-of-type"?: _emotion_serialize.CSSObject | undefined;
        ":left"?: _emotion_serialize.CSSObject | undefined;
        ":link"?: _emotion_serialize.CSSObject | undefined;
        ":local-link"?: _emotion_serialize.CSSObject | undefined;
        ":nth-col"?: _emotion_serialize.CSSObject | undefined;
        ":nth-last-col"?: _emotion_serialize.CSSObject | undefined;
        ":only-child"?: _emotion_serialize.CSSObject | undefined;
        ":only-of-type"?: _emotion_serialize.CSSObject | undefined;
        ":optional"?: _emotion_serialize.CSSObject | undefined;
        ":out-of-range"?: _emotion_serialize.CSSObject | undefined;
        ":past"?: _emotion_serialize.CSSObject | undefined;
        ":paused"?: _emotion_serialize.CSSObject | undefined;
        ":picture-in-picture"?: _emotion_serialize.CSSObject | undefined;
        ":placeholder-shown"?: _emotion_serialize.CSSObject | undefined;
        ":playing"?: _emotion_serialize.CSSObject | undefined;
        ":read-only"?: _emotion_serialize.CSSObject | undefined;
        ":read-write"?: _emotion_serialize.CSSObject | undefined;
        ":required"?: _emotion_serialize.CSSObject | undefined;
        ":right"?: _emotion_serialize.CSSObject | undefined;
        ":root"?: _emotion_serialize.CSSObject | undefined;
        ":scope"?: _emotion_serialize.CSSObject | undefined;
        ":target"?: _emotion_serialize.CSSObject | undefined;
        ":target-within"?: _emotion_serialize.CSSObject | undefined;
        ":user-invalid"?: _emotion_serialize.CSSObject | undefined;
        ":user-valid"?: _emotion_serialize.CSSObject | undefined;
        ":valid"?: _emotion_serialize.CSSObject | undefined;
        ":visited"?: _emotion_serialize.CSSObject | undefined;
        label?: string;
    };
    singleValue: () => {};
    valueContainer: () => {};
};

type SelectContainerProps<Option, isMulti extends boolean, Group extends GroupBase<Option>> = ContainerProps$1<Option, isMulti, Group> & CustomComponentProps<Option, isMulti, Group>;
declare const SelectContainer: <Option, isMulti extends boolean, Group extends GroupBase<Option>>(props: SelectContainerProps<Option, isMulti, Group>) => react_jsx_runtime.JSX.Element;

/** @deprecated Use Combobox component instead */
declare function Select<T, Rest = {}>(props: SelectCommonProps<T> & Rest): react_jsx_runtime.JSX.Element;
declare function MultiSelect<T, Rest = {}>(props: MultiSelectCommonProps<T> & Rest): react_jsx_runtime.JSX.Element;
interface AsyncSelectProps<T> extends Omit<SelectCommonProps<T>, 'options'>, SelectAsyncProps<T> {
    value?: T | SelectableValue<T> | null;
}
/** @deprecated Use Combobox component instead */
declare function AsyncSelect<T, Rest = {}>(props: AsyncSelectProps<T> & Rest): react_jsx_runtime.JSX.Element;
/** @deprecated Use Combobox component instead - it's virtualised by default! */
declare function VirtualizedSelect<T, Rest = {}>(props: VirtualizedSelectProps<T> & Rest): react_jsx_runtime.JSX.Element;
/** @deprecated Use Combobox component instead - it's virtualised by default! */
declare function AsyncVirtualizedSelect<T, Rest = {}>(props: VirtualizedSelectAsyncProps<T> & Rest): react_jsx_runtime.JSX.Element;
interface AsyncMultiSelectProps<T> extends Omit<MultiSelectCommonProps<T>, 'options'>, SelectAsyncProps<T> {
    value?: Array<SelectableValue<T>>;
}
declare function AsyncMultiSelect<T, Rest = {}>(props: AsyncMultiSelectProps<T> & Rest): react_jsx_runtime.JSX.Element;

interface SelectMenuOptionProps<T> {
    isDisabled: boolean;
    isFocused: boolean;
    isSelected: boolean;
    indeterminate?: boolean;
    innerProps: JSX.IntrinsicElements['div'];
    innerRef: RefCallback<HTMLDivElement>;
    renderOptionLabel?: (value: SelectableValue<T>) => JSX.Element;
    data: SelectableValue<T>;
}
declare const SelectMenuOptions: {
    ({ children, data, innerProps, innerRef, isFocused, isSelected, renderOptionLabel, }: React$1.PropsWithChildren<SelectMenuOptionProps<unknown>>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const getSelectStyles: micro_memoize.Memoized<(theme: GrafanaTheme2) => {
    menu: string;
    option: string;
    optionIcon: string;
    optionImage: string;
    optionDescription: string;
    optionBody: string;
    optionFocused: string;
    optionSelected: string;
    optionDisabled: string;
    singleValue: string;
    valueContainer: string;
    valueContainerMulti: string;
    valueContainerMultiNoWrap: string;
    loadingMessage: string;
    multiValueContainer: string;
    multiValueRemove: string;
    singleValueRemove: string;
    groupHeader: string;
    group: string;
    toggleAllButton: string;
}>;

type ComboboxOption<T extends string | number = string> = {
    label?: string;
    value: T;
    description?: string;
    group?: string;
};

interface ComboboxBaseProps<T extends string | number> extends Pick<Props$14, 'placeholder' | 'autoFocus' | 'id' | 'aria-labelledby' | 'disabled' | 'loading' | 'invalid'> {
    /**
     * An `X` appears in the UI, which clears the input and sets the value to `null`. Do not use if you have no `null` case.
     */
    isClearable?: boolean;
    /**
     * Allows the user to set a value which is not in the list of options.
     */
    createCustomValue?: boolean;
    /**
     * An array of options, or a function that returns a promise resolving to an array of options.
     * If a function, it will be called when the menu is opened and on keypress with the current search query.
     */
    options: Array<ComboboxOption<T>> | ((inputValue: string) => Promise<Array<ComboboxOption<T>>>);
    /**
     * onChange handler is called with the newly selected option.
     */
    onChange: (option: ComboboxOption<T>) => void;
    /**
     * Current selected value. Most consumers should pass a scalar value (string | number). However, sometimes with Async
     * it may be better to pass in an Option with a label to display.
     */
    value?: T | ComboboxOption<T> | null;
    /**
     * Defaults to full width of container. Number is a multiple of the spacing unit. 'auto' will size the input to the content.
     * */
    width?: number | 'auto';
    ['data-testid']?: string;
    /**
     * Called when the input loses focus.
     */
    onBlur?: () => void;
}
type ClearableConditionals<T extends number | string> = {
    /**
     * Allow the user to clear the selected value. `null` is emitted from the onChange handler
     */
    isClearable: true;
    /**
     * The onChange handler is called with `null` when clearing the Combobox.
     */
    onChange: (option: ComboboxOption<T> | null) => void;
} | {
    isClearable?: false;
    onChange: (option: ComboboxOption<T>) => void;
};
type AutoSizeConditionals = {
    width: 'auto';
    /**
     * Needs to be set when width is 'auto' to prevent the input from shrinking too much
     */
    minWidth: number;
    /**
     * Recommended to set when width is 'auto' to prevent the input from growing too much.
     */
    maxWidth?: number;
} | {
    width?: number;
    minWidth?: never;
    maxWidth?: never;
};
type ComboboxProps<T extends string | number> = ComboboxBaseProps<T> & AutoSizeConditionals & ClearableConditionals<T>;
/**
 * A performant Select replacement.
 *
 * @alpha
 */
declare const Combobox: <T extends string | number>(props: ComboboxProps<T>) => react_jsx_runtime.JSX.Element;

interface MultiComboboxBaseProps<T extends string | number> extends Omit<ComboboxBaseProps<T>, 'value' | 'onChange'> {
    value?: T[] | Array<ComboboxOption<T>>;
    onChange: (option: Array<ComboboxOption<T>>) => void;
    enableAllOption?: boolean;
}
type MultiComboboxProps<T extends string | number> = MultiComboboxBaseProps<T> & AutoSizeConditionals;
declare const MultiCombobox: <T extends string | number>(props: MultiComboboxProps<T>) => react_jsx_runtime.JSX.Element;

declare enum Orientation {
    Horizontal = 0,
    Vertical = 1
}
type Spacing = 'none' | 'xs' | 'sm' | 'md' | 'lg';
type Justify = 'flex-start' | 'flex-end' | 'space-between' | 'center';
type Align = 'normal' | 'flex-start' | 'flex-end' | 'center';
interface LayoutProps extends Omit<HTMLProps<HTMLDivElement>, 'align' | 'children' | 'wrap'> {
    children: React$1.ReactNode[] | React$1.ReactNode;
    orientation?: Orientation;
    spacing?: Spacing;
    justify?: Justify;
    align?: Align;
    width?: string;
    wrap?: boolean;
}
interface ContainerProps {
    padding?: Spacing;
    margin?: Spacing;
    grow?: number;
    shrink?: number;
}
/**
 * @deprecated use Stack component instead
 */
declare const HorizontalGroup: ({ children, spacing, justify, align, wrap, width, height, }: Omit<LayoutProps, "orientation">) => react_jsx_runtime.JSX.Element;
/**
 * @deprecated use Stack component with the "column" direction instead
 */
declare const VerticalGroup: ({ children, spacing, justify, align, width, height, }: Omit<LayoutProps, "orientation" | "wrap">) => react_jsx_runtime.JSX.Element;
declare const Container: ({ children, padding, margin, grow, shrink }: React$1.PropsWithChildren<ContainerProps>) => react_jsx_runtime.JSX.Element;

type BadgeColor = 'blue' | 'red' | 'green' | 'orange' | 'purple' | 'darkgrey';
interface BadgeProps extends HTMLAttributes<HTMLDivElement> {
    text?: React$1.ReactNode;
    color: BadgeColor;
    icon?: IconName;
    tooltip?: PopoverContent;
}
declare const Badge: React$1.NamedExoticComponent<BadgeProps> & {
    Skeleton: (props: unknown) => react_jsx_runtime.JSX.Element;
};

type RadioButtonSize = 'sm' | 'md';

interface RadioButtonGroupProps<T> {
    value?: T;
    id?: string;
    disabled?: boolean;
    disabledOptions?: T[];
    options: Array<SelectableValue<T>>;
    onChange?: (value: T) => void;
    onClick?: (value: T) => void;
    size?: RadioButtonSize;
    fullWidth?: boolean;
    className?: string;
    autoFocus?: boolean;
    ['aria-label']?: string;
    invalid?: boolean;
}
declare function RadioButtonGroup<T>({ options, value, onChange, onClick, disabled, disabledOptions, size, id, className, fullWidth, autoFocus, 'aria-label': ariaLabel, invalid, }: RadioButtonGroupProps<T>): react_jsx_runtime.JSX.Element;
declare namespace RadioButtonGroup {
    var displayName: string;
}

interface RadioButtonDotProps<T> extends Omit<React$1.HTMLProps<HTMLInputElement>, 'label' | 'value' | 'onChange' | 'type'> {
    id: string;
    name: string;
    checked?: boolean;
    value?: T;
    disabled?: boolean;
    label: React$1.ReactNode;
    description?: string;
    onChange?: (id: string) => void;
}
declare const RadioButtonDot: <T extends string | number | readonly string[]>({ id, name, label, checked, value, disabled, description, onChange, ...props }: RadioButtonDotProps<T>) => react_jsx_runtime.JSX.Element;

interface RadioButtonListProps<T> {
    /** A name of a radio group. Used to group multiple radio inputs into a single group */
    name: string;
    id?: string;
    /** An array of available options */
    options: Array<SelectableValue<T>>;
    value?: T;
    onChange?: (value: T) => void;
    /** Disables all elements in the list */
    disabled?: boolean;
    /** Disables subset of elements in the list. Compares values using the === operator */
    disabledOptions?: T[];
    className?: string;
}
declare function RadioButtonList<T extends string | number | readonly string[]>({ name, id, options, value, onChange, className, disabled, disabledOptions, }: RadioButtonListProps<T>): react_jsx_runtime.JSX.Element;

interface Props$d extends Props$14 {
    /** Sets the min-width to a multiple of 8px. Default value is 10*/
    minWidth?: number;
    /** Sets the max-width to a multiple of 8px.*/
    maxWidth?: number;
    /** onChange function that will be run on onBlur and onKeyPress with enter
     * @deprecated Use `onChange` instead and manage the value in the parent as a controlled input
     */
    onCommitChange?: (event: React$1.FormEvent<HTMLInputElement>) => void;
    /** @deprecated Use `value` and `onChange` instead to manage the value in the parent as a controlled input */
    defaultValue?: string | number | readonly string[];
}
declare const AutoSizeInput: React$1.ForwardRefExoticComponent<Omit<Props$d, "ref"> & React$1.RefAttributes<HTMLInputElement>>;

interface Props$c extends Omit<HTMLProps<HTMLInputElement>, 'onChange'> {
    value: string | undefined;
    width?: number;
    onChange: (value: string) => void;
    escapeRegex?: boolean;
}
declare const FilterInput: React$1.ForwardRefExoticComponent<Omit<Props$c, "ref"> & React$1.RefAttributes<HTMLInputElement>>;

type Props$b = React$1.ComponentProps<typeof Input> & {
    /** TRUE if the secret was already configured. (It is needed as often the backend doesn't send back the actual secret, only the information that it was configured) */
    isConfigured: boolean;
    /** Called when the user clicks on the "Reset" button in order to clear the secret */
    onReset: () => void;
};
declare const SecretInput: ({ isConfigured, onReset, ...props }: Props$b) => react_jsx_runtime.JSX.Element;

interface Props$a extends Omit<HTMLProps<HTMLTextAreaElement>, 'size'> {
    /** Show an invalid state around the input */
    invalid?: boolean;
}
declare const TextArea: React$1.ForwardRefExoticComponent<Omit<Props$a, "ref"> & React$1.RefAttributes<HTMLTextAreaElement>>;

type Props$9 = React$1.ComponentProps<typeof TextArea> & {
    /** TRUE if the secret was already configured. (It is needed as often the backend doesn't send back the actual secret, only the information that it was configured) */
    isConfigured: boolean;
    /** Called when the user clicks on the "Reset" button in order to clear the secret */
    onReset: () => void;
};
/**
 * Text area that does not disclose an already configured value but lets the user reset the current value and enter a new one.
 * Typically useful for asymmetric cryptography keys.
 */
declare const SecretTextArea: ({ isConfigured, onReset, ...props }: Props$9) => react_jsx_runtime.JSX.Element;

interface Props$8 extends Omit<HTMLProps<HTMLInputElement>, 'value'> {
    value?: boolean;
    /** Show an invalid state around the input */
    invalid?: boolean;
}
declare const Switch: React$1.ForwardRefExoticComponent<Omit<Props$8, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
interface InlineSwitchProps extends Props$8 {
    /** Label to show next to the switch */
    showLabel?: boolean;
    /** Make inline switch's background and border transparent */
    transparent?: boolean;
}
declare const InlineSwitch: React$1.ForwardRefExoticComponent<Omit<InlineSwitchProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;

interface CheckboxProps extends Omit<HTMLProps<HTMLInputElement>, 'value'> {
    /** Label to display next to checkbox */
    label?: string;
    /** Description to display under the label */
    description?: string | React$1.ReactElement;
    /** Current value of the checkbox */
    value?: boolean;
    /** htmlValue allows to specify the input "value" attribute */
    htmlValue?: string | number;
    /** Sets the checkbox into a "mixed" state. This is only a visual change and does not affect the value. */
    indeterminate?: boolean;
    /** Show an invalid state around the input */
    invalid?: boolean;
}
declare const Checkbox: React$1.ForwardRefExoticComponent<Omit<CheckboxProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;

interface Props$7 {
    /** Callback function to handle uploaded file  */
    onFileUpload: (event: FormEvent<HTMLInputElement>) => void;
    /** Accepted file extensions */
    accept?: string;
    /** Overwrite or add to style */
    className?: string;
    /** Button size */
    size?: ComponentSize;
    /** Show the file name */
    showFileName?: boolean;
}
declare const FileUpload: ({ onFileUpload, className, children, accept, size, showFileName, }: React$1.PropsWithChildren<Props$7>) => react_jsx_runtime.JSX.Element;

type BackwardsCompatibleDropzoneOptions = Omit<DropzoneOptions, 'accept'> & {
    accept?: string | string[] | Accept;
};
interface FileDropzoneProps {
    /**
     * Use the children property to have custom dropzone view.
     */
    children?: ReactNode;
    /**
     * Use this property to override the default behaviour for the react-dropzone options.
     * @default {
     *  maxSize: Infinity,
     *  minSize: 0,
     *  multiple: true,
     *  useFsAccessApi: false,
     *  maxFiles: 0,
     * }
     */
    options?: BackwardsCompatibleDropzoneOptions;
    /**
     * Use this to change the FileReader's read.
     */
    readAs?: 'readAsArrayBuffer' | 'readAsText' | 'readAsBinaryString' | 'readAsDataURL';
    /**
     * Use the onLoad function to get the result from FileReader.
     */
    onLoad?: (result: string | ArrayBuffer | null) => void;
    /**
     * The fileListRenderer property can be used to overwrite the list of files. To not to show
     * any list return null in the function.
     */
    fileListRenderer?: (file: DropzoneFile, removeFile: (file: DropzoneFile) => void) => ReactNode;
    onFileRemove?: (file: DropzoneFile) => void;
}
interface DropzoneFile {
    file: File;
    id: string;
    error: DOMException | null;
    progress?: number;
    abortUpload?: () => void;
    retryUpload?: () => void;
}
declare function FileDropzone({ options, children, readAs, onLoad, fileListRenderer, onFileRemove }: FileDropzoneProps): react_jsx_runtime.JSX.Element;
declare function FileDropzoneDefaultChildren({ primaryText, secondaryText }: {
    primaryText?: string | undefined;
    secondaryText?: string | undefined;
}): react_jsx_runtime.JSX.Element;

interface FileListItemProps {
    file: DropzoneFile;
    removeFile?: (file: DropzoneFile) => void;
}
declare function FileListItem({ file: customFile, removeFile }: FileListItemProps): react_jsx_runtime.JSX.Element;

interface TimeRangeInputProps {
    value: TimeRange;
    timeZone?: TimeZone;
    onChange: (timeRange: TimeRange) => void;
    onChangeTimeZone?: (timeZone: TimeZone) => void;
    hideTimeZone?: boolean;
    placeholder?: string;
    clearable?: boolean;
    /** Controls horizontal alignment of the picker menu */
    isReversed?: boolean;
    /** Controls visibility of the preset time ranges (e.g. **Last 5 minutes**) in the picker menu */
    hideQuickRanges?: boolean;
    disabled?: boolean;
    showIcon?: boolean;
    /** Which day of the week the calendar should start on. Possible values: "saturday", "sunday" or "monday" */
    weekStart?: WeekStart;
}
declare const TimeRangeInput: ({ value, onChange, onChangeTimeZone, clearable, weekStart, hideTimeZone, timeZone, placeholder, isReversed, hideQuickRanges, disabled, showIcon, }: TimeRangeInputProps) => react_jsx_runtime.JSX.Element;

/**
 * @internal
 */
interface RelativeTimeRangePickerProps {
    timeRange: RelativeTimeRange;
    onChange: (timeRange: RelativeTimeRange) => void;
}
/**
 * @internal
 */
declare function RelativeTimeRangePicker(props: RelativeTimeRangePickerProps): react_jsx_runtime.JSX.Element;

/**
 * @public
 */
interface CardInnerProps {
    href?: string;
    children?: React$1.ReactNode;
}
/**
 * @public
 */
interface CardContainerProps extends HTMLAttributes<HTMLOrSVGElement>, CardInnerProps {
    /** Disable pointer events for the Card, e.g. click events */
    disableEvents?: boolean;
    /** No style change on hover */
    disableHover?: boolean;
    /** Makes the card selectable, set to "true" to apply selected styles */
    isSelected?: boolean;
    /** Custom container styles */
    className?: string;
}
/** @deprecated Using `CardContainer` directly is discouraged and should be replaced with `Card` */
declare const CardContainer: ({ children, disableEvents, disableHover, isSelected, className, href, ...props }: CardContainerProps) => react_jsx_runtime.JSX.Element;

/**
 * @public
 */
interface Props$6 extends Omit<CardContainerProps, 'disableEvents' | 'disableHover'> {
    /** Indicates if the card and all its actions can be interacted with */
    disabled?: boolean;
    /** Link to redirect to on card click. If provided, the Card inner content will be rendered inside `a` */
    href?: string;
    /** On click handler for the Card */
    onClick?: (e: React$1.MouseEvent<HTMLElement>) => void;
    /** @deprecated Use `Card.Heading` instead */
    heading?: ReactNode;
    /** @deprecated Use `Card.Description` instead */
    description?: string;
    isSelected?: boolean;
    /** If true, the padding of the Card will be smaller */
    isCompact?: boolean;
}
interface CardInterface extends FC<Props$6> {
    Heading: typeof Heading;
    Tags: typeof Tags;
    Figure: typeof Figure;
    Meta: typeof Meta;
    Actions: typeof Actions;
    SecondaryActions: typeof SecondaryActions;
    Description: typeof Description;
}
/**
 * Generic card component
 *
 * @public
 */
declare const Card: CardInterface;
interface ChildProps {
    className?: string;
    disabled?: boolean;
    children?: React$1.ReactNode;
}
/** Main heading for the card */
declare const Heading: {
    ({ children, className, "aria-label": ariaLabel }: ChildProps & {
        "aria-label"?: string;
    }): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const Tags: {
    ({ children, className }: ChildProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};
/** Card description text */
declare const Description: {
    ({ children, className }: ChildProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const Figure: {
    ({ children, align, className }: ChildProps & {
        align?: "start" | "center";
    }): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const Meta: React$1.MemoExoticComponent<({ children, className, separator }: ChildProps & {
    separator?: string;
}) => react_jsx_runtime.JSX.Element | null>;
declare const Actions: {
    ({ children, disabled, className }: ChildProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const SecondaryActions: {
    ({ children, disabled, className }: ChildProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};
/**
 * @public
 * @deprecated Use `className` on respective components to modify styles
 */
declare const getCardStyles: (theme: GrafanaTheme2) => {
    tagList: string;
    actions: string;
    secondaryActions: string;
    media: string;
    description: string;
    metadata: string;
    metadataItem: string;
    separator: string;
    heading: string;
    linkHack: string;
    inner: string;
};

interface Props$5 extends Omit<HTMLProps<HTMLDivElement>, 'className' | 'value' | 'style'> {
    value: FormattedValue;
    className?: string;
    style?: CSSProperties;
}
declare const FormattedValueDisplay: {
    ({ value, className, style, ...htmlProps }: Props$5): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface Props$4<T> extends HTMLAttributes<HTMLButtonElement> {
    className?: string;
    options: Array<SelectableValue<T>>;
    value?: SelectableValue<T>;
    onChange: (item: SelectableValue<T>) => void;
    /** @deprecated use tooltip instead, tooltipContent is not being processed in ToolbarButton*/
    tooltipContent?: PopoverContent;
    narrow?: boolean;
    variant?: ToolbarButtonVariant;
    tooltip?: string;
}
/**
 * @internal
 * A temporary component until we have a proper dropdown component
 */
declare const ButtonSelectComponent: {
    <T>(props: Props$4<T>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const ButtonSelect: typeof ButtonSelectComponent;

interface Props$3 {
    overlay: React$1.ReactElement | (() => React$1.ReactElement);
    placement?: TooltipPlacement;
    children: React$1.ReactElement;
    /** Amount in pixels to nudge the dropdown vertically and horizontally, respectively. */
    offset?: [number, number];
    onVisibleChange?: (state: boolean) => void;
}
declare const Dropdown: React$1.MemoExoticComponent<({ children, overlay, placement, offset, onVisibleChange }: Props$3) => react_jsx_runtime.JSX.Element>;

/**
 * @public
 */
interface PluginSignatureBadgeProps extends HTMLAttributes<HTMLDivElement> {
    status?: PluginSignatureStatus;
    signatureType?: PluginSignatureType;
    signatureOrg?: string;
}
/**
 * @public
 */
declare const PluginSignatureBadge: {
    ({ status, color, signatureType, signatureOrg, ...otherProps }: PluginSignatureBadgeProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface UserView {
    user: {
        /** User's name, containing first + last name */
        name: string;
        /** URL to the user's avatar */
        avatarUrl?: string;
    };
    /** Datetime string when the user was last active */
    lastActiveAt: DateTimeInput;
}

interface UserIconProps {
    /** An object that contains the user's details and 'lastActiveAt' status */
    userView: UserView;
    /** A boolean value that determines whether the tooltip should be shown or not */
    showTooltip?: boolean;
    /** An optional class name to be added to the icon element */
    className?: string;
    /** onClick handler to be called when the icon is clicked */
    onClick?: () => void;
}
declare const UserIcon: ({ userView, className, children, onClick, showTooltip, }: PropsWithChildren<UserIconProps>) => react_jsx_runtime.JSX.Element;

interface UsersIndicatorProps {
    /** An object that contains the user's details and 'lastActiveAt' status */
    users: UserView[];
    /** A limit of how many user icons to show before collapsing them and showing a number of users instead */
    limit?: number;
    /** onClick handler for the user number indicator */
    onClick?: () => void;
}
declare const UsersIndicator: ({ users, onClick, limit }: UsersIndicatorProps) => react_jsx_runtime.JSX.Element | null;

interface AvatarProps {
    src: string;
    alt: string;
    width?: ResponsiveProp<ThemeSpacingTokens>;
    height?: ResponsiveProp<ThemeSpacingTokens>;
}
declare const Avatar: ({ src, alt, width, height }: AvatarProps) => react_jsx_runtime.JSX.Element;

interface Props$2 {
    children: ReactNode;
    className?: string;
    htmlFor?: string;
    isFocused?: boolean;
    isInvalid?: boolean;
    tooltip?: PopoverContent;
    width?: number | 'auto';
    /** Make tooltip interactive */
    interactive?: boolean;
}
declare const InlineFormLabel: ({ children, isFocused, isInvalid, className, htmlFor, tooltip, width, interactive, ...rest }: Props$2) => react_jsx_runtime.JSX.Element;

interface DividerProps {
    direction?: 'vertical' | 'horizontal';
    spacing?: ThemeSpacingTokens;
}
declare const Divider: {
    ({ direction, spacing }: DividerProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

type DragHandlePosition = 'middle' | 'start' | 'end';
declare const getDragStyles: (theme: GrafanaTheme2, handlePosition?: DragHandlePosition) => {
    dragHandleVertical: string;
    dragHandleHorizontal: string;
    dragHandleBaseVertical: string;
    dragHandleBaseHorizontal: string;
};

interface UseSplitterOptions {
    /**
     * The initial size of the primary pane between 0-1, defaults to 0.5
     * If `usePixels` is true, this is the initial size in pixels of the second pane.
     */
    initialSize?: number;
    direction: 'row' | 'column';
    dragPosition?: DragHandlePosition;
    usePixels?: boolean;
    /**
     * Called when ever the size of the primary pane changes
     * @param flexSize (float from 0-1)
     */
    onSizeChanged?: (flexSize: number, firstPanePixels: number, secondPanePixels: number) => void;
    onResizing?: (flexSize: number, firstPanePixels: number, secondPanePixels: number) => void;
    handleSize?: ComponentSize;
}
declare function useSplitter(options: UseSplitterOptions): {
    containerProps: {
        ref: React$1.MutableRefObject<HTMLDivElement | null>;
        className: string;
    };
    primaryProps: {
        ref: React$1.MutableRefObject<HTMLDivElement | null>;
        className: string;
        style: React$1.CSSProperties;
    };
    secondaryProps: {
        ref: React$1.MutableRefObject<HTMLDivElement | null>;
        className: string;
        style: React$1.CSSProperties;
    };
    splitterProps: {
        onPointerUp: (e: React$1.PointerEvent<HTMLDivElement>) => void;
        onPointerDown: (e: React$1.PointerEvent<HTMLDivElement>) => void;
        onPointerMove: (e: React$1.PointerEvent<HTMLDivElement>) => void;
        onKeyDown: (e: React$1.KeyboardEvent<HTMLDivElement>) => void;
        onKeyUp: (e: React$1.KeyboardEvent<HTMLDivElement>) => void;
        onDoubleClick: () => void;
        onBlur: () => void;
        ref: React$1.MutableRefObject<HTMLDivElement | null>;
        style: {
            [x: string]: string;
        };
        role: string;
        'aria-valuemin': number;
        'aria-valuemax': number;
        'aria-valuenow': number;
        'aria-controls': string;
        'aria-label': string;
        tabIndex: number;
        className: string;
    };
};

/**
 * @alpha
 */
declare const graphFieldOptions: {
    drawStyle: Array<SelectableValue<GraphDrawStyle>>;
    lineInterpolation: Array<SelectableValue<LineInterpolation>>;
    barAlignment: Array<SelectableValue<BarAlignment>>;
    showPoints: Array<SelectableValue<VisibilityMode>>;
    axisPlacement: Array<SelectableValue<AxisPlacement>>;
    fillGradient: Array<SelectableValue<GraphGradientMode>>;
    stacking: Array<SelectableValue<StackingMode>>;
    thresholdsDisplayModes: Array<SelectableValue<GraphThresholdsStyleMode>>;
};

type UPlotChartState = {
    plot: uPlot | null;
};
/**
 * @internal
 * uPlot abstraction responsible for plot initialisation, setup and refresh
 * Receives a data frame that is x-axis aligned, as of https://github.com/leeoniya/uPlot/tree/master/docs#data-format
 * Exposes context for uPlot instance access
 */
declare class UPlotChart extends Component<PlotProps, UPlotChartState> {
    plotContainer: React$1.RefObject<HTMLDivElement>;
    plotCanvasBBox: React$1.RefObject<DOMRect>;
    plotInstance: uPlot | null;
    constructor(props: PlotProps);
    reinitPlot(): void;
    componentDidMount(): void;
    componentWillUnmount(): void;
    componentDidUpdate(prevProps: PlotProps): void;
    render(): react_jsx_runtime.JSX.Element;
}

interface PlotLegendProps extends VizLegendOptions, Omit<VizLayoutLegendProps, 'children'> {
    data: DataFrame[];
    config: UPlotConfigBuilder;
}
declare const PlotLegend: React$1.MemoExoticComponent<({ data, config, placement, calcs, displayMode, ...vizLayoutLegendProps }: PlotLegendProps) => react_jsx_runtime.JSX.Element>;

interface EventsCanvasProps {
    id: string;
    config: UPlotConfigBuilder;
    events: DataFrame[];
    renderEventMarker: (dataFrame: DataFrame, dataFrameFieldIndex: DataFrameFieldIndex) => React$1.ReactNode;
    mapEventToXYCoords: (dataFrame: DataFrame, dataFrameFieldIndex: DataFrameFieldIndex) => {
        x: number;
        y: number;
    } | undefined;
}
declare function EventsCanvas({ id, events, renderEventMarker, mapEventToXYCoords, config }: EventsCanvasProps): react_jsx_runtime.JSX.Element | null;

interface MarkerProps {
    /** x position relative to plotting area bounding box*/
    x: number;
    /** y position relative to plotting area bounding box*/
    y: number;
}
declare const Marker: ({ x, y, children }: React$1.PropsWithChildren<MarkerProps>) => react_jsx_runtime.JSX.Element;

interface XYCanvasProps {
    top: number;
    left: number;
}
/**
 * Renders absolutely positioned element on top of the uPlot's plotting area (axes are not included!).
 * Useful when you want to render some overlay with canvas-independent elements on top of the plot.
 */
declare const XYCanvas: ({ children, left, top }: React$1.PropsWithChildren<XYCanvasProps>) => react_jsx_runtime.JSX.Element;

declare const enum TooltipHoverMode {
    xOne = 0,
    xAll = 1,
    xyOne = 2
}
type GetDataLinksCallback = (seriesIdx: number, dataIdx: number) => LinkModel[];
interface TooltipPlugin2Props {
    config: UPlotConfigBuilder;
    hoverMode: TooltipHoverMode;
    syncMode?: DashboardCursorSync$1;
    syncScope?: string;
    queryZoom?: (range: {
        from: number;
        to: number;
    }) => void;
    clientZoom?: boolean;
    onSelectRange?: OnSelectRangeCallback;
    getDataLinks?: GetDataLinksCallback;
    render: (u: uPlot, dataIdxs: Array<number | null>, seriesIdx: number | null, isPinned: boolean, dismiss: () => void, timeRange: TimeRange2 | null, viaSync: boolean, dataLinks: LinkModel[]) => React$1.ReactNode;
    maxWidth?: number;
}
interface TimeRange2 {
    from: number;
    to: number;
}
/**
 * @alpha
 */
declare const TooltipPlugin2: ({ config, hoverMode, render, clientZoom, queryZoom, onSelectRange, maxWidth, syncMode, syncScope, getDataLinks, }: TooltipPlugin2Props) => React$1.ReactPortal | null;

interface EventBusPluginProps {
    config: UPlotConfigBuilder;
    eventBus: EventBus;
    frame?: DataFrame;
}
/**
 * @alpha
 */
declare const EventBusPlugin: ({ config, eventBus, frame }: EventBusPluginProps) => null;

interface KeyboardPluginProps {
    config: UPlotConfigBuilder;
}
/**
 * @alpha
 */
declare const KeyboardPlugin: ({ config }: KeyboardPluginProps) => null;

type OnLabelClick = (name: string, value: string | undefined, event: React$1.MouseEvent<HTMLElement>) => void;
interface Props$1 extends Omit<HTMLAttributes<HTMLElement>, 'onClick'> {
    name: string;
    active?: boolean;
    loading?: boolean;
    searchTerm?: string;
    value?: string;
    facets?: number;
    title?: string;
    highlightParts?: HighlightPart[];
    onClick?: OnLabelClick;
}
/**
 * @internal
 */
declare const Label: React$1.ForwardRefExoticComponent<Props$1 & React$1.RefAttributes<HTMLButtonElement>>;

type Props = DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
declare const PanelContainer: ({ children, className, ...props }: Props) => react_jsx_runtime.JSX.Element;

/** @deprecated */
interface FlotItem<T> {
    datapoint: [number, number];
    dataIndex: number;
    series: T;
    seriesIndex: number;
    pageX: number;
    pageY: number;
}

/** @deprecated */
interface GraphProps {
    ariaLabel?: string;
    children?: JSX.Element | JSX.Element[];
    series: GraphSeriesXY[];
    timeRange: TimeRange;
    timeZone?: TimeZone;
    showLines?: boolean;
    showPoints?: boolean;
    showBars?: boolean;
    width: number;
    height: number;
    isStacked?: boolean;
    lineWidth?: number;
    onHorizontalRegionSelected?: (from: number, to: number) => void;
}
/** @deprecated */
interface GraphState {
    pos?: FlotPosition;
    contextPos?: FlotPosition;
    isTooltipVisible: boolean;
    isContextVisible: boolean;
    activeItem?: FlotItem<GraphSeriesXY>;
    contextItem?: FlotItem<GraphSeriesXY>;
}
/**
 * This is a react wrapper for the angular, flot based graph visualization.
 * Rather than using this component, you should use the `<PanelRender .../> with
 * timeseries panel configs.
 *
 * @deprecated
 */
declare class Graph extends PureComponent<GraphProps, GraphState> {
    static defaultProps: {
        showLines: boolean;
        showPoints: boolean;
        showBars: boolean;
        isStacked: boolean;
        lineWidth: number;
    };
    state: GraphState;
    element: HTMLElement | null;
    $element: JQuery<HTMLElement> | null;
    componentDidUpdate(prevProps: GraphProps, prevState: GraphState): void;
    componentDidMount(): void;
    componentWillUnmount(): void;
    onPlotSelected: (event: JQuery.Event, ranges: {
        xaxis: {
            from: number;
            to: number;
        };
    }) => void;
    onPlotHover: (event: JQuery.Event, pos: FlotPosition, item?: FlotItem<GraphSeriesXY>) => void;
    onPlotClick: (event: JQuery.Event, contextPos: FlotPosition, item?: FlotItem<GraphSeriesXY>) => void;
    getYAxes(series: GraphSeriesXY[]): {
        show: boolean;
        index: number;
        position: string;
        min: number | null;
        tickDecimals: number | null;
    }[] | {
        show: boolean;
        min: number;
        max: number;
    }[];
    renderTooltip: () => React$1.ReactElement<VizTooltipProps, string | React$1.JSXElementConstructor<any>> | null;
    renderContextMenu: () => react_jsx_runtime.JSX.Element | null;
    getBarWidth: () => number;
    draw(): void;
    render(): react_jsx_runtime.JSX.Element;
}

interface GraphWithLegendProps extends GraphProps {
    legendDisplayMode: LegendDisplayMode;
    legendVisibility: boolean;
    placement: LegendPlacement;
    hideEmpty?: boolean;
    hideZero?: boolean;
    sortLegendBy?: string;
    sortLegendDesc?: boolean;
    onSeriesToggle?: (label: string, event: React$1.MouseEvent<HTMLElement>) => void;
    onToggleSort: (sortBy: string) => void;
}
declare const GraphWithLegend: (props: GraphWithLegendProps) => react_jsx_runtime.JSX.Element;

/** @deprecated */
interface GraphDimensions extends Dimensions {
    xAxis: Dimension<number>;
    yAxis: Dimension<number>;
}

/** @deprecated */
type ContextDimensions<T extends Dimensions = any> = {
    [key in keyof T]: [number, number | undefined] | null;
};
/** @deprecated */
type GraphContextMenuProps = ContextMenuProps & {
    getContextMenuSource: () => FlotDataPoint | null;
    timeZone?: TimeZone;
    itemsGroup?: MenuGroupProps[];
    dimensions?: GraphDimensions;
    contextDimensions?: ContextDimensions;
};
/** @internal */
declare const GraphContextMenu: ({ getContextMenuSource, timeZone, itemsGroup, dimensions, contextDimensions, ...otherProps }: GraphContextMenuProps) => react_jsx_runtime.JSX.Element;
/** @internal */
declare const GraphContextMenuHeader: ({ timestamp, seriesColor, displayName, displayValue, }: {
    timestamp: string;
    seriesColor: string;
    displayName: string;
    displayValue: FormattedValue;
}) => react_jsx_runtime.JSX.Element;

/** @deprecated */
declare const graphTickFormatter: (epoch: number, axis: any) => string;
/** @deprecated */
declare const graphTimeFormat: (ticks: number | null, min: number | null, max: number | null) => string;

/**
 * Event being triggered when the user interact with the Graph legend.
 * @deprecated
 */
interface GraphNGLegendEvent {
    fieldIndex: DataFrameFieldIndex;
    mode: SeriesVisibilityChangeMode;
}
/** @deprecated */
interface XYFieldMatchers {
    x: FieldMatcher;
    y: FieldMatcher;
}

/**
 * @deprecated
 * @internal -- not a public API
 */
type PropDiffFn<T extends any = any> = (prev: T, next: T) => boolean;
/** @deprecated */
interface GraphNGProps extends Themeable2 {
    frames: DataFrame[];
    structureRev?: number;
    width: number;
    height: number;
    timeRange: TimeRange;
    timeZone: TimeZone[] | TimeZone;
    legend: VizLegendOptions;
    fields?: XYFieldMatchers;
    renderers?: Renderers;
    tweakScale?: (opts: ScaleProps, forField: Field$1) => ScaleProps;
    tweakAxis?: (opts: AxisProps, forField: Field$1) => AxisProps;
    onLegendClick?: (event: GraphNGLegendEvent) => void;
    children?: (builder: UPlotConfigBuilder, alignedFrame: DataFrame) => React$1.ReactNode;
    prepConfig: (alignedFrame: DataFrame, allFrames: DataFrame[], getTimeRange: () => TimeRange) => UPlotConfigBuilder;
    propsToDiff?: Array<string | PropDiffFn>;
    preparePlotFrame?: (frames: DataFrame[], dimFields: XYFieldMatchers) => DataFrame | null;
    renderLegend: (config: UPlotConfigBuilder) => React$1.ReactElement | null;
    /**
     * needed for propsToDiff to re-init the plot & config
     * this is a generic approach to plot re-init, without having to specify which panel-level options
     * should cause invalidation. we can drop this in favor of something like panelOptionsRev that gets passed in
     * similar to structureRev. then we can drop propsToDiff entirely.
     */
    options?: Record<string, any>;
}
/**
 * @internal -- not a public API
 * @deprecated
 */
interface GraphNGState {
    alignedFrame: DataFrame;
    alignedData?: AlignedData;
    config?: UPlotConfigBuilder;
}
/**
 * "Time as X" core component, expects ascending x
 * @deprecated
 */
declare class GraphNG extends Component<GraphNGProps, GraphNGState> {
    static contextType: React$1.Context<PanelContext>;
    panelContext: PanelContext;
    private plotInstance;
    private subscription;
    constructor(props: GraphNGProps);
    getTimeRange: () => TimeRange;
    prepState(props: GraphNGProps, withConfig?: boolean): GraphNGState;
    handleCursorUpdate(evt: DataHoverEvent | LegacyGraphHoverEvent): void;
    componentDidMount(): void;
    componentDidUpdate(prevProps: GraphNGProps): void;
    componentWillUnmount(): void;
    render(): react_jsx_runtime.JSX.Element | null;
}

declare function cardChrome(theme: GrafanaTheme2): string;
declare function hoverColor(color: string, theme: GrafanaTheme2): string;
declare function listItem(theme: GrafanaTheme2): string;
declare function listItemSelected(theme: GrafanaTheme2): string;
declare function mediaUp(breakpoint: string): string;
declare const focusCss: (theme: GrafanaTheme | GrafanaTheme2) => string;
declare function getMouseFocusStyles(theme: GrafanaTheme | GrafanaTheme2): {
    outline: string;
    boxShadow: string;
};
declare function getFocusStyles(theme: GrafanaTheme2): {
    outline: string;
    outlineOffset: string;
    boxShadow: string;
    transitionTimingFunction: string;
    transitionDuration: string;
    transitionProperty: string;
};
declare const getTooltipContainerStyles: (theme: GrafanaTheme2) => {
    overflow: string;
    background: string;
    boxShadow: string;
    maxWidth: string;
    padding: string;
    borderRadius: string;
    zIndex: number;
};
interface ExternalRadiusAdditionalOptions {
    selfBorderWidth?: number;
    childBorderRadius?: number;
}
/**
 * Calculates a border radius for an element, based on border radius of its child.
 *
 * @param theme
 * @param offset - The distance to offset from the child element, should be >= 0.
 * @param additionalOptions
 * @param additionalOptions.selfBorderWidth - The border width of the element itself (default: 1)
 * @param additionalOptions.childBorderRadius - The border radius of the child element (default: theme default radius)
 * @returns A CSS calc() expression that returns the relative external radius value
 */
declare const getExternalRadius: (theme: GrafanaTheme2, offset: number, additionalOptions?: ExternalRadiusAdditionalOptions) => string;
interface InternalRadiusAdditionalOptions {
    parentBorderWidth?: number;
    parentBorderRadius?: number;
}
/**
 * Calculates a border radius for an element, based on border radius of its parent.
 *
 * @param theme
 * @param offset - The distance to offset from the parent element, should be >= 0.
 * @param additionalOptions
 * @param additionalOptions.parentBorderWidth - The border width of the parent element (default: 1)
 * @param additionalOptions.parentBorderRadius - The border radius of the parent element (default: theme default radius)
 * @returns A CSS calc() expression that returns the relative internal radius value
 */
declare const getInternalRadius: (theme: GrafanaTheme2, offset: number, additionalOptions?: InternalRadiusAdditionalOptions) => string;

declare const mixins_d_cardChrome: typeof cardChrome;
declare const mixins_d_focusCss: typeof focusCss;
declare const mixins_d_getExternalRadius: typeof getExternalRadius;
declare const mixins_d_getFocusStyles: typeof getFocusStyles;
declare const mixins_d_getInternalRadius: typeof getInternalRadius;
declare const mixins_d_getMouseFocusStyles: typeof getMouseFocusStyles;
declare const mixins_d_getTooltipContainerStyles: typeof getTooltipContainerStyles;
declare const mixins_d_hoverColor: typeof hoverColor;
declare const mixins_d_listItem: typeof listItem;
declare const mixins_d_listItemSelected: typeof listItemSelected;
declare const mixins_d_mediaUp: typeof mediaUp;
declare namespace mixins_d {
  export { mixins_d_cardChrome as cardChrome, mixins_d_focusCss as focusCss, mixins_d_getExternalRadius as getExternalRadius, mixins_d_getFocusStyles as getFocusStyles, mixins_d_getInternalRadius as getInternalRadius, mixins_d_getMouseFocusStyles as getMouseFocusStyles, mixins_d_getTooltipContainerStyles as getTooltipContainerStyles, mixins_d_hoverColor as hoverColor, mixins_d_listItem as listItem, mixins_d_listItemSelected as listItemSelected, mixins_d_mediaUp as mediaUp };
}

declare function addTooltipOptions<T extends OptionsWithTooltip>(builder: PanelOptionsEditorBuilder<T>, singleOnly?: boolean, setProximity?: boolean, defaultOptions?: Partial<OptionsWithTooltip>): void;

declare const StackingEditor: ({ value, context, onChange, item, }: StandardEditorProps<StackingConfig, {
    options: Array<SelectableValue<StackingMode>>;
}>) => react_jsx_runtime.JSX.Element;
declare function addStackingConfig(builder: FieldConfigEditorBuilder<GraphFieldConfig>, defaultConfig?: StackingConfig, category?: string[]): void;

/**
 * @alpha
 */
declare function addHideFrom(builder: FieldConfigEditorBuilder<HideableFieldConfig>): void;

/**
 * @alpha
 */
declare function addAxisConfig(builder: FieldConfigEditorBuilder<AxisConfig>, defaultConfig: AxisConfig): void;
/**
 * @internal
 */
declare const ScaleDistributionEditor: ({ value, onChange }: StandardEditorProps<ScaleDistributionConfig>) => react_jsx_runtime.JSX.Element;
/** @internal */
declare function addAxisWidth(builder: FieldConfigEditorBuilder<AxisConfig>): void;
/** @internal */
declare function addAxisPlacement(builder: FieldConfigEditorBuilder<AxisConfig>, optionsFilter?: (placement: AxisPlacement) => boolean): void;

interface OptionsFormat {
    onlyIn?: (node: Node) => boolean;
    getSyntax?: (node: Node) => string;
    renderMark?: ({ mark, children }: {
        mark: Mark;
        children: React$1.ReactNode;
    }) => void | React$1.ReactNode;
}

interface Token {
    content: string;
    offsets?: {
        start: number;
        end: number;
    };
    types: string[];
    aliases: string[];
    prev?: Token | null;
    next?: Token | null;
}
/**
 * A Slate plugin to highlight code syntax.
 */
declare function SlatePrism(optsParam?: OptionsFormat, prismLanguages?: LanguageMap): Plugin;

declare const TimeSeries: React$1.FunctionComponent<{
    fields?: XYFieldMatchers | undefined;
    width: number;
    options?: Record<string, any> | undefined;
    timeZone: _grafana_data.TimeZone[] | _grafana_data.TimeZone;
    height: number;
    legend: schema.VizLegendOptions;
    structureRev?: number | undefined;
    children?: ((builder: UPlotConfigBuilder, alignedFrame: DataFrame) => React$1.ReactNode) | undefined;
    timeRange: TimeRange;
    frames: DataFrame[];
    renderers?: Renderers | undefined;
    tweakScale?: ((opts: ScaleProps, forField: _grafana_data.Field) => ScaleProps) | undefined;
    tweakAxis?: ((opts: AxisProps, forField: _grafana_data.Field) => AxisProps) | undefined;
    onLegendClick?: ((event: GraphNGLegendEvent) => void) | undefined;
    preparePlotFrame?: ((frames: DataFrame[], dimFields: XYFieldMatchers) => DataFrame | null) | undefined;
}>;

/** @deprecated */
declare const useGraphNGContext: () => {
    dimFields: XYFieldMatchers;
    mapSeriesIndexToDataFrameFieldIndex: (index: number) => DataFrameFieldIndex;
    getXAxisField: () => Field$1<any> | null;
    alignedData: DataFrame;
};

declare function preparePlotFrame(frames: DataFrame[], dimFields: XYFieldMatchers, timeRange?: TimeRange | null): DataFrame | null;
declare function buildScaleKey(config: FieldConfig<GraphFieldConfig>, fieldType: FieldType): string;

interface ZoomPluginProps {
    onZoom: (range: {
        from: number;
        to: number;
    }) => void;
    withZoomY?: boolean;
    config: UPlotConfigBuilder;
}
/**
 * @alpha
 */
declare const ZoomPlugin: ({ onZoom, config, withZoomY }: ZoomPluginProps) => null;

interface TooltipPluginProps {
    timeZone: TimeZone;
    data: DataFrame;
    frames?: DataFrame[];
    config: UPlotConfigBuilder;
    mode?: TooltipDisplayMode;
    sortOrder?: SortOrder;
    sync?: () => DashboardCursorSync;
    renderTooltip?: (alignedFrame: DataFrame, seriesIdx: number | null, datapointIdx: number | null) => React$1.ReactNode;
}
/**
 * @alpha
 */
declare const TooltipPlugin: ({ mode, sortOrder, sync, timeZone, config, renderTooltip, ...otherProps }: TooltipPluginProps) => react_jsx_runtime.JSX.Element | null;

interface ElementSelectionOnSelectOptions {
    /** If specified, this will ignore the shift key press */
    multi?: boolean;
    /** If true, this will make sure the element is selected */
    force?: boolean;
}
/** @alpha */
interface ElementSelectionContextState {
    /**
     * Turn on selection mode & show selection state
     */
    enabled?: boolean;
    /** List of currently selected elements */
    selected: ElementSelectionContextItem[];
    onSelect: (item: ElementSelectionContextItem, options: ElementSelectionOnSelectOptions) => void;
    onClear: () => void;
}
interface ElementSelectionContextItem {
    id: string;
}
declare const ElementSelectionContext: React__default.Context<ElementSelectionContextState | undefined>;
interface UseElementSelectionResult {
    isSelected?: boolean;
    isSelectable?: boolean;
    onSelect?: (evt: React__default.PointerEvent, options?: ElementSelectionOnSelectOptions) => void;
    onClear?: () => void;
}
declare function useElementSelection(id: string | undefined): UseElementSelectionResult;

/** @deprecated Please use non-legacy versions of these components */
declare const LegacyForms: {
    SecretFormField: {
        ({ label, labelWidth, inputWidth, onReset, isConfigured, tooltip, placeholder, interactive, ...inputProps }: Props$1e): react_jsx_runtime.JSX.Element;
        displayName: string;
    };
    FormField: {
        ({ label, tooltip, labelWidth, inputWidth, inputEl, className, interactive, ...inputProps }: Props$1f): react_jsx_runtime.JSX.Element;
        displayName: string;
    };
    Select: typeof Select$1;
    AsyncSelect: typeof AsyncSelect$1;
    IndicatorsContainer: <T>(props: react_select.IndicatorsContainerProps<_grafana_data.SelectableValue<T>>) => react_jsx_runtime.JSX.Element;
    NoOptionsMessage: <T extends unknown>(props: Props$1h<T>) => react_jsx_runtime.JSX.Element;
    Input: typeof Input$1;
    Switch: React$1.FunctionComponent<{
        label: string;
        tooltip?: string | undefined;
        transparent?: boolean | undefined;
        onChange: (event: React.SyntheticEvent<HTMLInputElement>) => void;
        disabled?: boolean | undefined;
        className?: string | undefined;
        checked: boolean;
        tooltipPlacement?: _popperjs_core.Placement | undefined;
        labelClass?: string | undefined;
        switchClass?: string | undefined;
    }>;
};

type Omit$1<T, K> = Pick<T, Exclude<keyof T, K>>;
type Subtract<T, K> = Omit$1<T, keyof K>;
/** @deprecated use withTheme2 */
/** @public */
declare const withTheme: <P extends Themeable, S extends {} = {}>(Component: React$1.ComponentType<P>) => React$1.FunctionComponent<Subtract<P, Themeable>> & S;
/** @alpha */
declare const withTheme2: <P extends Themeable2, S extends {} = {}>(Component: React$1.ComponentType<P>) => React$1.FunctionComponent<Subtract<P, Themeable2>> & S;
/** @deprecated use useTheme2 */
/** @public */
declare function useTheme(): GrafanaTheme;
/** @public */
declare function useTheme2(): GrafanaTheme2;
/**
 * Hook for using memoized styles with access to the theme.
 *
 * NOTE: For memoization to work, you need to ensure that the function
 * you pass in doesn't change, or only if it needs to. (i.e. declare
 * your style creator outside of a function component or use `useCallback()`.)
 * */
/** @deprecated use useStyles2 */
/** @public */
declare function useStyles<T>(getStyles: (theme: GrafanaTheme) => T): T;
/**
 * Hook for using memoized styles with access to the theme. Pass additional
 * arguments to the getStyles function as additional arguments to this hook.
 *
 * Prefer using primitive values (boolean, number, string, etc) for
 * additional arguments for better performance
 *
 * ```
 * const getStyles = (theme, isDisabled, isOdd) => {css(...)}
 * [...]
 * const styles = useStyles2(getStyles, true, Boolean(index % 2))
 * ```
 *
 * NOTE: For memoization to work, ensure that all arguments don't change
 * across renders (or only change if they need to)
 *
 * @public
 * */
declare function useStyles2<T extends unknown[], CSSReturnValue>(getStyles: (theme: GrafanaTheme2, ...args: T) => CSSReturnValue, ...additionalArguments: T): CSSReturnValue;
/**
 * Enables theme context mocking
 */
/** @public */
declare const mockThemeContext: (theme: Partial<GrafanaTheme2>) => () => void;

/** @public */
declare const getTheme: (mode?: "dark" | "light") => GrafanaTheme;
/** @public */
declare const mockTheme: (mock: (name?: string) => GrafanaTheme) => () => void;

/**
 * @public
 * @deprecated use useStyles hook
 *  Creates memoized version of styles creator
 * @param stylesCreator function accepting dependencies based on which styles are created
 */
declare function stylesFactory<ResultFn extends (...newArgs: any[]) => ReturnType<ResultFn>>(stylesCreator: ResultFn): micro_memoize.Memoized<ResultFn>;

interface GlobalStylesProps {
    isExtensionSidebarOpen?: boolean;
}
/** @internal */
declare function GlobalStyles(props: GlobalStylesProps): react_jsx_runtime.JSX.Element;

/**
 * @alpha
 */
declare function addLegendOptions<T extends OptionsWithLegend>(builder: PanelOptionsEditorBuilder<T>, includeLegendCalcs?: boolean, showLegend?: boolean): void;

/**
 * Adds common text control options to a visualization options
 * @param builder
 * @param withTitle
 * @public
 */
declare function addTextSizeOptions<T extends OptionsWithTextFormatting>(builder: PanelOptionsEditorBuilder<T>, withTitle?: boolean): void;

declare const index_d_ScaleDistributionEditor: typeof ScaleDistributionEditor;
declare const index_d_StackingEditor: typeof StackingEditor;
declare const index_d_addAxisConfig: typeof addAxisConfig;
declare const index_d_addAxisPlacement: typeof addAxisPlacement;
declare const index_d_addAxisWidth: typeof addAxisWidth;
declare const index_d_addHideFrom: typeof addHideFrom;
declare const index_d_addLegendOptions: typeof addLegendOptions;
declare const index_d_addStackingConfig: typeof addStackingConfig;
declare const index_d_addTextSizeOptions: typeof addTextSizeOptions;
declare const index_d_addTooltipOptions: typeof addTooltipOptions;
declare namespace index_d {
  export { index_d_ScaleDistributionEditor as ScaleDistributionEditor, index_d_StackingEditor as StackingEditor, index_d_addAxisConfig as addAxisConfig, index_d_addAxisPlacement as addAxisPlacement, index_d_addAxisWidth as addAxisWidth, index_d_addHideFrom as addHideFrom, index_d_addLegendOptions as addLegendOptions, index_d_addStackingConfig as addStackingConfig, index_d_addTextSizeOptions as addTextSizeOptions, index_d_addTooltipOptions as addTooltipOptions };
}

declare function BracesPlugin(): Plugin;

declare function ClearPlugin(): Plugin;

declare function ClipboardPlugin(): Plugin;

declare function IndentationPlugin(): Plugin;

declare function NewlinePlugin(): Plugin;

declare function RunnerPlugin({ handler }: {
    handler?: (e: React$1.KeyboardEvent) => void;
}): Plugin;

declare function SelectionShortcutsPlugin(): Plugin;

declare global {
    interface Window {
        grafanaBootData?: BootData;
    }
}
declare function SuggestionsPlugin({ onTypeahead, cleanText, onWillApplySuggestion, portalOrigin, }: {
    onTypeahead?: (typeahead: TypeaheadInput) => Promise<TypeaheadOutput>;
    cleanText?: (text: string) => string;
    onWillApplySuggestion?: (suggestion: string, state: SuggestionsState) => string;
    portalOrigin: string;
}): Plugin;

export { ALERTING_COLOR, type ActionMeta, type AdHocFilterItem, Alert, type AlertVariant, AlertingSettings, AsyncMultiSelect, AsyncSelect, type AsyncSelectProps, AsyncVirtualizedSelect, AutoSaveField, AutoSizeInput, Avatar, Badge, type BadgeColor, type BadgeProps, BarGauge, BigValue, BigValueColorMode, BigValueGraphMode, BigValueJustifyMode, BigValueTextMode, Box, BracesPlugin, Label as BrowserLabel, Button, ButtonCascader, ButtonGroup, type ButtonProps, ButtonSelect, type ButtonVariant, CallToActionCard, Card, CardContainer, type CardContainerProps, type Props$6 as CardProps, Carousel, Cascader, type CascaderOption, CertificationKey, Checkbox, ClearPlugin, ClickOutsideWrapper, ClipboardButton, ClipboardPlugin, CodeEditor, type MonacoOptions as CodeEditorMonacoOptions, type CodeEditorSuggestionItem, CodeEditorSuggestionItemKind, CollapsableSection, Collapse, ColorPicker, ColorPickerInput, type Column, Combobox, type ComboboxOption, type CompletionItem, type CompletionItemGroup, CompletionItemKind, type ComponentSize, ConfirmButton, ConfirmModal, type ConfirmModalProps, Container, ContextMenu, type ContextMenuProps, type ControlComponent, ControlledCollapse, Counter, type CustomCellRendererProps, type CustomComponentProps, type CustomControlProps, CustomHeadersSettings, CustomScrollbar, DEFAULT_ANNOTATION_COLOR, dom_d as DOMUtil, DataLinkButton, DataLinkInput, DataLinksContextMenu, type DataLinksContextMenuApi, type DataLinksContextMenuProps, DataLinksInlineEditor, DataLinksInlineEditorBase, type DataLinksInlineEditorBaseProps, DataSourceHttpSettings, DatePicker, type DatePickerProps, DatePickerWithInput, type DatePickerWithInputProps, DateTimePicker, DeleteButton, Divider, type DragHandlePosition, Drawer, Dropdown, type DropzoneFile, ElementSelectionContext, type ElementSelectionContextItem, type ElementSelectionContextState, type ElementSelectionOnSelectOptions, EmptySearchResult, EmptyState, ErrorBoundary, ErrorBoundaryAlert, type ErrorBoundaryAlertProps, ErrorWithStack, EventBusPlugin, EventsCanvas, EventsWithValidation, FIXED_UNIT, FadeTransition, FeatureBadge, FeatureInfoBox, type FetchDataArgs, type FetchDataFunc, Field, FieldArray, type FieldArrayApi, FieldLinkList, type FieldProps, FieldSet, FieldValidationMessage, FileDropzone, FileDropzoneDefaultChildren, type FileDropzoneProps, FileListItem, type FileListItemProps, FileUpload, FilterInput, FilterPill, Form, type FormAPI, type FormInputSize, type FormatOptionLabelMeta, FormattedValueDisplay, FullWidthButtonContainer, Gauge, GlobalStyles, Graph, GraphContextMenu, GraphContextMenuHeader, GraphNG, type GraphNGLegendEvent, type GraphNGProps, GraphSeriesToggler, type GraphSeriesTogglerAPI, GraphWithLegend, Grid, type HighlightPart, HorizontalGroup, Icon, IconButton, type IconButtonVariant, type IconSize, type IconType, IndentationPlugin, InfoBox, InlineField, InlineFieldRow, InlineFormLabel, InlineLabel, InlineSegmentGroup, InlineSwitch, InlineToast, Input, type InputActionMeta, InputControl, InteractiveTable, JSONFormatter, JsonExplorer, KeyboardPlugin, Label$1 as Label, LegacyForms, LegacyInputStatus, Legend, Link, LinkButton, List, type LoadOptionsCallback, LoadingBar, type LoadingBarProps, LoadingPlaceholder, type LoadingPlaceholderProps, Marker, Menu, MenuGroup, type MenuGroupProps, MenuItem, type MenuItemProps, type MenuItemsGroup, type MenuProps, Modal, ModalHeader, type Props$Q as ModalProps, ModalRoot, ModalTabContent, ModalTabsHeader, ModalsContext, ModalsController, ModalsProvider, type Monaco, type MonacoEditor, MultiCombobox, MultiSelect, type MultiSelectCommonProps, NO_DATA_COLOR, NewlinePlugin, NodeGraphDataFrameFieldNames, OK_COLOR, type OnSelectRangeCallback, type OnTagClick, PENDING_COLOR, PageToolbar, Pagination, PanelChrome, LoadingIndicator as PanelChromeLoadingIndicator, type LoadingIndicatorProps as PanelChromeLoadingIndicatorProps, type PanelChromeProps, type PanelChromeType, PanelContainer, type PanelContext, PanelContextProvider, PanelContextRoot, type PanelPadding, PlotLegend, type PlotSelection, type PlotTooltipInterpolator, PluginSignatureBadge, type PluginSignatureBadgeProps, Popover, type PopoverContent, PopoverController, Portal, PortalContainer, QueryField, type QueryFieldProps, REGION_FILL_ALPHA, RadioButtonDot, RadioButtonGroup, RadioButtonList, type RangeSelection1D, type RangeSelection2D, RangeSlider, ReactMonacoEditorLazy as ReactMonacoEditor, type ReactSelectProps, reactUtils_d as ReactUtils, RefreshPicker, RelativeTimeRangePicker, RenderUserContentAsHTML, RunnerPlugin, SCHEMA, ScrollContainer, type ScrollbarPosition, type SearchFunction, SearchFunctionType, SecretInput, SecretTextArea, SecureSocksProxySettings, Segment, SegmentAsync, SegmentInput, SegmentSection, SegmentSelect, Select, type SelectAsyncProps, type SelectBaseProps, type SelectCommonProps, SelectContainer, type SelectContainerProps, SelectMenuOptions, type SelectOptions, type SelectValue, type SelectableOptGroup, SelectionShortcutsPlugin, SeriesColorPicker, SeriesColorPickerPopover, SeriesColorPickerPopoverWithTheme, SeriesIcon, SeriesTable, type SeriesTableProps, SeriesTableRow, type SeriesTableRowProps, SeriesVisibilityChangeBehavior, SeriesVisibilityChangeMode, SetInterval, type SingleStatBaseOptions, SlatePrism, SlideOutTransition, Slider, Space, Sparkline, Spinner, Stack, StatsPicker, SuggestionsPlugin, type SuggestionsState, Switch, TLSAuthSettings, Tab, type TabConfig, TabContent, type TabProps, TabbedContainer, Table, TableCellInspector, TableCellInspectorMode, type TableCustomCellOptions, type TableFieldOptions, type TableFooterCalc, TableInputCSV, type TableSortByFieldState, TabsBar, Tag, TagList, TagsInput, Text, TextArea, TextLink, type Themeable, type Themeable2, TimeOfDayPicker, TimePickerTooltip, TimeRangeInput, TimeRangeLabel, TimeRangePicker, type TimeRangePickerProps, TimeRangeProvider, TimeSeries, TimeZonePicker, ToggleAllState, Toggletip, type Token, ToolbarButton, ToolbarButtonRow, Tooltip, TooltipPlugin, TooltipPlugin2, type TypeaheadInput, type TypeaheadOutput, UPLOT_AXIS_FONT_SIZE, UPlotChart, UPlotConfigBuilder, type UPlotConfigPrepFn, UnitPicker, type UseElementSelectionResult, UserIcon, type UserIconProps, type UserView, UsersIndicator, type UsersIndicatorProps, type ValidationEvents, type ValidationRule, ValuePicker, VerticalGroup, VerticalTab, VirtualizedSelect, type VirtualizedSelectAsyncProps, type VirtualizedSelectProps, VizLayout, type VizLayoutComponentType, type VizLayoutLegendProps, type VizLayoutProps, VizLegend, type VizLegendItem, VizLegendListItem, VizRepeater, type VizRepeaterRenderValueProps, VizTooltip, VizTooltipContainer, type WeekStart, WeekStartPicker, WithContextMenu, XYCanvas, ZoomPlugin, attachDebugger, buildScaleKey, calculateFontSize, clearButtonStyles, colors, index_d as commonOptionsBuilder, convertOldAngularValueMapping, createLogger, createPointerDistance, defaultIntervals, fieldMatchersUI, fuzzyMatch, getAvailableIcons, getCanvasContext, getCardStyles, getCellLinks, getDragStyles, getFieldTypeIcon, getFieldTypeIconName, getInputStyles, getPortalContainer, getScrollbarWidth, getSelectStyles, getTagColor, getTagColorIndexFromName, getTagColorsFromName, getTextColorForAlphaBackground, getTextColorForBackground, getTheme, getWeekStart, graphFieldOptions, graphTickFormatter, graphTimeFormat, hasValidationEvent, isIconSize, isWeekStart, linkModelToContextMenuItems, logOptions, makeFragment, makeValue, measureText, mockTheme, mockThemeContext, preparePlotFrame, regexValidation, resetSelectStyles, sharedInputStyle, sharedSingleStatMigrationHandler, sharedSingleStatPanelChangedHandler, sortedColors, mixins_d as styleMixins, stylesFactory, useElementSelection, useForceUpdate, useGraphNGContext, usePanelContext, usePointerDistance, useSplitter, useStyles, useStyles2, useTheme, useTheme2, validate, variableSuggestionToCodeEditorSuggestion, withErrorBoundary, withTheme, withTheme2 };