vuetify

const allowedVariants: readonly [
    'elevated',
    'flat',
    'tonal',
    'outlined',
    'text',
    'plain'
];

const block: readonly ['top', 'bottom'];

const breakpoints: readonly ['sm', 'md', 'lg', 'xl', 'xxl'];

const IconValue: PropType<any>;

const inline: readonly ['start', 'end', 'left', 'right'];

const locationStrategies: {
    static: typeof staticLocationStrategy;
    connected: typeof connectedLocationStrategy;
};

const scrollStrategies: {
    none: null;
    close: typeof closeScrollStrategy;
    block: typeof blockScrollStrategy;
    reposition: typeof repositionScrollStrategy;
};

const version: string;

const VSnackbar: any;

blockScrollStrategy: (data: ScrollStrategyData, props: StrategyProps) => void;

closeScrollStrategy: (data: ScrollStrategyData) => void;

connectedLocationStrategy: (
    data: LocationStrategyData,
    props: StrategyProps$1,
    contentStyles: Ref<Record<string, string>>
) => {
    updateLocation: () =>
        | {
              available: { x: number; y: number };
              contentBox: Box;
              flipped: { x: boolean; y: boolean };
          }
        | undefined;
};

createVuetify: typeof createVuetify;

deepEqual: (a: any, b: any) => boolean;

EventProp: <T extends any[] = any[]>() => PropType<(...args: T) => void>;

provideExpanded: (props: ExpandProps) => {
    expand: (item: DataTableItem, value: boolean) => void;
    expanded: Ref<Set<string>, Set<string>> & {
        readonly externalValue: readonly string[];
    };
    expandOnClick: Ref<boolean, boolean>;
    isExpanded: (item: DataTableItem) => boolean;
    toggleExpand: (item: DataTableItem) => void;
};

provideSelection: (
    props: SelectionProps,
    {
        allItems,
        currentPage,
    }: { allItems: Ref<SelectableItem[]>; currentPage: Ref<SelectableItem[]> }
) => {
    toggleSelect: (item: SelectableItem, index?: number, event?: MouseEvent) => void;
    select: (items: SelectableItem[], value: boolean) => void;
    selectAll: (value: boolean) => void;
    isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
    isSomeSelected: (items: SelectableItem | SelectableItem[]) => boolean;
    someSelected: vue.ComputedRef<boolean>;
    allSelected: vue.ComputedRef<boolean>;
    showSelectAll: Ref<boolean, boolean>;
    lastSelectedIndex: vue.ShallowRef<number, number>;
    selectStrategy: vue.ComputedRef<DataTableSelectStrategy>;
};

repositionScrollStrategy: (
    data: ScrollStrategyData,
    props: StrategyProps,
    scope: EffectScope
) => void;

staticLocationStrategy: () => void;

useDate: () => DateInstance;

useDefaults: {
    <T extends Record<string, any>>(props: T, name?: string): T;
    (props?: undefined, name?: string): Record<string, any>;
};

useDisplay: (
    props?: DisplayProps,
    name?: string
) => {
    displayClasses: Ref<{ [x: string]: boolean }, { [x: string]: boolean }>;
    mobile: vue.ComputedRef<boolean>;
    xs: Ref<boolean>;
    sm: Ref<boolean>;
    md: Ref<boolean>;
    lg: Ref<boolean>;
    xl: Ref<boolean>;
    xxl: Ref<boolean>;
    smAndUp: Ref<boolean>;
    mdAndUp: Ref<boolean>;
    lgAndUp: Ref<boolean>;
    xlAndUp: Ref<boolean>;
    smAndDown: Ref<boolean>;
    mdAndDown: Ref<boolean>;
    lgAndDown: Ref<boolean>;
    xlAndDown: Ref<boolean>;
    name: Ref<DisplayBreakpoint>;
    height: Ref<number>;
    width: Ref<number>;
    mobileBreakpoint: Ref<number | DisplayBreakpoint>;
    platform: Ref<DisplayPlatform>;
    thresholds: Ref<DisplayThresholds>;
    ssr: boolean;
    update(): void;
};

useGoTo: (_options?: GoToOptions) => {
    (
        target: ComponentPublicInstance | HTMLElement | string | number,
        options?: Partial<GoToOptions>
    ): Promise<unknown>;
    horizontal(
        target: ComponentPublicInstance | HTMLElement | string | number,
        options?: Partial<GoToOptions>
    ): Promise<unknown>;
};

useLayout: () => {
    getLayoutItem: (id: string) => LayoutItem | undefined;
    mainRect: Ref<Layer, Layer>;
    mainStyles: Ref<CSSProperties, CSSProperties>;
};

useLocale: () => LocaleInstance & RtlInstance;

useRtl: () => { isRtl: Ref<boolean, boolean>; rtlClasses: Ref<string, string> };

useTheme: () => ThemeInstance;

type ActiveStrategy = {
    activate: ActiveStrategyFunction;
    in: ActiveStrategyTransformInFunction;
    out: ActiveStrategyTransformOutFunction;
};

type Anchor =
    | Tblock
    | Tinline
    | 'center'
    | 'center center'
    | `${Tblock} ${Tinline | 'center'}`
    | `${Tinline} ${Tblock | 'center'}`;

type CellPropsFunction<T> = (
    data: Pick<
        ItemKeySlot<T>,
        'index' | 'item' | 'internalItem' | 'value' | 'column'
    >
) => Record<string, any>;

type DataTableCompareFunction<T = any> = (a: T, b: T) => number | null;

type DataTableHeader<T = Record<string, any>> = {
    key?:
        | 'data-table-group'
        | 'data-table-select'
        | 'data-table-expand'
        | (string & {});
    value?: SelectItemKey<T>;
    title?: string;
    fixed?: boolean;
    align?: 'start' | 'end' | 'center';
    width?: number | string;
    minWidth?: number | string;
    maxWidth?: number | string;
    nowrap?: boolean;
    headerProps?: Record<string, any>;
    cellProps?: HeaderCellProps;
    sortable?: boolean;
    sort?: DataTableCompareFunction;
    sortRaw?: DataTableCompareFunction;
    filter?: FilterFunction;
    children?: DataTableHeader<T>[];
};

type HeaderCellPropsFunction = (
    data: Pick<ItemKeySlot<any>, 'index' | 'item' | 'internalItem' | 'value'>
) => Record<string, any>;

type RowPropsFunction<T> = (
    data: Pick<ItemKeySlot<T>, 'index' | 'item' | 'internalItem'>
) => Record<string, any>;

type SortItem = {
    key: string;
    order?: boolean | 'asc' | 'desc';
};

type DateOptions = Partial<InternalDateOptions>;

type DefaultsInstance =
    | undefined
    | {
          [key: string]: undefined | Record<string, unknown>;
          global?: Record<string, unknown>;
      };

type DisplayBreakpoint = 'xs' | Breakpoint;

type DisplayThresholds = {
    [key in DisplayBreakpoint]: number;
};

type FilterFunction = (
    value: string,
    query: string,
    item?: InternalItem
) => FilterMatch;

type FilterMatch = boolean | number | FilterMatchArray;

type IconOptions = Partial<InternalIconOptions>;

type JSXComponent<Props = any> =
    | {
          new (): ComponentPublicInstance<Props>;
      }
    | FunctionalComponent<Props>;

type LocationStrategyFunction = (
    data: LocationStrategyData,
    props: StrategyProps$1,
    contentStyles: Ref<Record<string, string>>
) =>
    | undefined
    | {
          updateLocation: (e?: Event) => void;
      };

type OpenStrategy = {
    open: OpenStrategyFunction;
    select: OpenSelectStrategyFunction;
};

type ScrollStrategyFunction = (
    data: ScrollStrategyData,
    props: StrategyProps,
    scope: EffectScope
) => void;

type SelectStrategy = {
    select: SelectStrategyFunction;
    in: SelectStrategyTransformInFunction;
    out: SelectStrategyTransformOutFunction;
};

type SnackbarMessage =
    | string
    | (Omit<
          VSnackbar['$props'],
          | 'modelValue'
          | 'onUpdate:modelValue'
          | 'activator'
          | 'activatorProps'
          | 'closeDelay'
          | 'openDelay'
          | 'openOnClick'
          | 'openOnFocus'
          | 'openOnHover'
          | 'style'
          | '$children'
          | 'v-slots'
          | `v-slot:${string}`
          | keyof VNodeProps
      > & {
          style?: any;
      });

type ThemeDefinition = DeepPartial<InternalThemeDefinition>;

type ValidationRule =
    | ValidationResult
    | PromiseLike<ValidationResult>
    | ((value: any) => ValidationResult)
    | ((value: any) => PromiseLike<ValidationResult>);