@unicom-cloud/ui 0.8.41

package/types/hooks/useMotion.d.ts

@@ -0,0 +1,20 @@
+export interface MotionSensorState {
+    acceleration: {
+        x: number | null;
+        y: number | null;
+        z: number | null;
+    };
+    accelerationIncludingGravity: {
+        x: number | null;
+        y: number | null;
+        z: number | null;
+    };
+    rotationRate: {
+        alpha: number | null;
+        beta: number | null;
+        gamma: number | null;
+    };
+    interval: number | null;
+}
+declare const useMotion: (initialState?: MotionSensorState) => MotionSensorState;
+export default useMotion;

package/types/hooks/useMount.d.ts

@@ -0,0 +1,2 @@
+declare const useMount: (fn: () => void) => void;
+export default useMount;

package/types/hooks/useMountedState.d.ts

@@ -0,0 +1 @@
+export default function useMountedState(): () => boolean;

package/types/hooks/useMouse.d.ts

@@ -0,0 +1,13 @@
+import { RefObject } from 'react';
+export interface State {
+    docX: number;
+    docY: number;
+    posX: number;
+    posY: number;
+    elX: number;
+    elY: number;
+    elH: number;
+    elW: number;
+}
+declare const useMouse: (ref: RefObject<Element>) => State;
+export default useMouse;

package/types/hooks/useMouseHovered.d.ts

@@ -0,0 +1,8 @@
+import { RefObject } from 'react';
+import { State } from './useMouse';
+export interface UseMouseHoveredOptions {
+    whenHovered?: boolean;
+    bound?: boolean;
+}
+declare const useMouseHovered: (ref: RefObject<Element>, options?: UseMouseHoveredOptions) => State;
+export default useMouseHovered;

package/types/hooks/useMouseWheel.d.ts

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

package/types/hooks/useMultiStateValidator.d.ts

@@ -0,0 +1,9 @@
+import { StateValidator, UseStateValidatorReturn, ValidityState } from './useStateValidator';
+export type MultiStateValidatorStates = any[] | {
+    [p: string]: any;
+} | {
+    [p: number]: any;
+};
+export type MultiStateValidator<V extends ValidityState, S extends MultiStateValidatorStates> = StateValidator<V, S>;
+export declare function useMultiStateValidator<V extends ValidityState, S extends MultiStateValidatorStates>(states: S, validator: MultiStateValidator<V, S>, initialValidity?: V): UseStateValidatorReturn<V>;
+export default useMultiStateValidator;

package/types/hooks/useNetworkState.d.ts

@@ -0,0 +1,22 @@
+import { IHookStateInitAction } from './misc/hookState';
+export interface INetworkInformation extends EventTarget {
+    readonly downlink: number;
+    readonly downlinkMax: number;
+    readonly effectiveType: 'slow-2g' | '2g' | '3g' | '4g';
+    readonly rtt: number;
+    readonly saveData: boolean;
+    readonly type: 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown';
+    onChange: (event: Event) => void;
+}
+export interface IUseNetworkState {
+    online: boolean | undefined;
+    previous: boolean | undefined;
+    since: Date | undefined;
+    downlink: INetworkInformation['downlink'] | undefined;
+    downlinkMax: INetworkInformation['downlinkMax'] | undefined;
+    effectiveType: INetworkInformation['effectiveType'] | undefined;
+    rtt: INetworkInformation['rtt'] | undefined;
+    saveData: INetworkInformation['saveData'] | undefined;
+    type: INetworkInformation['type'] | undefined;
+}
+export default function useNetworkState(initialState?: IHookStateInitAction<IUseNetworkState>): IUseNetworkState;

package/types/hooks/useNumber.d.ts

@@ -0,0 +1,2 @@
+import useNumber from './useCounter';
+export default useNumber;

package/types/hooks/useObservable.d.ts

@@ -0,0 +1,8 @@
+export interface Observable<T> {
+    subscribe: (listener: (value: T) => void) => {
+        unsubscribe: () => void;
+    };
+}
+declare function useObservable<T>(observable$: Observable<T>): T | undefined;
+declare function useObservable<T>(observable$: Observable<T>, initialValue: T): T;
+export default useObservable;

package/types/hooks/useOrientation.d.ts

@@ -0,0 +1,6 @@
+export interface OrientationState {
+    angle: number;
+    type: string;
+}
+declare const useOrientation: (initialState?: OrientationState) => OrientationState;
+export default useOrientation;

package/types/hooks/useOverflowHidden.d.ts

@@ -0,0 +1,5 @@
+interface Option {
+    hidden: boolean;
+}
+export default function useOverflowHidden(getContainer: () => HTMLElement, { hidden }: Option): (() => void)[];
+export {};

package/types/hooks/usePageLeave.d.ts

@@ -0,0 +1,2 @@
+declare const usePageLeave: (onPageLeave: any, args?: never[]) => void;
+export default usePageLeave;

package/types/hooks/usePermission.d.ts

@@ -0,0 +1,16 @@
+export type IState = PermissionState | '';
+interface IPushPermissionDescriptor extends PermissionDescriptor {
+    name: 'push';
+    userVisibleOnly?: boolean;
+}
+interface IMidiPermissionDescriptor extends PermissionDescriptor {
+    name: 'midi';
+    sysex?: boolean;
+}
+interface IDevicePermissionDescriptor extends PermissionDescriptor {
+    name: 'camera' | 'microphone' | 'speaker';
+    deviceId?: string;
+}
+export type IPermissionDescriptor = PermissionDescriptor | IPushPermissionDescriptor | IMidiPermissionDescriptor | IDevicePermissionDescriptor;
+declare const usePermission: (permissionDesc: IPermissionDescriptor) => IState;
+export default usePermission;

package/types/hooks/usePinchZoom.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from 'react';
+export type CacheRef = {
+    prevDiff: number;
+    evCache: Array<PointerEvent>;
+};
+export declare enum ZoomState {
+    'ZOOMING_IN' = "ZOOMING_IN",
+    'ZOOMING_OUT' = "ZOOMING_OUT"
+}
+export type ZoomStateType = ZoomState.ZOOMING_IN | ZoomState.ZOOMING_OUT;
+declare const usePinchZoom: (ref: RefObject<HTMLElement>) => {
+    zoomingState: ZoomStateType;
+    pinchState: number;
+} | {
+    zoomingState: null;
+    pinchState: number;
+};
+export default usePinchZoom;

package/types/hooks/usePrevious.d.ts

@@ -0,0 +1,2 @@
+import { ComponentState, PropsWithoutRef } from 'react';
+export default function usePrevious<T>(value: PropsWithoutRef<T> | ComponentState): undefined;

package/types/hooks/usePreviousDistinct.d.ts

@@ -0,0 +1,2 @@
+export type Predicate<T> = (prev: T | undefined, next: T) => boolean;
+export default function usePreviousDistinct<T>(value: T, compare?: Predicate<T>): T | undefined;

package/types/hooks/usePromise.d.ts

@@ -0,0 +1,3 @@
+export type UsePromise = () => <T>(promise: Promise<T>) => Promise<T>;
+declare const usePromise: UsePromise;
+export default usePromise;

package/types/hooks/useQueue.d.ts

@@ -0,0 +1,9 @@
+export interface QueueMethods<T> {
+    add: (item: T) => void;
+    remove: () => T;
+    first: T;
+    last: T;
+    size: number;
+}
+declare const useQueue: <T>(initialValue?: T[]) => QueueMethods<T>;
+export default useQueue;

package/types/hooks/useRaf.d.ts

@@ -0,0 +1,2 @@
+declare const useRaf: (ms?: number, delay?: number) => number;
+export default useRaf;

package/types/hooks/useRafLoop.d.ts

@@ -0,0 +1,2 @@
+export type RafLoopReturns = [() => void, () => void, () => boolean];
+export default function useRafLoop(callback: FrameRequestCallback, initiallyActive?: boolean): RafLoopReturns;

package/types/hooks/useRafState.d.ts

@@ -0,0 +1,3 @@
+import { Dispatch, SetStateAction } from 'react';
+declare const useRafState: <S>(initialState: S | (() => S)) => [S, Dispatch<SetStateAction<S>>];
+export default useRafState;

package/types/hooks/useReactive.d.ts

@@ -0,0 +1,2 @@
+declare const useReactive: (initialState: any) => undefined;
+export default useReactive;

package/types/hooks/useRefs.d.ts

@@ -0,0 +1 @@
+export default function useRefs<T>(defaultValue?: T[]): [T[], (node: T, index?: number) => void];

package/types/hooks/useRendersCount.d.ts

@@ -0,0 +1 @@
+export default function useRendersCount(): number;

package/types/hooks/useScroll.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from 'react';
+export interface State {
+    x: number;
+    y: number;
+}
+declare const useScroll: (ref: RefObject<HTMLElement>) => State;
+export default useScroll;

package/types/hooks/useScrolling.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from 'react';
+declare const useScrolling: (ref: RefObject<HTMLElement>) => boolean;
+export default useScrolling;

package/types/hooks/useSearchParam.d.ts

@@ -0,0 +1,3 @@
+export type UseQueryParam = (param: string) => string | null;
+declare const _default: UseQueryParam;
+export default _default;

package/types/hooks/useSessionStorage.d.ts

@@ -0,0 +1,2 @@
+declare const useSessionStorage: <T>(key: string, initialValue?: T, raw?: boolean) => [T, (value: T) => void];
+export default useSessionStorage;

package/types/hooks/useSet.d.ts

@@ -0,0 +1,11 @@
+export interface StableActions<K> {
+    add: (key: K) => void;
+    remove: (key: K) => void;
+    toggle: (key: K) => void;
+    reset: () => void;
+}
+export interface Actions<K> extends StableActions<K> {
+    has: (key: K) => boolean;
+}
+declare const useSet: <K>(initialSet?: Set<K>) => [Set<K>, Actions<K>];
+export default useSet;

package/types/hooks/useSetState.d.ts

@@ -0,0 +1,2 @@
+declare const useSetState: <T extends object>(initialState?: T) => [T, (patch: Partial<T> | ((prevState: T) => Partial<T>)) => void];
+export default useSetState;

package/types/hooks/useSize.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export type Element = ((state: State) => React.ReactElement<any>) | React.ReactElement<any>;
+export interface State {
+    width: number;
+    height: number;
+}
+declare const useSize: (element: Element, { width, height }?: Partial<State>) => [React.ReactElement<any>, State];
+export default useSize;

package/types/hooks/useSlider.d.ts

@@ -0,0 +1,15 @@
+import { CSSProperties, RefObject } from 'react';
+export interface State {
+    isSliding: boolean;
+    value: number;
+}
+export interface Options {
+    onScrub: (value: number) => void;
+    onScrubStart: () => void;
+    onScrubStop: (value: number) => void;
+    reverse: boolean;
+    styles: boolean | CSSProperties;
+    vertical?: boolean;
+}
+declare const useSlider: (ref: RefObject<HTMLElement>, options?: Partial<Options>) => State;
+export default useSlider;

package/types/hooks/useSpeech.d.ts

@@ -0,0 +1,16 @@
+type SpeechOptions = {
+    lang: string;
+    voice?: SpeechSynthesisVoice;
+    rate: number;
+    pitch: number;
+    volume: number;
+};
+export type ISpeechOptions = Partial<SpeechOptions>;
+export type VoiceInfo = Pick<SpeechSynthesisVoice, 'lang' | 'name'>;
+export type ISpeechState = SpeechOptions & {
+    isPlaying: boolean;
+    status: string;
+    voiceInfo: VoiceInfo;
+};
+declare const useSpeech: (text: string, options: ISpeechOptions) => ISpeechState;
+export default useSpeech;

package/types/hooks/useStartTyping.d.ts

@@ -0,0 +1,2 @@
+declare const useStartTyping: (onStartTyping: (event: KeyboardEvent) => void) => void;
+export default useStartTyping;

package/types/hooks/useStateCallback.d.ts

@@ -0,0 +1,5 @@
+import { SetStateAction } from 'react';
+type Callback<T> = (value?: T) => void;
+type DispatchWithCallback<T> = (value: T, callback?: Callback<T>) => void;
+declare function useStateCallback<T>(initialState: T | (() => T)): [T, DispatchWithCallback<SetStateAction<T>>];
+export default useStateCallback;

package/types/hooks/useStateList.d.ts

@@ -0,0 +1,9 @@
+export interface UseStateListReturn<T> {
+    state: T;
+    currentIndex: number;
+    setStateAt: (newIndex: number) => void;
+    setState: (state: T) => void;
+    next: () => void;
+    prev: () => void;
+}
+export default function useStateList<T>(stateSet?: T[]): UseStateListReturn<T>;

package/types/hooks/useStateValidator.d.ts

@@ -0,0 +1,8 @@
+import { Dispatch, SetStateAction } from 'react';
+export type ValidityState = [boolean | undefined, ...any[]] | [undefined];
+export interface StateValidator<V, S> {
+    (state: S): V;
+    (state: S, dispatch: Dispatch<SetStateAction<V>>): void;
+}
+export type UseStateValidatorReturn<V> = [V, () => void];
+export default function useStateValidator<V extends ValidityState, S>(state: S, validator: StateValidator<V, S>, initialState?: V): UseStateValidatorReturn<V>;

package/types/hooks/useStateWithHistory.d.ts

@@ -0,0 +1,18 @@
+import { Dispatch } from 'react';
+import { IHookStateInitAction, IHookStateSetAction } from './misc/hookState';
+interface HistoryState<S> {
+    history: S[];
+    position: number;
+    capacity: number;
+    back: (amount?: number) => void;
+    forward: (amount?: number) => void;
+    go: (position: number) => void;
+}
+export type UseStateHistoryReturn<S> = [
+    S,
+    Dispatch<IHookStateSetAction<S>>,
+    HistoryState<S>
+];
+export declare function useStateWithHistory<S, I extends S>(initialState: IHookStateInitAction<S>, capacity?: number, initialHistory?: I[]): UseStateHistoryReturn<S>;
+export declare function useStateWithHistory<S = undefined>(): UseStateHistoryReturn<S | undefined>;
+export default useStateWithHistory;

package/types/hooks/useStateWithPromise.d.ts

@@ -0,0 +1,2 @@
+declare function useStateWithPromise<T>(defaultVal: T): [T, (updater: any) => Promise<T>];
+export default useStateWithPromise;

package/types/hooks/useSyncState.d.ts

@@ -0,0 +1,3 @@
+type UseSyncStateProps<T> = readonly [() => T, (newValue: T) => void];
+export default function useSyncState<T>(initialValue: T): UseSyncStateProps<T>;
+export {};

package/types/hooks/useThrottle.d.ts

@@ -0,0 +1,2 @@
+declare const useThrottle: <T>(value: T, ms?: number) => T;
+export default useThrottle;

package/types/hooks/useThrottleFn.d.ts

@@ -0,0 +1,2 @@
+declare const useThrottleFn: <T, U extends any[]>(fn: (...args: U) => T, ms: number | undefined, args: U) => T | null;
+export default useThrottleFn;

package/types/hooks/useTimeout.d.ts

@@ -0,0 +1,2 @@
+export default useTimeout;
+declare function useTimeout(fn: any, delay: any): void;

package/types/hooks/useTimeoutFn.d.ts

@@ -0,0 +1,2 @@
+export type UseTimeoutFnReturn = [() => boolean | null, () => void, () => void];
+export default function useTimeoutFn(fn: Function, ms?: number): UseTimeoutFnReturn;

package/types/hooks/useTitle.d.ts

@@ -0,0 +1,6 @@
+export interface UseTitleOptions {
+    restoreOnUnmount?: boolean;
+}
+declare function useTitle(title: string, options?: UseTitleOptions): void;
+declare const _default: typeof useTitle;
+export default _default;

package/types/hooks/useToggle.d.ts

@@ -0,0 +1,2 @@
+declare const useToggle: (initialValue: boolean) => [boolean, (nextValue?: any) => void];
+export default useToggle;

package/types/hooks/useTween.d.ts

@@ -0,0 +1,3 @@
+export type Easing = (t: number) => number;
+declare const useTween: (easingName?: string, ms?: number, delay?: number) => number;
+export default useTween;

package/types/hooks/useUnmount.d.ts

@@ -0,0 +1,2 @@
+declare const useUnmount: (fn: () => any) => void;
+export default useUnmount;

package/types/hooks/useUnmountPromise.d.ts

@@ -0,0 +1,3 @@
+export type Race = <P extends Promise<any>, E = any>(promise: P, onError?: (error: E) => void) => P;
+declare const useUnmountPromise: () => Race;
+export default useUnmountPromise;

package/types/hooks/useUpdate.d.ts

@@ -0,0 +1,2 @@
+import { DependencyList } from 'react';
+export default function useUpdate(fn: () => void, deps?: DependencyList): void;

package/types/hooks/useUpdateEffect.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const useUpdateEffect: typeof useEffect;
+export default useUpdateEffect;

package/types/hooks/useUpdateTimeout.d.ts

@@ -0,0 +1,2 @@
+export type UseTimeoutReturn = [() => boolean | null, () => void, () => void];
+export default function useTimeout(ms?: number): UseTimeoutReturn;

package/types/hooks/useUpsert.d.ts

@@ -0,0 +1,6 @@
+import { ListActions } from './useList';
+import { IHookStateInitAction } from './misc/hookState';
+export interface UpsertListActions<T> extends Omit<ListActions<T>, 'upsert'> {
+    upsert: (newItem: T) => void;
+}
+export default function useUpsert<T>(predicate: (a: T, b: T) => boolean, initialList?: IHookStateInitAction<T[]>): [T[], UpsertListActions<T>];

package/types/hooks/useVibrate.d.ts

@@ -0,0 +1,4 @@
+export type VibrationPattern = number | number[];
+declare function useVibrate(enabled?: boolean, pattern?: VibrationPattern, loop?: boolean): void;
+declare const _default: typeof useVibrate;
+export default _default;

package/types/hooks/useVideo.d.ts

@@ -0,0 +1,11 @@
+declare const useVideo: (elOrProps: import("./factory/createHTMLMediaHook").HTMLMediaProps | import("react").ReactElement<import("./factory/createHTMLMediaHook").HTMLMediaProps, string | import("react").JSXElementConstructor<any>>) => readonly [import("react").ReactElement<import("./factory/createHTMLMediaHook").HTMLMediaProps & {
+    ref?: import("react").MutableRefObject<HTMLVideoElement | null> | undefined;
+}, string | import("react").JSXElementConstructor<any>>, import("./factory/createHTMLMediaHook").HTMLMediaState, {
+    play: () => Promise<void> | undefined;
+    pause: () => void;
+    seek: (time: number) => void;
+    volume: (volume: number) => void;
+    mute: () => void;
+    unmute: () => void;
+}, import("react").MutableRefObject<HTMLVideoElement | null>];
+export default useVideo;

package/types/hooks/useWatch.d.ts

@@ -0,0 +1,2 @@
+import { ComponentState, PropsWithoutRef } from 'react';
+export default function useWatch<T>(value: PropsWithoutRef<T> | ComponentState, callback: (value: any, prevValue: any) => void): void;

package/types/hooks/useWindowScroll.d.ts

@@ -0,0 +1,6 @@
+export interface State {
+    x: number;
+    y: number;
+}
+declare const useWindowScroll: () => State;
+export default useWindowScroll;

package/types/hooks/useWindowSize.d.ts

@@ -0,0 +1,5 @@
+declare const useWindowSize: (initialWidth?: number, initialHeight?: number) => {
+    width: number;
+    height: number;
+};
+export default useWindowSize;

package/types/icon/addFromIconFontCn.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { IconProps } from '.';
+export interface IconfontOptions {
+    src?: string;
+    extraProps?: {
+        [key: string]: any;
+    };
+}
+export default function addFromIconFontCn(options?: IconfontOptions): React.FC<IconProps & React.RefAttributes<unknown>>;

package/types/icon/index.d.ts

@@ -0,0 +1,18 @@
+import './style';
+import React, { CSSProperties, SVGAttributes } from 'react';
+export interface IconProps extends Omit<SVGAttributes<SVGElement>, 'className'> {
+    style?: CSSProperties;
+    type?: string;
+    spin?: boolean;
+    className?: string | string[];
+}
+export interface CustomIconComponentProps {
+    style?: CSSProperties;
+    className?: string;
+    width?: string | number;
+    height?: string | number;
+    fill?: string;
+    viewBox?: string;
+}
+declare const Icon: React.ForwardRefExoticComponent<IconProps & React.RefAttributes<unknown>>;
+export default Icon;

package/types/icon-hover/index.d.ts

@@ -0,0 +1,11 @@
+import './style';
+import React, { PropsWithChildren } from 'react';
+interface HoverProps extends React.HTMLAttributes<HTMLSpanElement> {
+    size?: 'small' | 'mini' | 'default' | 'large';
+    className?: string;
+    prefix?: string;
+    disabled?: boolean;
+    onClick?: (e: any) => void;
+}
+export default function IconHover(props: PropsWithChildren<HoverProps>): import("react/jsx-dev-runtime").JSX.Element;
+export {};

package/types/icon-hover/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/image/Image.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import ImagePreview from './ImagePreview';
+import ImagePreviewGroup from './ImagePreviewGroup';
+import type { ImageProps } from './interface';
+declare const ImageComponent: React.ForwardRefExoticComponent<ImageProps & {
+    _index?: number | undefined;
+} & React.RefAttributes<HTMLDivElement>> & {
+    Preview: typeof ImagePreview;
+    PreviewGroup: typeof ImagePreviewGroup;
+};
+export default ImageComponent;

package/types/image/ImageFooter.d.ts

@@ -0,0 +1,13 @@
+import { CSSProperties } from 'react';
+import type { ImageProps } from './interface';
+interface ImageFooterProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    title?: ImageProps['title'];
+    description?: ImageProps['description'];
+    actions?: ImageProps['actions'];
+    prefixCls: string | undefined;
+    simple?: boolean;
+}
+export declare const ImageFooter: (props: ImageFooterProps) => import("react/jsx-dev-runtime").JSX.Element | null;
+export {};

package/types/image/ImagePreview.d.ts

@@ -0,0 +1,6 @@
+import type { ImagePreviewProps } from './interface';
+export type ImagePreviewHandle = {
+    reset: () => void;
+};
+declare const PreviewComponent: import("react").ForwardRefExoticComponent<ImagePreviewProps & import("react").RefAttributes<ImagePreviewHandle>>;
+export default PreviewComponent;

package/types/image/ImagePreviewArrow.d.ts

@@ -0,0 +1,9 @@
+interface ImagePreviewArrowProps {
+    current: number;
+    previewCount: number;
+    infinite?: boolean;
+    onPrev?: () => void;
+    onNext?: () => void;
+}
+declare function ImagePreviewArrow(props: ImagePreviewArrowProps): import("react/jsx-dev-runtime").JSX.Element;
+export default ImagePreviewArrow;

package/types/image/ImagePreviewGroup.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { ImagePreviewGroupProps } from './interface';
+export type { ImagePreviewGroupProps };
+export interface ImagePreviewGroupHandle {
+    reset: () => void;
+}
+declare const PreviewGroupComponent: React.ForwardRefExoticComponent<ImagePreviewGroupProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<ImagePreviewGroupHandle>>;
+export default PreviewGroupComponent;

package/types/image/ImagePreviewToolbar.d.ts

@@ -0,0 +1,14 @@
+import { CSSProperties } from 'react';
+import type { ImagePreviewActionProps } from './interface';
+interface ImagePreviewToolbarProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    prefixCls: string | undefined;
+    previewPrefixCls: string;
+    simple: boolean;
+    actions: ImagePreviewActionProps[];
+    actionsLayout: string[];
+    defaultActions: ImagePreviewActionProps[];
+}
+declare const _default: import("react").ForwardRefExoticComponent<ImagePreviewToolbarProps & import("react").RefAttributes<unknown>>;
+export default _default;

package/types/image/TriggerForToolbar.d.ts

@@ -0,0 +1,10 @@
+import { CSSProperties, PropsWithChildren } from 'react';
+import { TriggerProps } from '../trigger';
+interface TriggerForToolbarProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    prefixCls: string | undefined;
+    popup: TriggerProps['popup'];
+}
+export declare const TriggerForToolbar: (props: PropsWithChildren<TriggerForToolbarProps>) => import("react/jsx-dev-runtime").JSX.Element;
+export {};

package/types/image/index.d.ts

@@ -0,0 +1,4 @@
+import './style';
+import Image from './Image';
+export default Image;
+export type { ImagePreviewActionProps, ImagePreviewGroupProps, ImagePreviewProps, ImageProps, } from './interface';