@cloudtower/eagle 0.17.11

package/README.md

@@ -0,0 +1,26 @@
+## Usage
+
+```tsx
+import { antdKit } from "@cloudtower/eagle";
+import { KitStoreProvider, kitContext } from "@cloudtower/eagle";
+import { initParrotI18n } from "@cloudtower/eagle";
+
+import "@cloudtower/eagle/dist/style.css";
+
+initParrotI18n();
+
+ReactDOM.render(
+  <React.StrictMode>
+    <KitStoreProvider>
+      <kitContext.Provider value={antdKit}>
+        <App />
+      </kitContext.Provider>
+    </KitStoreProvider>
+  </React.StrictMode>,
+  document.getElementById("root") as HTMLElement
+);
+```
+
+## Debug
+
+## Contribute

package/dist/components/BaseIcon/index.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+export interface IBaseIconProps extends React.HTMLAttributes<HTMLSpanElement> {
+    className?: string;
+    alt?: string;
+    width?: number;
+    height?: number | "auto";
+    cursor?: "pointer" | string;
+    prefixNode?: React.ReactNode;
+    suffixIconSrc?: string;
+    src: string;
+}
+declare const BaseIcon: React.ForwardRefExoticComponent<IBaseIconProps & React.RefAttributes<HTMLSpanElement>>;
+export default BaseIcon;

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

@@ -0,0 +1,16 @@
+import React from "react";
+declare const Button: React.ForwardRefExoticComponent<{
+    prefixIcon?: JSX.Element | import("..").ImagesType | undefined;
+    hoverPrefixIcon?: JSX.Element | import("..").ImagesType | undefined;
+    suffixIcon?: JSX.Element | import("..").ImagesType | undefined;
+    hoverSuffixIcon?: JSX.Element | import("..").ImagesType | undefined;
+    type?: "link" | "text" | "ghost" | "default" | "primary" | "dashed" | "secondary" | "tertiary" | "ordinary" | "ordinary-onTint" | "quiet" | undefined;
+} & Omit<Partial<{
+    href: string;
+    target?: string | undefined;
+    onClick?: React.MouseEventHandler<HTMLElement> | undefined;
+} & import("antd/lib/button/button").BaseButtonProps & import("antd/lib/_util/type").Omit<React.AnchorHTMLAttributes<any>, "type" | "onClick"> & {
+    htmlType?: "button" | "reset" | "submit" | undefined;
+    onClick?: React.MouseEventHandler<HTMLElement> | undefined;
+} & import("antd/lib/_util/type").Omit<React.ButtonHTMLAttributes<any>, "type" | "onClick">>, "type"> & React.RefAttributes<HTMLButtonElement>>;
+export default Button;

package/dist/components/ButtonGroup/index.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { ButtonGroupType } from "../../spec";
+export declare const ButtonStyle: import("@linaria/core").LinariaClassName;
+declare const ButtonGroup: React.ForwardRefExoticComponent<ButtonGroupType & React.RefAttributes<HTMLDivElement>>;
+export default ButtonGroup;

package/dist/components/ErrorBoundary/index.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { WithTranslation } from "react-i18next";
+declare const _default: React.ComponentType<Omit<{
+    t: any;
+    tReady: boolean;
+}, keyof WithTranslation<N, undefined>> & import("react-i18next").WithTranslationProps>;
+export default _default;

package/dist/components/FailedLoad/index.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+declare const FailedLoad: React.FC<{
+    error: Error | string;
+    refetch: () => Promise<unknown>;
+    refetchText?: string;
+    className?: string;
+    title?: string;
+}>;
+export default FailedLoad;

package/dist/components/Form/index.d.ts

@@ -0,0 +1,154 @@
+import { FormApi, FormState, FormSubscription, MutableState, SubmissionErrors, Tools } from "@smartx/final-form";
+import { FieldMetaState, FieldRenderProps, FormProps, FormRenderProps, UseFormStateParams } from "@smartx/react-final-form";
+import { FieldArrayRenderProps } from "@smartx/react-final-form-arrays";
+import { ColProps } from "antd/lib/col";
+import React, { Component, ReactElement, ReactNode } from "react";
+import { Kit } from "../../spec";
+export declare const FormLayoutContext: React.Context<Form1LayoutProps>;
+declare type FormItemLayout = {
+    label?: ColProps;
+    control?: ColProps;
+};
+export declare type LayoutProps = {
+    compact?: boolean;
+    formItem?: FormItemLayout;
+};
+export declare const DEFAULT_LAYOUT: {
+    formItem: Required<FormItemLayout>;
+};
+declare type SetValuesMutator = ([mutate]: [(prevValues: Readonly<any>) => any], state: MutableState<any>) => void;
+export declare const setValuesMutator: SetValuesMutator;
+export declare const arrayMutators: {
+    replace: ([name, value]: [string, any[]], state: MutableState<any>, { changeValue }: Tools<any>) => void;
+    insert: import("@smartx/final-form").Mutator<any>;
+    concat: import("@smartx/final-form").Mutator<any>;
+    move: import("@smartx/final-form").Mutator<any>;
+    pop: import("@smartx/final-form").Mutator<any>;
+    push: import("@smartx/final-form").Mutator<any>;
+    removeBatch: import("@smartx/final-form").Mutator<any>;
+    remove: import("@smartx/final-form").Mutator<any>;
+    shift: import("@smartx/final-form").Mutator<any>;
+    swap: import("@smartx/final-form").Mutator<any>;
+    update: import("@smartx/final-form").Mutator<any>;
+    unshift: import("@smartx/final-form").Mutator<any>;
+};
+export declare type UseFormApi<T> = FormApi<T> & {
+    setValues: (callback: (prev: Readonly<T>) => T) => void;
+};
+export declare type BaseFormProps<T, V, O = {}> = {
+    initialValues?: T;
+    keepDirtyOnReinitialize?: boolean;
+    onSubmit: (values: T, form: FormApi<T>, callback?: (errors?: SubmissionErrors) => void) => SubmissionErrors | Promise<SubmissionErrors | undefined> | undefined | void;
+    subscription?: FormSubscription;
+    validation?: V;
+    onChanges?: O;
+    render: (props: Omit<FormRenderProps<T>, "form"> & {
+        form: UseFormApi<T>;
+    }) => ReactElement;
+    layout?: LayoutProps;
+    debug?: FormProps["debug"];
+};
+export declare type FormContextType<Validators = {}, OnChanges = {}> = {
+    layout: LayoutProps;
+    kit: Kit;
+    validators: Validators;
+    onChanges: OnChanges;
+};
+declare type BaseFieldState<T> = FieldMetaState<T> & {
+    value: T;
+    name: string;
+};
+export declare type FieldProps<T> = {
+    defaultValue?: T;
+    initialValue?: T;
+    format?: (value: T, name: string) => any;
+    parse?: (value: any, name: string) => T;
+    label?: ((props: BaseFieldState<T>) => ReactElement | null) | ReactNode;
+    error?: ((props: BaseFieldState<T>) => ReactElement | null) | ReactNode;
+    extra?: ((props: BaseFieldState<T>) => ReactElement | null) | ReactNode;
+    render?: ((props: FieldRenderProps<T>) => ReactElement | null) | ReactNode;
+    className?: string;
+    autoFocus?: boolean;
+    layout?: {
+        label?: ColProps;
+        control?: ColProps;
+    };
+    index?: number | number[];
+};
+export declare type FieldOnChange<T, FV> = (args: {
+    name?: string;
+    value: T | undefined;
+    setValues: UseFormApi<FV>["setValues"];
+}) => void;
+export declare type FieldListenerProps<T, FV> = {
+    name: string;
+    onChange: FieldOnChange<T, FV>;
+};
+export declare class BaseField<T, FV, P extends FieldProps<T> = FieldProps<T>> extends Component<P> {
+    path: string;
+    form: string;
+    defaultRender?: FieldProps<T>["render"];
+    render(): JSX.Element | null;
+}
+export declare type FieldArrayRenderPropsFields<T> = FieldArrayRenderProps<T, HTMLElement>["fields"] & {
+    replace: (value: T[]) => void;
+};
+export declare type FieldArrayRender<T> = (props: {
+    fields: FieldArrayRenderPropsFields<T>;
+    meta: FieldArrayRenderProps<T, HTMLElement>["meta"];
+}) => ReactElement | null;
+declare type BaseFieldArrayState<T> = FieldArrayRenderProps<T, HTMLElement>["meta"] & {
+    value?: T[];
+};
+export declare type FieldArrayProps<T> = {
+    defaultValue?: T[];
+    initialValue?: T[];
+    format?: (value: T[], name: string) => any;
+    parse?: (value: any, name: string) => T[];
+    label?: ((props: BaseFieldArrayState<T>) => ReactElement | null) | ReactNode;
+    error?: ((props: BaseFieldArrayState<T>) => ReactElement | null) | ReactNode;
+    extra?: FieldArrayRender<T> | ReactNode;
+    render?: FieldArrayRender<T> | ReactNode;
+    className?: string;
+    autoFocus?: boolean;
+    layout?: {
+        label?: ColProps;
+        control?: ColProps;
+    };
+    index?: number | number[];
+};
+export declare class BaseFieldArray<T, FV, P extends FieldArrayProps<T> = FieldArrayProps<T>> extends Component<P> {
+    path: string;
+    form: string;
+    render(): JSX.Element | null;
+}
+export declare function useEnterToSubmit(handleSubmit: FormRenderProps["handleSubmit"]): void;
+export declare function useMemoInitialValues<T>(initialValues: T, keepDirtyOnReinitialize: boolean | undefined): T;
+declare type FormItemProps = {
+    autoFocus?: boolean;
+    className: string;
+    children: ReactNode;
+};
+export declare function FormItem({ autoFocus, ...props }: FormItemProps): JSX.Element;
+export declare type FormSpyComponent<T> = (props: UseFormStateParams<T> & {
+    children: ReactElement | null | ((props: FormState<T> & {
+        form: UseFormApi<T>;
+    }) => ReactElement | null);
+}) => ReactElement;
+declare type Form1FormLayout = "general" | "compact";
+declare type Form1LabelAlign = "left" | "right";
+declare type Form1LayoutProps = {
+    layout?: Form1FormLayout;
+    labelCol?: ColProps;
+    wrapperCol?: ColProps;
+    labelAlign?: Form1LabelAlign;
+};
+export declare const InfoField: (props: {
+    label?: ReactNode;
+    children: ReactNode;
+    className?: string | undefined;
+    layoutProps?: Form1LayoutProps | undefined;
+}) => JSX.Element;
+export declare type OnSubmit<T> = (values: T, form: FormApi<T>, callback?: (errors?: SubmissionErrors) => void) => SubmissionErrors | Promise<SubmissionErrors | undefined> | undefined | void;
+export declare const usePreventSubmitOnModalClose: <T>(onSubmit: OnSubmit<T>) => OnSubmit<T>;
+export {};

package/dist/components/FormError/index.d.ts

@@ -0,0 +1,29 @@
+import { SubmissionErrors, ValidationErrors } from "@smartx/final-form";
+import { FieldRenderProps } from "@smartx/react-final-form";
+import React, { ReactElement } from "react";
+export declare const FormError: import("@linaria/react").StyledMeta & React.FunctionComponent<React.ClassAttributes<HTMLSpanElement> & React.HTMLAttributes<HTMLSpanElement> & Record<never, unknown> & {
+    as?: React.ElementType<any> | undefined;
+}>;
+export declare function deepGetErrorKey(value: string | object): string | undefined;
+export declare const findFirstError: (fields: string[], errors?: ValidationErrors | SubmissionErrors) => ValidationErrors | undefined;
+export declare const SubmitError: React.FC<{
+    className?: string;
+    fallback?: unknown;
+    analyzeFallbackError(fallback: unknown): {
+        msg: string;
+        originalMsg: string;
+    } | null;
+}>;
+export declare const V2AnalyzedError: React.FC<{
+    className?: string;
+    fallback?: unknown;
+    analyzeFallbackError(fallback: unknown): {
+        msg: string;
+        originalMsg: string;
+    } | null;
+}>;
+declare const FieldError: <T>(props: {
+    name: string;
+    children?: (props: FieldRenderProps<T>) => ReactElement;
+}) => ReactElement | null;
+export default FieldError;

package/dist/components/HoverableIcon/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { ImagesType } from "../images/images-type";
+interface IProps {
+    className?: string;
+    hover: boolean;
+    icon: ImagesType | JSX.Element | null | undefined;
+    hoverIcon: ImagesType | JSX.Element | null | undefined;
+}
+declare const HoverableIcon: (props: IProps) => JSX.Element | null;
+export default HoverableIcon;

package/dist/components/Icon/index.d.ts

@@ -0,0 +1,39 @@
+import React from "react";
+import { ImagesType } from "../images/images-type";
+export declare type IconProps = React.HTMLAttributes<HTMLSpanElement> & {
+    type: ImagesType;
+    active?: boolean;
+    hoverType?: ImagesType;
+    activeType?: ImagesType;
+    className?: string;
+    alt?: string;
+    iconWidth?: number;
+    iconHeight?: number | "auto";
+    cursor?: "pointer" | string;
+    isRotate?: boolean;
+    prefix?: React.ReactNode;
+    suffixType?: {
+        type: ImagesType;
+        hoverType?: ImagesType;
+        activeType?: ImagesType;
+    };
+};
+declare const Icon: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLSpanElement> & {
+    type: ImagesType;
+    active?: boolean | undefined;
+    hoverType?: ImagesType | undefined;
+    activeType?: ImagesType | undefined;
+    className?: string | undefined;
+    alt?: string | undefined;
+    iconWidth?: number | undefined;
+    iconHeight?: number | "auto" | undefined;
+    cursor?: string | undefined;
+    isRotate?: boolean | undefined;
+    prefix?: React.ReactNode;
+    suffixType?: {
+        type: ImagesType;
+        hoverType?: ImagesType | undefined;
+        activeType?: ImagesType | undefined;
+    } | undefined;
+} & React.RefAttributes<HTMLSpanElement>>;
+export default Icon;

package/dist/components/InputInteger/index.d.ts

@@ -0,0 +1,12 @@
+import { InputNumberProps } from "antd/lib/input-number";
+import React from "react";
+import { AdditionOptions } from "../../spec";
+export declare const AntdIntStyled: import("@linaria/react").StyledMeta & React.FunctionComponent<{
+    controls: boolean;
+    suffix?: string | undefined;
+    prefix?: string | undefined;
+} & InputNumberProps & React.RefAttributes<unknown> & {
+    as?: React.ElementType<any> | undefined;
+}>;
+declare const InputInteger: React.FC<InputNumberProps & AdditionOptions>;
+export default InputInteger;

package/dist/components/KitStoreProvider/index.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren } from "react";
+import { Actions, KitRootState } from "../../store";
+interface IProps {
+}
+declare const KitStoreProvider: (props: PropsWithChildren<IProps>) => JSX.Element;
+export default KitStoreProvider;
+export declare const useKitDispatch: () => import("redux").Dispatch<Actions>;
+export declare const useKitSelector: <Selected extends unknown>(selector: (state: KitRootState) => Selected, equalityFn?: ((previous: Selected, next: Selected) => boolean) | undefined) => Selected;

package/dist/components/Loading/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const Loading: React.FC;
+export default Loading;

package/dist/components/Metric/MetricActions.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+declare const MetricActions: React.FC<{
+    info: {
+        current: string;
+        max: string;
+    };
+    dropdown?: React.ReactNode;
+}>;
+export default MetricActions;

package/dist/components/Metric/MetricLegend.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import { ILegend, IMetricData, IMetricStream } from "./type";
+export declare const ColorBlock: React.FC<{
+    background?: string;
+}>;
+export declare type GetDeselectedValueWithSuffix = (type: string | undefined, data: IMetricData, metricName: string, sample_stream?: IMetricStream) => string;
+export interface IMetricLegendProps {
+    streams: IMetricStream[];
+    metricName: string;
+    deselected: string[];
+    onClick: (id: string) => void;
+    legends: ILegend[];
+}
+declare const MetricLegend: (props: IMetricLegendProps) => JSX.Element;
+export declare const LegendComponent: React.FC<ILegend>;
+export default MetricLegend;

package/dist/components/Metric/Pointer.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+declare const Pointer: React.FC<{
+    metricWidth: number | undefined;
+    uuid: string;
+}>;
+export default Pointer;

package/dist/components/Metric/RenderChart.d.ts

@@ -0,0 +1,41 @@
+import React from "react";
+import { TooltipProps } from "recharts";
+import { NameType, Payload, ValueType } from "recharts/types/component/DefaultTooltipContent";
+import { AxisDomain } from "recharts/types/util/types";
+import { GraphType, IMetric } from "./type";
+export interface IChartProps<TValue extends ValueType = string, TName extends NameType = number> {
+    metricName: string;
+    yAxisAlign?: "left" | "right";
+    showXAxis?: boolean;
+    showLegend?: boolean;
+    syncId: string;
+    height: number;
+    type: GraphType;
+    mode?: "simple" | "legend" | "single";
+    averageLine?: boolean;
+    dropdown?: React.ReactNode;
+    onLabelsChange?: (labels: string[]) => void;
+    metric: IMetric;
+    yAxisProps?: {
+        domain?: AxisDomain;
+        ticks?: (string | number)[];
+        tickFormatter?: (value: any, index: number) => string;
+    };
+    xAxisProps?: {
+        domain?: AxisDomain;
+        ticks?: (string | number)[];
+        tickFormatter?: (value: any, index: number) => string;
+    };
+    actionsProps?: {
+        show?: boolean;
+        info: {
+            current: string;
+            max: string;
+        };
+    };
+    tooltipProps: TooltipProps<TValue, TName> & {
+        format?: (payload: Payload<number, string>) => string;
+    };
+}
+declare const RenderChart: (props: IChartProps) => JSX.Element;
+export default RenderChart;

package/dist/components/Metric/TooltipFormatter.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { TooltipProps } from "recharts";
+import { Payload } from "recharts/types/component/DefaultTooltipContent";
+import { ILegend } from "./type";
+declare const TooltipFormatter: React.FC<TooltipProps<number, string> & {
+    deselected: string[];
+    legends: ILegend[];
+    format: (payload: Payload<number, string>) => string;
+}>;
+export default TooltipFormatter;

package/dist/components/Metric/index.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="react" />
+import { IChartProps } from "./RenderChart";
+import { TimeUnit } from "./type";
+export declare type MetricProps = {
+    height?: number;
+    showPointer?: boolean;
+    yAxisAlign?: "left" | "right";
+    showXaxis?: boolean;
+    showLegend?: boolean;
+    timeSpan?: {
+        span: number;
+        unit: TimeUnit;
+    } | string;
+    chartProps: Omit<IChartProps, "uuid">;
+};
+declare const Metric: (props: MetricProps) => JSX.Element;
+export default Metric;
+export * from "./metric";
+export * from "./MetricActions";
+export { default as MetricActions } from "./MetricActions";
+export * from "./MetricLegend";
+export { default as MetricLegend } from "./MetricLegend";
+export * from "./Pointer";
+export { default as Pointer } from "./Pointer";
+export * from "./RenderChart";
+export { default as RenderChart } from "./RenderChart";
+export * from "./TooltipFormatter";
+export { default as TooltipFormatter } from "./TooltipFormatter";
+export * from "./type";

package/dist/components/Metric/metric.d.ts

@@ -0,0 +1,43 @@
+import { DateRange, IDataPoint, IMetric } from "./type";
+export declare function filterPointsByDateRange(points: IDataPoint[], dateRange: DateRange): IDataPoint[];
+export declare const parseRange: (range: string) => {
+    span: number;
+    unit: "h" | "d";
+};
+export declare const xaxisCal: (lastTime: number, dateRange: DateRange) => number[];
+export declare const tickFormatter: (tick: number, dateRange: DateRange) => string;
+export declare function getXAxisDomain(dateRange: DateRange, xaxisLastTime?: number): [number, number];
+export declare const getMs: (dateRange: DateRange) => number;
+export declare const getStep: (dateRange: DateRange) => number;
+export declare const filterDataOverlapping: <Data extends {
+    t: number;
+    v?: number | undefined;
+} = {
+    t: number;
+    v?: number | undefined;
+}>(data: Data[], startTimestamp: number, length: number, step: number, tolerance: number) => (Data | {
+    t: number;
+    v: number;
+})[];
+export declare type MetricRefType = {
+    exportCSV: (filename: string) => void;
+    getCSVFileData: (filename?: string) => {
+        data: string;
+        filename: string;
+        filetype: string;
+    };
+};
+export declare const convertDataStruct: (streams: IDataPoint[][]) => IDataPoint[];
+export declare const filterOverlappingMetric: (metric: IMetric, dateRange: DateRange) => {
+    sample_streams: {
+        points: (IDataPoint | {
+            t: number;
+            v: number;
+        })[];
+        legend: import("./type").ILegend;
+        step: number;
+        tolerance: number;
+    }[];
+    unit: string;
+    dropped: boolean;
+};

package/dist/components/Metric/styled.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+export declare const MetricPlaceholderWrapper: import("@linaria/react").StyledMeta & import("react").FunctionComponent<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & Record<never, unknown> & {
+    as?: import("react").ElementType<any> | undefined;
+}>;
+export declare const MetricLegendTabStyle: import("@linaria/core").LinariaClassName;
+export declare const LegendStyle: import("@linaria/core").LinariaClassName;
+export declare const LegendItemStyle: import("@linaria/core").LinariaClassName;
+export declare const ColorBlockStyle: import("@linaria/core").LinariaClassName;
+export declare const ExtraResource: import("@linaria/core").LinariaClassName;
+export declare const MetricWrapper: import("@linaria/react").StyledMeta & import("react").FunctionComponent<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & Record<never, unknown> & {
+    as?: import("react").ElementType<any> | undefined;
+}>;
+export declare const TooltipWrapper: import("@linaria/react").StyledMeta & import("react").FunctionComponent<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & Record<never, unknown> & {
+    as?: import("react").ElementType<any> | undefined;
+}>;
+export declare const TooltipColumn: import("@linaria/react").StyledMeta & import("react").FunctionComponent<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & Record<never, unknown> & {
+    as?: import("react").ElementType<any> | undefined;
+}>;

package/dist/components/Metric/type.d.ts

@@ -0,0 +1,39 @@
+import { Dayjs } from "dayjs";
+export interface IMetricData {
+    id: string;
+}
+export interface IDataPoint {
+    t: number;
+    v?: number;
+    [key: DataPointValueKey]: number | undefined;
+}
+declare type DataPointValueKey = `v${number}`;
+export interface ILegend {
+    id: string;
+    name: string;
+    color?: string;
+    fill?: string;
+    stroke?: boolean;
+}
+export interface IMetricStream {
+    points: IDataPoint[];
+    legend: ILegend;
+    step: number;
+    tolerance: number;
+}
+export interface IMetric {
+    sample_streams: IMetricStream[];
+    unit: string;
+    dropped: boolean;
+}
+export declare enum TimeUnit {
+    Day = "DAY",
+    Hour = "HOUR",
+    Month = "MONTH"
+}
+export declare enum GraphType {
+    Area = "AREA",
+    Stack = "STACK"
+}
+export declare type DateRange = [Dayjs, Dayjs];
+export {};

package/dist/components/Modal/index.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { ModalProps } from "../../spec";
+declare const Modal: React.FC<ModalProps>;
+export default Modal;

package/dist/components/Modal2/Error.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+interface ModalErrorType {
+    error: Error | string | React.ReactNode;
+    analyzeFallbackError: (fallback: unknown) => {
+        msg: string;
+        originalMsg: string;
+    } | null;
+}
+export declare const ModalContentError: React.FC<ModalErrorType>;
+interface ModalFooterErrorType extends ModalErrorType {
+    className?: string;
+}
+export declare const ModalFooterError: React.FC<ModalFooterErrorType>;
+export {};

package/dist/components/Modal2/InitializedModal.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { InitializedModalType } from "../../spec";
+declare const InitializedModal: React.FC<InitializedModalType>;
+export default InitializedModal;

package/dist/components/Modal2/Modal.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { Modal2Props } from "../../spec";
+declare const Modal: React.FC<Modal2Props & {
+    analyzeFallbackError: (fallback: unknown) => {
+        msg: string;
+        originalMsg: string;
+    } | null;
+}>;
+export default Modal;

package/dist/components/Modal2/WizardModal.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { WizardModalType } from "../../spec";
+declare const WizardModal: React.FC<WizardModalType>;
+export default WizardModal;

package/dist/components/Modal2/index.d.ts

@@ -0,0 +1,10 @@
+import { Modal2Type } from "../../spec";
+import InitializedModal from "./InitializedModal";
+import WizardModal from "./WizardModal";
+declare const Modal: Modal2Type;
+export default Modal;
+export { InitializedModal, Modal, WizardModal };
+export * from "./Error";
+export * from "./InitializedModal";
+export * from "./Modal";
+export * from "./WizardModal";

package/dist/components/ModalStack/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const ModalStack: React.FC;
+export default ModalStack;

package/dist/components/Overflow/index.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+declare const Overflow: React.FC<{
+    overflow: React.ReactNode;
+    offset?: number;
+    depend?: string;
+}>;
+export declare const ExtraOverflow: React.FC<{
+    extraEl: (sliceEnd: number) => React.ReactNode;
+    els: React.ReactNode[];
+    className?: string;
+    deps?: unknown[];
+    reverse?: boolean;
+}>;
+export default Overflow;

package/dist/components/Pagination/index.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { PaginationProps } from "../../spec";
+declare const Pagination: React.FC<PaginationProps>;
+export default Pagination;