@orioro/react-ui-core 0.0.0

package/dist/Dialog/DialogSystem/types.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { useConfirmDialog } from '../ConfirmDialog';
+import { ConfirmDialogProps } from '../ConfirmDialog/types';
+import { InfoDialogProps, useInfoDialog } from '../InfoDialog';
+import { LoadingDialogProps, useLoadingDialog } from '../LoadingDialog';
+import { PromptDialogProps, usePromptDialog } from '../PromptDialog';
+import { OptionsDialogProps } from '../OptionsDialog/types';
+import { useOptionsDialog } from '../OptionsDialog';
+export type DialogSystemDialogProps = Partial<{
+    info: InfoDialogProps;
+    loading: LoadingDialogProps;
+    prompt: PromptDialogProps;
+    confirm: ConfirmDialogProps;
+    options: OptionsDialogProps;
+}>;
+export type DialogSystemProps = DialogSystemDialogProps & {
+    children: React.ReactNode;
+};
+export type DialogSystemContextValue = {
+    info: ReturnType<typeof useInfoDialog>[1];
+    loading: ReturnType<typeof useLoadingDialog>[1];
+    prompt: ReturnType<typeof usePromptDialog>[1];
+    confirm: ReturnType<typeof useConfirmDialog>[1];
+    options: ReturnType<typeof useOptionsDialog>[1];
+};

package/dist/Dialog/InfoDialog/InfoDialog.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { InfoDialogProps } from './types';
+export declare function InfoDialog({ open, dismissable, onAcknowledge, buttonBar, title, message, acknowledge, errorActionHandlers, maxWidth, style, }: InfoDialogProps): React.JSX.Element;
+export declare namespace InfoDialog {
+    var Acknowlege: typeof InfoDialogAcknowledge;
+}
+export declare function InfoDialogAcknowledge({ children }: {
+    children: any;
+}): React.JSX.Element;

package/dist/Dialog/InfoDialog/index.d.ts

@@ -0,0 +1,3 @@
+export * from './InfoDialog';
+export * from './types';
+export * from './useInfoDialog';

package/dist/Dialog/InfoDialog/types.d.ts

@@ -0,0 +1,18 @@
+import { ErrorActionHanlders } from '../../ErrorDisplay';
+import { FlexProps } from '../../Flex';
+import { MergeableComponentInput } from '../../mergeable';
+import { CSSLength } from '../../util';
+export type InfoMessage = MergeableComponentInput | Error;
+export type InfoDialogContentProps = Partial<{
+    title: MergeableComponentInput;
+    message: InfoMessage;
+    buttonBar: FlexProps;
+    acknowledge: MergeableComponentInput;
+}>;
+export type InfoDialogProps = InfoDialogContentProps & {
+    open?: boolean;
+    dismissable?: boolean;
+    onAcknowledge: () => void;
+    errorActionHandlers?: ErrorActionHanlders;
+    maxWidth?: CSSLength;
+};

package/dist/Dialog/InfoDialog/useInfoDialog.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { InfoDialogProps } from './types';
+export type RequestInfo = (messageOrProps: string | React.ReactNode | Partial<InfoDialogProps>) => Promise<void>;
+export declare function useInfoDialog(baseDialogProps?: Partial<InfoDialogProps>): [InfoDialogProps, RequestInfo];

package/dist/Dialog/LoadingDialog/LoadingDialog.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { LoadingDialogProps } from './types';
+export declare function LoadingDialog({ open, message }: LoadingDialogProps): React.JSX.Element;

package/dist/Dialog/LoadingDialog/index.d.ts

@@ -0,0 +1,3 @@
+export * from './LoadingDialog';
+export * from './types';
+export * from './useLoadingDialog';

package/dist/Dialog/LoadingDialog/types.d.ts

@@ -0,0 +1,4 @@
+export type LoadingDialogProps = {
+    open?: any | Promise<any>;
+    message?: string;
+};

package/dist/Dialog/LoadingDialog/useLoadingDialog.d.ts

@@ -0,0 +1,5 @@
+import { LoadingDialogProps } from './types';
+export declare function useLoadingDialog(baseDialogProps?: Partial<LoadingDialogProps>): [
+    LoadingDialogProps,
+    (promiseOrValue: Promise<any> | any, message?: string) => Promise<any>
+];

package/dist/Dialog/OptionsDialog/OptionsDialog.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { OptionsDialogProps } from './types';
+export declare function OptionsDialog({ open, dismissable, options, onSelect, onCancel, renderOption, title, message, cancel, maxWidth, }: OptionsDialogProps): React.JSX.Element;

package/dist/Dialog/OptionsDialog/index.d.ts

@@ -0,0 +1,2 @@
+export * from './OptionsDialog';
+export * from './useOptionsDialog';

package/dist/Dialog/OptionsDialog/types.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { MergeableComponentInput } from '../../mergeable';
+import { CSSLength } from '../../util';
+export type Option = {
+    value: string | symbol | boolean | number;
+    label: string | React.ReactElement;
+    color?: string;
+    variant?: string;
+    [key: string]: any;
+};
+export type OptionsDialogContentProps = Partial<{
+    title: MergeableComponentInput;
+    message: MergeableComponentInput;
+    cancel: MergeableComponentInput;
+}>;
+export type OptionsDialogProps = OptionsDialogContentProps & {
+    open?: boolean;
+    dismissable?: boolean;
+    maxWidth?: CSSLength;
+    options: Option[];
+    renderOption?: (option: Option, onSelect: (value: Option['value']) => void, onCancel: () => void) => React.ReactElement;
+    onSelect: (value: Option['value']) => void;
+    onCancel: () => void;
+};

package/dist/Dialog/OptionsDialog/useOptionsDialog.d.ts

@@ -0,0 +1,3 @@
+import { Option, OptionsDialogProps } from './types';
+export type RequestSelect = <InputType = any>(propsOrOptions: Option[] | Partial<OptionsDialogProps>) => Promise<InputType>;
+export declare function useOptionsDialog(baseDialogProps?: Partial<OptionsDialogProps>): [OptionsDialogProps, RequestSelect];

package/dist/Dialog/PromptDialog/PromptDialog.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { Dialog } from '@radix-ui/themes';
+import { PromptDialogContentProps, PromptDialogProps } from './types';
+declare function PromptDialogContent<InputType = any>({ input, title, form, description, buttonBar, restore, cancel, submit, buttons, maxWidth, }: Omit<PromptDialogContentProps<InputType>, 'active'>): React.JSX.Element;
+export declare function PromptDialog({ open: externalOpen, onSetOpen, ...props }: PromptDialogProps): React.JSX.Element;
+export declare namespace PromptDialog {
+    var Root: React.FC<Dialog.RootProps>;
+    var Content: typeof PromptDialogContent;
+    var Trigger: React.ForwardRefExoticComponent<Dialog.TriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    var Context: React.Context<{
+        open?: boolean | undefined;
+        setOpen?: ((nextOpen: boolean) => any) | undefined;
+        promptUI: {
+            value: unknown;
+            setValue: React.Dispatch<unknown>;
+            isLoading: boolean;
+            hasUnsubmittedChanges: boolean;
+            inputProps: {
+                value: unknown;
+                onSetValue: React.Dispatch<unknown>;
+                disabled: boolean;
+                invalid: boolean;
+                errorMessage: any;
+            };
+            restore: () => void;
+            submit: (...args: any[]) => any;
+            cancel: () => Promise<void>;
+            cancelProps: {
+                disabled: boolean;
+                onClick: () => Promise<void>;
+            };
+            restoreProps: {
+                onClick: () => void;
+                style: {
+                    display: string;
+                } | {
+                    display?: undefined;
+                };
+            };
+            submitProps: {
+                disabled: boolean;
+            };
+            submitState: import("../..").PromiseState;
+        };
+    }>;
+}
+export {};

package/dist/Dialog/PromptDialog/index.d.ts

@@ -0,0 +1,3 @@
+export * from './PromptDialog';
+export * from './usePromptDialog';
+export * from './types';

package/dist/Dialog/PromptDialog/isEqual.d.ts

@@ -0,0 +1 @@
+export declare function isEqual<InputType>(initialValue: InputType | undefined, value: InputType | undefined): boolean;

package/dist/Dialog/PromptDialog/types.d.ts

@@ -0,0 +1,22 @@
+import React, { HTMLProps } from 'react';
+import { FlexProps } from '../../Flex';
+import { MergeableComponentInput } from '../../mergeable';
+import { PromptUIProps, usePromptUI } from '../../usePromptUI';
+export type PromptDialogLabelProps = Partial<{
+    title: MergeableComponentInput;
+    description: [MergeableComponentInput, MergeableComponentInput] | MergeableComponentInput;
+    restore: MergeableComponentInput;
+    cancel: MergeableComponentInput;
+    submit: MergeableComponentInput;
+}>;
+export type PromptDialogUIProps = PromptDialogLabelProps & Partial<{
+    form: HTMLProps<HTMLFormElement>;
+    buttonBar: FlexProps;
+    maxWidth: string;
+    buttons: React.ReactNode | ((promptUI: ReturnType<typeof usePromptUI>) => React.ReactNode);
+}>;
+export type PromptDialogContentProps<InputType = any> = PromptUIProps & PromptDialogUIProps;
+export type PromptDialogProps<InputType = any> = PromptUIProps & {
+    open?: boolean;
+    onSetOpen?: (nextOpen: boolean) => any;
+} & PromptDialogUIProps;

package/dist/Dialog/PromptDialog/usePromptDialog.d.ts

@@ -0,0 +1,4 @@
+import { PromptDialogProps } from './types';
+import { InputSchema } from '../../Input';
+export type RequestPrompt = <InputType = any>(propsOrTitle: string | Partial<PromptDialogProps>, maybeInput?: string | InputSchema) => Promise<InputType>;
+export declare function usePromptDialog(baseDialogProps?: Partial<PromptDialogProps>): [PromptDialogProps, RequestPrompt];

package/dist/Dialog/constants.d.ts

@@ -0,0 +1 @@
+export declare const CANCELLED: unique symbol;

package/dist/Dialog/createDialogSystem/createDialogSystem.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { UseDialogOptions } from './useDialog';
+export type DialogSpecs = {
+    [key: string]: ((props: any) => React.ReactElement) | [(props: any) => React.ReactElement, UseDialogOptions?];
+};
+type CreateDialogSystemProps = {
+    dialogs: DialogSpecs;
+};
+export declare function createDialogSystem({ dialogs }: CreateDialogSystemProps): (React.Context<{}> | (({ children, ...props }: {
+    [key: string]: Record<string, any>;
+    children: React.ReactElement;
+}) => React.JSX.Element) | (() => {}))[];
+export {};

package/dist/Dialog/createDialogSystem/index.d.ts

@@ -0,0 +1,2 @@
+export * from './createDialogSystem';
+export * from './useDialog';

package/dist/Dialog/createDialogSystem/proxyRef.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function proxyRef(keys: string[], toRef: React.RefObject<Record<string, any>>): Record<string, any>;

package/dist/Dialog/createDialogSystem/useDialog.d.ts

@@ -0,0 +1,18 @@
+export type UseDialogOptions = {
+    props?: (defer: {
+        resolve: (result?: any) => void;
+        reject: (err: any) => void;
+    }, ...args: any[]) => Record<string, any>;
+};
+/**
+ * Utility hook that sets up promise resolution systems
+ */
+export declare function useDialog<DialogProps, OnExecuteResultType = any>(baseDialogProps?: Partial<DialogProps>, options?: UseDialogOptions): {
+    dialogProps: Partial<DialogProps> & {
+        [key: string]: any;
+        open?: boolean | undefined;
+    };
+    resolve: (value: OnExecuteResultType) => Promise<void>;
+    reject: (error: any) => Promise<void>;
+    invoke: (...args: any[]) => Promise<OnExecuteResultType>;
+};

package/dist/Dialog/index.d.ts

@@ -0,0 +1,8 @@
+export * from './ConfirmDialog';
+export * from './AuthDialog';
+export * from './DialogSystem';
+export * from './InfoDialog';
+export * from './LoadingDialog';
+export * from './PromptDialog';
+export * from './constants';
+export * from './createDialogSystem';

package/dist/Dialog/useDialog/index.d.ts

@@ -0,0 +1,6 @@
+export declare function useDialog<DialogProps, OnExecuteResultType = any>(baseDialogProps?: Partial<DialogProps>): {
+    dialogProps: Partial<DialogProps>;
+    onResolve: (value: OnExecuteResultType) => Promise<void>;
+    onReject: (error: any) => Promise<void>;
+    onExecute: (overrides: Partial<DialogProps>) => Promise<OnExecuteResultType>;
+};

package/dist/DotDotDot/index.d.ts

@@ -0,0 +1,3 @@
+import React, { HTMLProps } from 'react';
+export declare const AnimatedDots: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>;
+export declare function DotDotDot({ children, ...props }: HTMLProps<HTMLSpanElement>): React.JSX.Element;

package/dist/Editable/EditableContext.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { EditableContextProps } from './types';
+export declare const EditableContext: import("react").Context<EditableContextProps>;

package/dist/Editable/EditableField.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { Editable } from './types';
+export declare function EditableField({ trigger, children, triggerPlacement, active, onEdit, placeholder, fieldKeys, ...props }: Editable): React.JSX.Element;

package/dist/Editable/EditableRoot.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { EditableRootProps } from './types';
+export declare function EditableRoot({ active, onSetActive, onEdit, children, }: EditableRootProps): React.JSX.Element;

package/dist/Editable/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { EditableField } from './EditableField';
+import { EditableRoot } from './EditableRoot';
+export * from './EditableField';
+export * from './EditableContext';
+export declare const Editable: {
+    Field: typeof EditableField;
+    Root: typeof EditableRoot;
+    Context: import("react").Context<import("./types").EditableContextProps>;
+};

package/dist/Editable/types.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { Placement } from '../HoverElement';
+type OnEdit = (fieldKeys: string[], context: EditableContextProps) => void;
+export type Editable = {
+    [key: string]: any;
+    children: React.ReactNode;
+    trigger?: React.ReactNode;
+    triggerPlacement?: Placement;
+    onEdit: OnEdit;
+    active?: boolean;
+    editableStyle?: boolean | string;
+    fieldKeys: string[];
+};
+export type EditableContextProps = {
+    active: boolean;
+    setActive: (active: boolean) => void;
+    onEdit?: OnEdit;
+    [key: string]: any;
+};
+export type EditableRootProps = {
+    active?: boolean;
+    onSetActive?: (active: boolean) => void;
+    onEdit?: OnEdit;
+    children: React.ReactNode;
+};
+export {};

package/dist/ErrorDisplay/ErrorDisplay.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { ErrorDisplayProps } from './types';
+export declare function ErrorDisplay({ error, errorActionHandlers, }: ErrorDisplayProps): React.JSX.Element;

package/dist/ErrorDisplay/ErrorHandlingContext.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="react" />
+import { ErrorActionHanlders, ErrorDictionary, ErrorHandlingContextValue, ErrorReference, SuggestedAction } from './types';
+export declare const DEFAULT_ACTION_HANDLERS: {
+    navigateBack: () => void;
+    reload: () => void;
+};
+export declare const ErrorHandlingContext: import("react").Context<ErrorHandlingContextValue>;
+export declare const ErrorHandlingProvider: import("react").Provider<ErrorHandlingContextValue>;
+export declare function getErrorData(dictionary: ErrorDictionary, error: ErrorReference): {
+    [x: string]: any;
+    name: string;
+    message: string;
+    httpCode?: number | undefined;
+    action?: SuggestedAction | undefined;
+};
+export declare function useLogError(error: ErrorReference): string | void;
+export declare function useErrorHandling(error: ErrorReference, localHandlers?: ErrorActionHanlders): {
+    errorLogId: string | void;
+    action: {
+        handle: () => void;
+        id?: string | undefined;
+        label?: string | undefined;
+    } | null;
+    name: string;
+    message: string;
+    httpCode?: number | undefined;
+};

package/dist/ErrorDisplay/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ErrorDisplay';
+export * from './ErrorHandlingContext';
+export * from './types';

package/dist/ErrorDisplay/types.d.ts

@@ -0,0 +1,34 @@
+import { Merge } from 'type-fest';
+export type ErrorName = string;
+export type HTTPErrorCode = number;
+export type ErrorReference = Error | ErrorName | HTTPErrorCode;
+export type ErrorActionHanlders = {
+    [key: string]: (error: ErrorReference) => void;
+};
+export type ErrorDisplayProps = {
+    error: ErrorReference;
+    errorActionHandlers?: ErrorActionHanlders;
+};
+export type SuggestedAction = {
+    id: 'signIn' | 'navigateBack' | 'retry' | 'reload' | string;
+    label: string;
+    [key: string]: any;
+};
+export type ErrorDataObject<ErrorCustomProps = {}> = Merge<{
+    name: ErrorName;
+    message: string;
+    httpCode?: HTTPErrorCode;
+    action?: SuggestedAction;
+    [key: string]: any;
+}, ErrorCustomProps>;
+export type GetErrorData<ErrorCustomProps = {}> = (error: ErrorReference) => ErrorDataObject<ErrorCustomProps>;
+export type ErrorData<ErrorCustomProps = {}> = ErrorDataObject<ErrorCustomProps> | GetErrorData;
+export type ErrorDictionary<ErrorCustomProps = {}> = {
+    [key: string | number]: ErrorData<ErrorCustomProps>;
+};
+export type LogError = (error: ErrorReference) => string | void | Promise<string | void>;
+export type ErrorHandlingContextValue = {
+    dictionary: ErrorDictionary;
+    onLogError?: LogError;
+    errorActionHandlers?: ErrorActionHanlders;
+};

package/dist/EvenSpacedList/EvenSpacedList.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="react" />
+import { EvenSpacedListStylesProps } from './evenSpacedListStyles';
+import { FlexBaseStyles } from '../Flex';
+import { BoxProps } from '../Box';
+export type EvenSpacedListProps = BoxProps & FlexBaseStyles & EvenSpacedListStylesProps & {
+    children?: React.ReactNode;
+};
+export declare const EvenSpacedList: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps, import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps>, never>, keyof import("..").ResponsiveProps | "top" | "bottom" | "left" | "right" | "width" | "height" | "position" | "flexShrink" | "flexGrow" | "inset" | keyof import("../Box/spacing").SpacingStyles> & import("../Box/spacing").SpacingStyles & import("..").ResponsiveProps & {
+    children?: import("react").ReactNode;
+    width?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    height?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    position?: import("..").ResponsiveValueInput<import("..").CSSPosition> | undefined;
+    top?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    right?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    bottom?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    left?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    flexShrink?: import("..").ResponsiveValueInput<string> | undefined;
+    flexGrow?: import("..").ResponsiveValueInput<string> | undefined;
+    inset?: import("..").ResponsiveValueInput<"top" | "bottom" | "left" | "right"> | undefined;
+}, import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps, import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps>, never>, keyof import("..").ResponsiveProps | "top" | "bottom" | "left" | "right" | "width" | "height" | "position" | "flexShrink" | "flexGrow" | "inset" | keyof import("../Box/spacing").SpacingStyles> & import("../Box/spacing").SpacingStyles & import("..").ResponsiveProps & {
+    children?: import("react").ReactNode;
+    width?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    height?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    position?: import("..").ResponsiveValueInput<import("..").CSSPosition> | undefined;
+    top?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    right?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    bottom?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    left?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    flexShrink?: import("..").ResponsiveValueInput<string> | undefined;
+    flexGrow?: import("..").ResponsiveValueInput<string> | undefined;
+    inset?: import("..").ResponsiveValueInput<"top" | "bottom" | "left" | "right"> | undefined;
+}>, never>, EvenSpacedListProps>> & Omit<import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps, import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps>, never>, BoxProps>> & Omit<import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, import("..").ResponsiveProps>>, keyof import("react").Component<any, {}, any>>, keyof import("react").Component<any, {}, any>>;

package/dist/EvenSpacedList/evenSpacedListStyles.d.ts

@@ -0,0 +1,11 @@
+import { Theme } from '../Theme';
+import { CSSLength } from '../util';
+import { ResponsiveValueInput } from '../Responsive';
+export type Gap = ResponsiveValueInput<CSSLength | [CSSLength, CSSLength]>;
+export type EvenSpacedListStylesProps = {
+    gap?: Gap;
+    columns: ResponsiveValueInput<number>;
+};
+export declare function evenSpacedListStyles({ columns, gap, theme, }: EvenSpacedListStylesProps & {
+    theme: Partial<Theme>;
+}): string;

package/dist/EvenSpacedList/index.d.ts

@@ -0,0 +1 @@
+export * from './EvenSpacedList';

package/dist/FileDropzone/index.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { Merge } from 'type-fest';
+import { Accept, DropzoneOptions } from 'react-dropzone';
+import { ResponsiveProps } from '../Responsive';
+type CustomAccept = string | string[] | Accept;
+export type FileDropzoneProps = Merge<Merge<DropzoneOptions, ResponsiveProps>, {
+    dropzoneLabel?: (state: DropzoneStateProps) => React.ReactNode;
+    accept?: CustomAccept;
+}>;
+type DropzoneStateProps = {
+    isFocused: boolean;
+    isDragActive: boolean;
+    isDragReject: boolean;
+    isDragAccept: boolean;
+    isFileDialogActive: boolean;
+};
+export declare function FileDropzone({ dropzoneLabel, accept, style, ...props }: FileDropzoneProps): React.JSX.Element;
+export {};

package/dist/FileIcon/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare const ICON_BY_TYPE: {
+    [key: string]: React.FC;
+};
+export declare function FileIcon({ mimeType, ...props }: {
+    mimeType: string;
+    [key: string]: any;
+}): React.JSX.Element;

package/dist/FilePreview/FileThumb.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { AspectRatioProps } from '../AspectRatio';
+type FileThumbProps = AspectRatioProps & {
+    file: File;
+};
+export declare function FileThumb({ file, ...props }: FileThumbProps): "" | React.JSX.Element;
+export {};

package/dist/FilePreview/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { FlexProps } from '../Flex';
+import { Merge } from 'type-fest';
+type FilePreviewProps = Merge<Partial<FlexProps>, {
+    file: File;
+    onRemove?: (file: File) => void;
+}>;
+export declare function FilePreview({ file, onRemove, style, ...flexProps }: FilePreviewProps): React.JSX.Element;
+export {};

package/dist/Flex/Flex.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="react" />
+import { FlexGapStylesProps } from './flexGapStyles';
+import { FlexBaseStyles } from './flexBaseStyles';
+import { BoxProps } from '../Box';
+export declare const FLEX_PROPS: string[];
+export type FlexProps = BoxProps & FlexGapStylesProps & FlexBaseStyles;
+export declare const Flex: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps, import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps>, never>, keyof import("..").ResponsiveProps | "top" | "bottom" | "left" | "right" | "width" | "height" | "position" | "flexShrink" | "flexGrow" | "inset" | keyof import("../Box/spacing").SpacingStyles> & import("../Box/spacing").SpacingStyles & import("..").ResponsiveProps & {
+    children?: import("react").ReactNode;
+    width?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    height?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    position?: import("..").ResponsiveValueInput<import("..").CSSPosition> | undefined;
+    top?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    right?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    bottom?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    left?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    flexShrink?: import("..").ResponsiveValueInput<string> | undefined;
+    flexGrow?: import("..").ResponsiveValueInput<string> | undefined;
+    inset?: import("..").ResponsiveValueInput<"top" | "bottom" | "left" | "right"> | undefined;
+}, import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps, import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps>, never>, keyof import("..").ResponsiveProps | "top" | "bottom" | "left" | "right" | "width" | "height" | "position" | "flexShrink" | "flexGrow" | "inset" | keyof import("../Box/spacing").SpacingStyles> & import("../Box/spacing").SpacingStyles & import("..").ResponsiveProps & {
+    children?: import("react").ReactNode;
+    width?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    height?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    position?: import("..").ResponsiveValueInput<import("..").CSSPosition> | undefined;
+    top?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    right?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    bottom?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    left?: import("..").ResponsiveValueInput<import("..").CSSLength> | undefined;
+    flexShrink?: import("..").ResponsiveValueInput<string> | undefined;
+    flexGrow?: import("..").ResponsiveValueInput<string> | undefined;
+    inset?: import("..").ResponsiveValueInput<"top" | "bottom" | "left" | "right"> | undefined;
+}>, never>, FlexProps>> & Omit<import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps, import("styled-components/dist/types").FastOmit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("..").ResponsiveProps> & import("..").ResponsiveProps>, never>, BoxProps>> & Omit<import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").Substitute<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, import("..").ResponsiveProps>>, keyof import("react").Component<any, {}, any>>, keyof import("react").Component<any, {}, any>>;
+export * from './flexGapStyles';

package/dist/Flex/flexBaseStyles.d.ts

@@ -0,0 +1,13 @@
+import { ResponsiveValueInput } from '../Responsive';
+import { StyleSpecInput } from '../styleResolver';
+import { FlexAlignItems, FlexJustifyContent, FlexWrap, FlexDisplay } from './types';
+export declare const FLEX_BASE_STYLE_PROPS: StyleSpecInput;
+export type FlexBaseStyles = {
+    display?: ResponsiveValueInput<FlexDisplay>;
+    alignItems?: ResponsiveValueInput<FlexAlignItems>;
+    justifyContent?: ResponsiveValueInput<FlexJustifyContent>;
+    flexWrap?: ResponsiveValueInput<FlexWrap>;
+};
+export declare const flexBaseStyles: (props: {
+    [key: string]: any;
+}) => any;

package/dist/Flex/flexGapStyles.d.ts

@@ -0,0 +1,11 @@
+import { ResponsiveValueInput } from '../Responsive';
+import { Theme } from '../Theme';
+import { CSSLength } from '../util';
+import { FlexDirection } from './types';
+export type FlexGapStylesProps = {
+    direction?: ResponsiveValueInput<FlexDirection>;
+    theme?: Partial<Theme>;
+    gap?: ResponsiveValueInput<CSSLength>;
+    childOnlyGap?: ResponsiveValueInput<CSSLength>;
+};
+export declare function flexGapStyles({ direction, theme, gap, childOnlyGap, }: FlexGapStylesProps): string;

package/dist/Flex/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Flex';
+export * from './flexBaseStyles';
+export * from './flexGapStyles';
+export * from './types';