@glodon-aiot/react-components 0.0.0-20251106104234

package/dist/src/Button/index.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface ButtonProps {
+    primary?: boolean;
+    backgroundColor?: string;
+    size?: 'small' | 'medium' | 'large';
+    label: string;
+    onClick?: () => void;
+}
+declare const Button: React.FC<ButtonProps>;
+export { Button };

package/dist/src/ConfirmableButton/index.d.ts

@@ -0,0 +1,16 @@
+import { default as React, FC, ReactNode } from 'react';
+import { ButtonType } from 'antd/es/button';
+export interface ButtonConfirm {
+    text: string;
+}
+export interface ConfirmableButtonProps {
+    name: string;
+    children?: ReactNode;
+    confirm?: boolean | ButtonConfirm;
+    type?: ButtonType;
+    style?: React.CSSProperties;
+    className?: string;
+    onConfirm?: (e?: React.MouseEvent<HTMLElement, MouseEvent> | undefined) => void;
+}
+declare const ConfirmableButton: FC<ConfirmableButtonProps>;
+export default ConfirmableButton;

package/dist/src/Drawable/Drawable.d.ts

@@ -0,0 +1,32 @@
+import { ReactNode } from 'react';
+import { Line, Marker, Point, Polygon } from '.';
+export type DrawableState = 'viewOnly' | 'drawingLine' | 'addingMarker' | 'drawingPolygon';
+export interface DrawOptions {
+    lineColor?: string;
+    areaColor?: string;
+    lineWidth?: number | string;
+    lineDashArray?: string;
+    polygon?: {
+        showVertexIndex?: boolean;
+        vertexBgColor?: string;
+        vertexTextColor?: string;
+    };
+}
+export interface DrawableProps<MARKER extends Marker> {
+    drawOptions?: DrawOptions;
+    width?: number;
+    height?: number;
+    state: DrawableState;
+    scale: number;
+    lines?: Line[];
+    polygons?: Polygon[];
+    markers?: MARKER[];
+    markRenderer?(marker: MARKER): ReactNode;
+    onAddLine?(start: Point, end: Point): void;
+    onAddMarker?(at: Point): void;
+    onAddPolygon?(points: Point[]): void;
+    onStateChange?(state: DrawableState): void;
+}
+export interface State {
+}
+export default function Drawable<MARKER extends Marker>(props: DrawableProps<MARKER>): import("react/jsx-runtime").JSX.Element;

package/dist/src/Drawable/LineElement.d.ts

@@ -0,0 +1,8 @@
+import { Point } from '.';
+export interface LineElementProps {
+    start: Point;
+    end: Point;
+}
+export interface State {
+}
+export default function LineElement(props: LineElementProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/Drawable/MarkerElement.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { Marker, Point } from '.';
+export interface MarkerElementProps<M extends Marker> {
+    marker: M;
+    onPointChange?(point: Point): void;
+    markRenderer?(marker: Marker): ReactNode;
+}
+export interface State {
+}
+export default function MarkerElement<M extends Marker>(props: MarkerElementProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/src/Drawable/MarkersMap.d.ts

@@ -0,0 +1,7 @@
+import { Marker } from '.';
+export interface MarkersMapProps {
+    markers?: Marker[];
+}
+export interface State {
+}
+export default function MarkersMap(props: MarkersMapProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/Drawable/PolygonElement.d.ts

@@ -0,0 +1,10 @@
+import { Point, PolygonOptions } from '.';
+export interface PolygonElementProps {
+    points: Point[];
+    options?: PolygonOptions;
+    editing: boolean;
+    onClose?(index: number): void;
+}
+export interface State {
+}
+export default function PolygonElement(props: PolygonElementProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/Drawable/index.d.ts

@@ -0,0 +1,33 @@
+import { DrawOptions } from './Drawable';
+export { default as default } from './Drawable';
+export type Identifier = string | number;
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Marker {
+    id: Identifier;
+    point: Point;
+}
+export interface Line {
+    id: Identifier;
+    start: Point;
+    end: Point;
+}
+export interface Polygon {
+    id: Identifier;
+    points: Point[];
+    autoClose?: boolean;
+    options?: PolygonOptions;
+}
+export interface PolygonOptions {
+    hideBorder?: boolean;
+    hideBackground?: boolean;
+    borderColor?: string;
+    backgroundColor?: string;
+}
+export declare function calAngle(p1: Point, p2: Point, p3?: Point): number;
+export interface IDrawableContext {
+    options: DrawOptions;
+}
+export declare const DrawableContext: import('react').Context<IDrawableContext>;

package/dist/src/Drawable/state.d.ts

@@ -0,0 +1,49 @@
+import { Point } from '.';
+export interface DrawableContext {
+    markerPoint?: Point;
+    polygonPoints?: Point[];
+    lineStart?: Point;
+    lineEnd?: Point;
+    movingPoint?: Point;
+}
+export type DrawableEvent = {
+    type: 'START_ADD_MARKER';
+} | {
+    type: 'START_DRAW_LINE';
+} | {
+    type: 'START_DRAW_POLYGON';
+} | {
+    type: 'ADD_MARKER';
+    point: Point;
+} | {
+    type: 'ADD_LINE_START';
+    point: Point;
+} | {
+    type: 'ADD_LINE_END';
+    point: Point;
+} | {
+    type: 'DRAW_LINE_COMPLETED';
+} | {
+    type: 'DRAW_POLYGON';
+    start: Point;
+} | {
+    type: 'ADD_POLYGON_POINT';
+    point: Point;
+} | {
+    type: 'DRAW_POLYGON_COMPLETE';
+} | {
+    type: 'MOUSE_MOVE';
+    point: Point;
+} | {
+    type: 'RESET';
+} | {
+    type: 'CANCEL';
+};
+type SimpleState<T> = {
+    value: T;
+    context: DrawableContext;
+};
+type S<T> = SimpleState<T>;
+export type DrawableState = S<'idle'> | S<'addingMarker'> | S<'drawingLine'> | S<'drawingPolygon'> | S<'drawCompleted'> | S<'canceled'>;
+export declare const drawableMachine: import('xstate').StateMachine<DrawableContext, any, DrawableEvent, DrawableState, import('xstate').BaseActionObject, import('xstate').ServiceMap, import('xstate').ResolveTypegenMeta<import('xstate').TypegenDisabled, DrawableEvent, import('xstate').BaseActionObject, import('xstate').ServiceMap>>;
+export {};

package/dist/src/ExpandablePannel/index.d.ts

@@ -0,0 +1,24 @@
+import { CSSProperties, FC, ReactElement } from 'react';
+export type PannelMode = 'max' | 'normal' | 'min';
+interface ExpandablePannelProps {
+    visible?: boolean;
+    style?: CSSProperties;
+    className?: string;
+    headerClassName?: string;
+    mode?: PannelMode;
+    children?: React.ReactNode;
+    icons?: {
+        collapseButton: ReactElement;
+        expandButton: ReactElement;
+        fullscreenButton: ReactElement;
+        exitFullscreenButton: ReactElement;
+    };
+    extraButtons?: ReactElement[];
+    header?: ReactElement;
+    fullScreenContainer?: HTMLElement;
+    onNormalize?: () => void;
+    onMinimize?: () => void;
+    onMaximize?: () => void;
+}
+declare const ExpandablePannel: FC<ExpandablePannelProps>;
+export { ExpandablePannel };

package/dist/src/GOSImageMap/DrawableImageMap.d.ts

@@ -0,0 +1,8 @@
+import { Marker } from '../Drawable';
+import { DrawableProps } from '../Drawable/Drawable';
+export interface DrawableImageMapProps<MARKER extends Marker> extends DrawableProps<MARKER> {
+    url?: string;
+}
+export interface State {
+}
+export default function DrawableImageMap<MARKER extends Marker>(props: DrawableImageMapProps<MARKER>): import("react/jsx-runtime").JSX.Element;

package/dist/src/GOSImageMap/ImageMap.d.ts

@@ -0,0 +1,8 @@
+export interface ImageMapProps {
+    url: string;
+    onScaleChange(scale: number, width: number, height: number): void;
+    onLoad?(img: HTMLImageElement): void;
+}
+export interface State {
+}
+export default function ImageMap(props: ImageMapProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/GOSImageMap/index.d.ts

@@ -0,0 +1,2 @@
+export { default as default } from './ImageMap';
+export { default as DrawableImageMap } from './DrawableImageMap';

package/dist/src/IconButton/index.d.ts

@@ -0,0 +1,5 @@
+import { ButtonHTMLAttributes, FC } from 'react';
+interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+}
+declare const IconButton: FC<IconButtonProps>;
+export { IconButton };

package/dist/src/Iconfont/CloudIconfont.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('react').FC<import('@ant-design/icons/lib/components/IconFont').IconFontProps<string>>;
+export default _default;

package/dist/src/Iconfont/EdgeIconfont.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('react').FC<import('@ant-design/icons/lib/components/IconFont').IconFontProps<string>>;
+export default _default;

package/dist/src/Iconfont/index.d.ts

@@ -0,0 +1,2 @@
+declare const Iconfont: import('react').FC<import('@ant-design/icons/lib/components/IconFont').IconFontProps<string>>;
+export { Iconfont };

package/dist/src/ImageMap/index.d.ts

@@ -0,0 +1,40 @@
+import { default as React, CSSProperties } from 'react';
+import { ITrackPoint } from '..';
+import { TrackMapActions, Transform } from '../TrackMap';
+interface ImageMapProps {
+    url: string;
+    points?: ITrackPoint[];
+    pointSize?: number;
+    direction?: number;
+    activePointId?: string;
+    lineStyle?: CSSProperties;
+    pointStyle?: CSSProperties;
+    directionStyle?: CSSProperties;
+    transform?: Transform;
+    trackEditable?: boolean;
+    trackEditing?: boolean;
+    keepRatio?: boolean;
+    actions?: TrackMapActions;
+    onTrackEditingChange?: (editing: boolean) => void;
+    onPointClick?: (val: ITrackPoint) => void;
+    passes?: any;
+    activePassId?: number;
+    passStyle?: CSSProperties;
+    activePassStyle?: CSSProperties;
+    marks?: any;
+    draggable?: boolean;
+    zoomable?: boolean;
+    zoomStep?: number;
+    offsetEdge?: number[];
+    zoomMax?: number;
+    zoomMin?: number;
+    onImageLoad?: (img: HTMLImageElement) => void;
+    onTransform?: (transform: Transform, pointsEl?: SVGCircleElement[], canvas?: SVGSVGElement) => void;
+    onPointsChange?: (points: ITrackPoint[]) => void;
+}
+export interface ImageMapRefProps {
+    zoomIn: (zoom?: number) => void;
+    zoomOut: (zoom?: number) => void;
+}
+declare const ImageMap: React.ForwardRefExoticComponent<ImageMapProps & React.RefAttributes<ImageMapRefProps>>;
+export { ImageMap };

package/dist/src/MouseTip/constant.d.ts

@@ -0,0 +1,6 @@
+export declare const GAP_SIZE_H = 16;
+export declare const GAP_SIZE_V = 16;
+export declare const ON_LEFT = -1;
+export declare const ON_RIGHT = 1;
+export declare const ON_TOP = -1;
+export declare const ON_BOTTOM = 1;

package/dist/src/MouseTip/index.d.ts

@@ -0,0 +1,17 @@
+import { default as React, FC, CSSProperties } from 'react';
+import { Placement } from './types';
+interface MouseTipProps {
+    className?: string;
+    style?: CSSProperties;
+    visible?: boolean;
+    children?: React.ReactNode;
+    defaultPosition?: {
+        x: number;
+        y: number;
+    };
+    forElement?: HTMLElement | null;
+    placement?: Placement;
+    curserPosition?: [number, number];
+}
+declare const MouseTip: FC<MouseTipProps>;
+export { MouseTip };

package/dist/src/MouseTip/types.d.ts

@@ -0,0 +1,8 @@
+export type HorizontalPlacement = 'left' | 'center' | 'right';
+export type VerticalPlacement = 'top' | 'middle' | 'bottom';
+export type SinglePlacemnet = HorizontalPlacement | VerticalPlacement;
+export type Placement = 'left-top' | 'right-top' | 'left-bottom' | 'right-bottom' | 'top' | 'bottom' | 'left' | 'right';
+export interface PlacementParams {
+    className: string;
+    margin: [number, number];
+}

package/dist/src/MouseTip/utils.d.ts

@@ -0,0 +1,8 @@
+import { HorizontalPlacement, VerticalPlacement } from './types';
+export declare const getOffsetX: (e: any) => any;
+export declare const getOffsetY: (e: any) => any;
+export declare const placementStringToArr: (Placement: any) => [HorizontalPlacement, VerticalPlacement];
+export declare const getPlacementPosition: (placement: [HorizontalPlacement, VerticalPlacement], contentRect?: DOMRect, gap?: [number, number]) => {
+    x: number;
+    y: number;
+};

package/dist/src/PanoramaRecordPlayer/index.d.ts

@@ -0,0 +1,14 @@
+import { CSSProperties, FC } from 'react';
+interface PanoramaRecordPlayerProps {
+    className?: string;
+    style?: CSSProperties;
+    length?: number;
+    current?: number;
+    speed?: number;
+    play?: boolean;
+    loop?: boolean;
+    loading?: boolean;
+    onChange: (index: number) => void;
+}
+declare const PanoramaRecordPlayer: FC<PanoramaRecordPlayerProps>;
+export { PanoramaRecordPlayer };

package/dist/src/PassMap/index.d.ts

@@ -0,0 +1,11 @@
+import { default as React, CSSProperties } from 'react';
+interface PassMapProps {
+    passes?: any;
+    style?: CSSProperties;
+    scale: number;
+    activePassId?: number;
+    passStyle?: CSSProperties;
+    activePassStyle?: CSSProperties;
+}
+declare const PassMap: React.FC<PassMapProps>;
+export { PassMap };

package/dist/src/TrackMap/PointTooltip.d.ts

@@ -0,0 +1,9 @@
+import { FC, Key } from 'react';
+import { AbstractTooltipProps } from 'antd/es/tooltip';
+import { ITrackPoint } from '.';
+export interface PointTooltipProps extends AbstractTooltipProps {
+    point: ITrackPoint;
+    key?: Key;
+}
+declare const PointTooltip: FC<PointTooltipProps>;
+export default PointTooltip;

package/dist/src/TrackMap/TrackPoint.d.ts

@@ -0,0 +1,19 @@
+import { CSSProperties, FC, Key } from 'react';
+import { ITrackPoint } from '.';
+interface TrackPointProps {
+    point: ITrackPoint;
+    open?: boolean;
+    key?: Key;
+    id?: Key;
+    x: number;
+    y: number;
+    r: number;
+    style?: CSSProperties & any;
+    scale?: number;
+    active?: boolean;
+    hidden?: boolean;
+    onPointClick?: (val: ITrackPoint) => void;
+    getTooltipContainer?: (node: HTMLElement) => HTMLElement;
+}
+declare const TrackPoint: FC<TrackPointProps>;
+export default TrackPoint;

package/dist/src/TrackMap/index.d.ts

@@ -0,0 +1,82 @@
+import { default as React, CSSProperties, ReactElement } from 'react';
+export interface Position {
+    id: number | string;
+    x: number;
+    y: number;
+}
+export type OrderedPosition = Position & {
+    order: number;
+};
+export interface Transform {
+    translate?: number[];
+    rotate?: number;
+    scale?: number[];
+}
+export interface ITrackPoint {
+    id: string | number;
+    x: number;
+    y: number;
+    order: number;
+    lineStyle?: CSSProperties & any;
+    pointStyle?: CSSProperties & any;
+    tooltipStyle?: CSSProperties;
+    tooltipOpen?: boolean;
+    tooltipRender?: (item: Position) => HTMLElement | string | number;
+}
+export interface TrackEditButtonConfirm {
+    text: string;
+}
+export interface TrackEditButton {
+    text?: string;
+    style?: CSSProperties;
+    className?: string;
+    children?: React.ReactNode;
+}
+export interface TrackEditConfirmableButton extends TrackEditButton {
+    confirm?: boolean | TrackEditButtonConfirm;
+}
+export interface TrackEditButtons {
+    editButton?: TrackEditButton & {
+        exitTitleText?: string;
+        titleText?: string;
+    };
+    okButton?: TrackEditConfirmableButton;
+    cancelButton?: TrackEditConfirmableButton;
+}
+export type TrackMapActions = boolean | TrackEditButtons;
+interface TrackMapProps {
+    width: number;
+    height: number;
+    points: ITrackPoint[];
+    scale: number;
+    pointSize?: number;
+    direction?: number;
+    activePointId?: string;
+    style?: CSSProperties;
+    lineStyle?: CSSProperties & any;
+    pointStyle?: CSSProperties & any;
+    directionStyle?: CSSProperties;
+    marks?: ITrackMapMark[];
+    movable?: boolean;
+    resizable?: boolean;
+    transform?: Transform;
+    keepRatio?: boolean;
+    actions?: TrackMapActions;
+    onPointClick?: (val: ITrackPoint) => void;
+    onTransform?: (transform: Transform, pointsEl?: SVGCircleElement[], canvas?: SVGSVGElement) => void;
+    onPointsChange?: (points: ITrackPoint[]) => void;
+    onCancelResize?: VoidFunction;
+    setIsSaved?: (val: boolean) => void;
+    isSaved?: boolean;
+}
+export interface Point {
+    id: string | number;
+    x: number;
+    y: number;
+}
+export interface ITrackMapMark extends Point {
+    renderData: any;
+    render: (renderData: any, markData: Point) => ReactElement;
+}
+declare const TrackMap: React.FC<TrackMapProps>;
+export { TrackMap };

package/dist/src/Zoom/index.d.ts

@@ -0,0 +1,13 @@
+import { CSSProperties, FC } from 'react';
+interface ZoomProps {
+    className?: string;
+    style?: CSSProperties;
+    value?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    onChange: (value: number) => void;
+    showText?: boolean;
+}
+declare const Zoom: FC<ZoomProps>;
+export { Zoom };

package/dist/src/components/Copy/index.d.ts

@@ -0,0 +1,5 @@
+interface CopyProps {
+    text: string;
+}
+declare const Copy: ({ text }: CopyProps) => import("react/jsx-runtime").JSX.Element;
+export { Copy };

package/dist/src/components/Markdown/ATag/index.d.ts

@@ -0,0 +1,2 @@
+declare const ATag: (props: any) => import("react/jsx-runtime").JSX.Element;
+export default ATag;

package/dist/src/components/Markdown/Code/index.d.ts

@@ -0,0 +1,2 @@
+declare const MarkdownCode: ({ node, inline, className, children, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+export default MarkdownCode;

package/dist/src/components/Markdown/Image/index.d.ts

@@ -0,0 +1,2 @@
+declare const MarkdownImage: (props: React.ImgHTMLAttributes<HTMLImageElement>) => import("react/jsx-runtime").JSX.Element;
+export default MarkdownImage;

package/dist/src/components/Markdown/Video/index.d.ts

@@ -0,0 +1,2 @@
+declare const MarkdownVideo: (props: React.VideoHTMLAttributes<HTMLVideoElement>) => import("react/jsx-runtime").JSX.Element;
+export default MarkdownVideo;

package/dist/src/components/Markdown/index.d.ts

@@ -0,0 +1,19 @@
+import { default as React, FC } from 'react';
+import { Components } from 'react-markdown';
+import { default as MarkdownImage } from './Image';
+import { default as MarkdownCode } from './Code';
+import { default as MarkdownATag } from './ATag';
+import { default as MarkdownVideo } from './Video';
+export interface MarkdownProps {
+    children: string;
+    showLatex?: boolean;
+    components?: Components;
+    componentProps?: {
+        a?: React.AnchorHTMLAttributes<HTMLAnchorElement>;
+        img?: React.ImgHTMLAttributes<HTMLImageElement>;
+        code?: React.HTMLAttributes<HTMLElement>;
+        video?: React.VideoHTMLAttributes<HTMLVideoElement>;
+    };
+}
+declare const Markdown: FC<MarkdownProps>;
+export { Markdown, MarkdownATag, MarkdownVideo, MarkdownImage, MarkdownCode };

package/dist/src/index.d.ts

@@ -0,0 +1,17 @@
+export { Button } from './Button';
+export { Markdown, MarkdownATag, MarkdownVideo, MarkdownImage, MarkdownCode } from './components/Markdown';
+export { Copy } from './components/Copy';
+export { ExpandablePannel } from './ExpandablePannel';
+export { IconButton } from './IconButton';
+export { Iconfont } from './Iconfont';
+export { ImageMap } from './ImageMap';
+export type { ImageMapRefProps } from './ImageMap';
+export { PanoramaRecordPlayer } from './PanoramaRecordPlayer';
+export { TrackMap } from './TrackMap';
+export type { ITrackPoint, TrackMapActions, TrackEditButtons, TrackEditConfirmableButton, TrackEditButton, } from './TrackMap';
+export { MouseTip } from './MouseTip';
+export { PassMap } from './PassMap';
+export { Zoom } from './Zoom';
+export { useBimface } from './useBimface';
+export * from './GOSImageMap';
+export * from './Drawable';

package/dist/src/useBimface/example.d.ts

@@ -0,0 +1,2 @@
+declare const BimfaceViewer: () => import("react/jsx-runtime").JSX.Element;
+export default BimfaceViewer;

package/dist/src/useBimface/index.d.ts

@@ -0,0 +1,65 @@
+import { default as React } from 'react';
+type LengthUnits = any;
+type OrbitButton = any;
+type BimfaceColor = any;
+interface Viewer3DConfig {
+    avatar?: any;
+    backgroundColor?: string[];
+    domElement?: HTMLElement;
+    enableConstraintZoom?: boolean;
+    enableCoordinateSystem?: number;
+    enableCSMShadow?: boolean;
+    enableExplosion?: boolean;
+    enableHover?: boolean;
+    enableIBLBackground?: boolean;
+    enableLogarithmicDepthBuffer?: boolean;
+    enableMouseMovePick?: boolean;
+    enableOrbit?: boolean;
+    enableRealisticMiniMap?: boolean;
+    enableReplaceMaterial?: boolean;
+    enableShortcutKey?: boolean;
+    enableSplitComponent?: boolean;
+    enableSSAO?: boolean;
+    enableToggleContextMenuDisplay?: boolean;
+    enableViewHouse?: boolean;
+    enableWireframe?: boolean;
+    exposure?: number;
+    globalUnit?: LengthUnits;
+    loadIBLScene?: object;
+    memoryThreshold?: number;
+    orbitButton?: OrbitButton;
+    renderMode?: string;
+    walkRotationSpeed?: number;
+    wireframeColor?: BimfaceColor;
+}
+export interface BimfaceFloor {
+    archElev: number;
+    areas: null;
+    elevation: number;
+    height: null;
+    id: string;
+    miniMap: string;
+    name: string;
+    rooms: null;
+    structElev: number;
+}
+export declare function useBimface(config?: Viewer3DConfig): {
+    BimfaceViewer: any;
+    BimfaceSection: any;
+    BimfaceMark: any;
+    BimfaceViewerEvents: any;
+    viewer: any;
+    viewerAdded: boolean;
+    sDKLoaded: boolean;
+    loadedModelCount: number;
+    loadModels: (viewTokens: string[]) => void;
+    setContainerDom: React.Dispatch<React.SetStateAction<HTMLDivElement>>;
+    getSnapshot: (type?: "image/png" | "image/jpeg" | "image/webp", quality?: number) => string;
+    setComponentsColorByCatgryId: (categoryColors: any) => void;
+    setAllComponentsColor: (colorString: string) => void;
+    navigationMapByHeight: (height: number, maxSize: {
+        width: number;
+        height: number;
+    }, cb: (img: HTMLImageElement) => void) => void;
+};
+export {};

package/dist/src/utils/JSAsyncLoader.d.ts

@@ -0,0 +1,2 @@
+declare function loadJsAsync(url: any, onload: any): void;
+export default loadJsAsync;

package/dist/src/utils/clipboard.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Interface CopyToClipboard params
+ */
+interface ICopyToClipboard {
+    /** HTML reference identifier ```<div id="foo"></div>```  */
+    target?: string;
+    /** String value */
+    value?: string;
+}
+export declare const copyToClipboard: ({ target, value }: ICopyToClipboard) => Promise<boolean>;
+export {};