@importcsv/react 0.2.0 → 0.2.3

package/build/preact/importer/components/Checkbox/index.d.ts

@@ -0,0 +1,2 @@
+import { CheckboxProps } from './types';
+export default function Checkbox({ label, className, ...props }: CheckboxProps): import("react/jsx-runtime").JSX.Element;

package/build/preact/importer/components/Checkbox/types/index.d.ts

@@ -0,0 +1,4 @@
+import { InputHTMLAttributes, ReactElement } from 'preact/hooks';
+export type CheckboxProps = InputHTMLAttributes<HTMLInputElement> & {
+    label?: string | ReactElement;
+};

package/build/preact/importer/components/Errors/index.d.ts

@@ -0,0 +1,4 @@
+export default function Errors({ error, centered }: {
+    error?: unknown;
+    centered?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

package/build/preact/importer/components/Input/index.d.ts

@@ -0,0 +1,2 @@
+import { InputProps } from './types';
+export default function Input({ as, label, icon, iconAfter, error, options, className, variants, children, ...props }: InputProps): import("react/jsx-runtime").JSX.Element;

package/build/preact/importer/components/Input/types/index.d.ts

@@ -0,0 +1,18 @@
+import { ButtonHTMLAttributes, InputHTMLAttributes, ReactElement } from 'preact/hooks';
+export type inputTypes = "date" | "datetime-local" | "email" | "file" | "month" | "number" | "password" | "search" | "tel" | "text" | "time" | "url" | "week";
+export type InputVariants = "fluid" | "small";
+export type InputOption = ButtonHTMLAttributes<HTMLButtonElement> & {
+    required?: boolean;
+};
+export type InputProps = InputHTMLAttributes<HTMLInputElement> & InputHTMLAttributes<HTMLSelectElement> & InputHTMLAttributes<HTMLTextAreaElement> & {
+    as?: "input" | "textarea";
+    label?: string | ReactElement;
+    icon?: ReactElement;
+    iconAfter?: ReactElement;
+    error?: string;
+    options?: {
+        [key: string]: InputOption;
+    };
+    variants?: InputVariants[];
+    type?: inputTypes;
+};

package/build/preact/importer/components/Root/index.d.ts

@@ -0,0 +1,10 @@
+import { ComponentChildren } from 'preact';
+interface RootProps {
+    children?: ComponentChildren;
+    className?: string;
+    primaryColor?: string;
+}
+declare const _default: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<RootProps> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+export default _default;

package/build/preact/importer/components/StepLayout/index.d.ts

@@ -0,0 +1,18 @@
+import { ComponentChildren } from 'preact';
+interface StepLayoutProps {
+    title?: string;
+    subtitle?: string;
+    children: ComponentChildren;
+    headerContent?: ComponentChildren;
+    footerContent?: ComponentChildren;
+    showHeader?: boolean;
+    showFooter?: boolean;
+    className?: string;
+    contentClassName?: string;
+}
+/**
+ * Consistent layout wrapper for all importer steps
+ * Ensures uniform spacing, typography, and structure
+ */
+export default function StepLayout({ title, subtitle, children, headerContent, footerContent, showHeader, showFooter, className, contentClassName, }: StepLayoutProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/preact/importer/components/Stepper/hooks/useStepper.d.ts

@@ -0,0 +1,2 @@
+import { Step, StepperProps } from '../types';
+export default function useStepper(steps: Step[], initialStep: number | undefined, skipHeader: boolean): StepperProps;

package/build/preact/importer/components/Stepper/index.d.ts

@@ -0,0 +1,2 @@
+import { StepperProps } from './types';
+export default function Stepper({ steps, current, hide, skipHeader }: StepperProps): import("react/jsx-runtime").JSX.Element | null;

package/build/preact/importer/components/Stepper/types/index.d.ts

@@ -0,0 +1,14 @@
+export type Step = {
+    label: string;
+    id?: string | number;
+    disabled?: boolean;
+};
+export type StepperProps = {
+    steps: Step[];
+    current: number;
+    setCurrent: (step: number) => void;
+    step: Step;
+    clickable?: boolean;
+    skipHeader: boolean;
+    hide?: boolean;
+};

package/build/preact/importer/components/Table/index.d.ts

@@ -0,0 +1,9 @@
+import { JSX } from 'preact';
+import { TableProps } from './types';
+export default function Table({ data, // An array of objects with the data to be displayed
+keyAsId, // Has to be a unique property in the data array to be used as key
+theme, // A CSS module object to style the table
+mergeThemes, // Should 'theme' be the only style applied (false) or be merged with the default style (true)
+highlightColumns, // Columns that should use the highlighted style
+hideColumns, // Array of columns to be hidden in the display
+emptyState, heading, background, columnWidths, columnAlignments, fixHeader, onRowClick, }: TableProps): JSX.Element;

package/build/preact/importer/components/ToggleFilter/index.d.ts

@@ -0,0 +1,3 @@
+import { ToggleFilterProps } from './types';
+declare function ToggleFilter({ options, onChange, className }: ToggleFilterProps): import("react/jsx-runtime").JSX.Element;
+export default ToggleFilter;

package/build/preact/importer/components/ToggleFilter/types/index.d.ts

@@ -0,0 +1,11 @@
+export interface Option {
+    label: string;
+    filterValue: string;
+    selected: boolean;
+    color?: string;
+}
+export interface ToggleFilterProps {
+    options: Option[];
+    className?: string;
+    onChange: (option: string) => void;
+}

package/build/preact/importer/components/Tooltip/index.d.ts

@@ -0,0 +1,2 @@
+import { AsMap, TooltipProps } from './types';
+export default function Tooltip<T extends keyof AsMap>({ as, className, title, children, icon, ...props }: TooltipProps<T>): import("react/jsx-runtime").JSX.Element;

package/build/preact/importer/components/Tooltip/types/index.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'preact/hooks';
+export type AsMap = {
+    div: JSX.HTMLAttributes<HTMLDivElement>;
+    span: JSX.HTMLAttributes<HTMLSpanElement>;
+    p: JSX.HTMLAttributes<HTMLParagraphElement>;
+};
+export type TooltipProps<T extends keyof AsMap = "span"> = {
+    as?: T;
+    title?: string | ReactNode;
+    icon?: ReactNode;
+} & AsMap[T];

package/build/preact/importer/components/UploaderWrapper/NativeDropzone.d.ts

@@ -0,0 +1,11 @@
+import { ComponentChildren } from 'preact';
+interface NativeDropzoneProps {
+    onFileSelect: (file: File) => void;
+    accept?: Record<string, string[]>;
+    disabled?: boolean;
+    loading?: boolean;
+    className?: string;
+    children?: ComponentChildren;
+}
+export default function NativeDropzone({ onFileSelect, accept, disabled, loading, className, children }: NativeDropzoneProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/preact/importer/components/UploaderWrapper/UploaderWrapper.d.ts

@@ -0,0 +1,2 @@
+import { UploaderWrapperProps } from './types';
+export default function UploaderWrapper({ onSuccess, setDataError, ...props }: UploaderWrapperProps): import("react/jsx-runtime").JSX.Element;

package/build/preact/importer/components/UploaderWrapper/types/index.d.ts

@@ -0,0 +1,2 @@
+import { UploaderProps } from '../../../features/uploader/types';
+export type UploaderWrapperProps = Omit<UploaderProps, "template"> & {};

package/build/preact/importer/components/VirtualTable/index.d.ts

@@ -0,0 +1,17 @@
+import { JSX } from 'preact';
+import { FileRow } from '../../features/main/types';
+interface VirtualTableProps {
+    headers: string[];
+    rows: FileRow[];
+    renderCell: (row: FileRow, colIdx: number, actualRowIdx: number) => JSX.Element;
+    onCellEdit?: (rowIdx: number, colIdx: number, value: string) => void;
+    rowHeight?: number;
+    overscan?: number;
+    stickyHeader?: boolean;
+    stickyFirstColumn?: boolean;
+    getRowClassName?: (row: FileRow, actualRowIdx: number) => string;
+    headerRowIndex?: number;
+    includedColumns: number[];
+}
+export default function VirtualTable({ headers, rows, renderCell, rowHeight, overscan, stickyHeader, stickyFirstColumn, getRowClassName, headerRowIndex, includedColumns, }: VirtualTableProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/preact/importer/components/ui/alert.d.ts

@@ -0,0 +1,10 @@
+declare const Alert: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<any> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+declare const AlertTitle: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<JSX.HTMLAttributes<HTMLHeadingElement>> & {
+    ref?: import('preact').Ref<HTMLParagraphElement> | undefined;
+}>;
+declare const AlertDescription: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<JSX.HTMLAttributes<HTMLParagraphElement>> & {
+    ref?: import('preact').Ref<HTMLParagraphElement> | undefined;
+}>;
+export { Alert, AlertTitle, AlertDescription };

package/build/preact/importer/components/ui/button.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface ButtonProps extends JSX.HTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    isLoading?: boolean;
+}
+declare const Button: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<ButtonProps> & {
+    ref?: import('preact').Ref<HTMLButtonElement> | undefined;
+}>;
+export { Button, buttonVariants };

package/build/preact/importer/components/ui/card.d.ts

@@ -0,0 +1,19 @@
+declare const Card: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+declare const CardHeader: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+declare const CardTitle: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<JSX.HTMLAttributes<HTMLHeadingElement>> & {
+    ref?: import('preact').Ref<HTMLParagraphElement> | undefined;
+}>;
+declare const CardDescription: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<JSX.HTMLAttributes<HTMLParagraphElement>> & {
+    ref?: import('preact').Ref<HTMLParagraphElement> | undefined;
+}>;
+declare const CardContent: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+declare const CardFooter: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

package/build/preact/importer/components/ui/checkbox.d.ts

@@ -0,0 +1,7 @@
+export interface CheckboxProps extends JSX.HTMLAttributes<HTMLInputElement> {
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare const Checkbox: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<CheckboxProps> & {
+    ref?: import('preact').Ref<HTMLInputElement> | undefined;
+}>;
+export { Checkbox };

package/build/preact/importer/components/ui/dialog.d.ts

@@ -0,0 +1,38 @@
+import { h, ComponentChildren, JSX } from 'preact';
+interface DialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: ComponentChildren;
+}
+declare const Dialog: ({ open, onOpenChange, children }: DialogProps) => import("react/jsx-runtime").JSX.Element;
+declare const DialogTrigger: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<h.JSX.HTMLAttributes<HTMLButtonElement>> & {
+    ref?: import('preact').Ref<HTMLButtonElement> | undefined;
+}>;
+interface DialogContentProps extends JSX.HTMLAttributes<HTMLDialogElement> {
+    onClose?: () => void;
+}
+declare const DialogContent: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<DialogContentProps> & {
+    ref?: import('preact').Ref<HTMLDialogElement> | undefined;
+}>;
+declare const DialogHeader: {
+    ({ className, ...props }: JSX.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: JSX.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<h.JSX.HTMLAttributes<HTMLHeadingElement>> & {
+    ref?: import('preact').Ref<HTMLHeadingElement> | undefined;
+}>;
+declare const DialogDescription: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<h.JSX.HTMLAttributes<HTMLParagraphElement>> & {
+    ref?: import('preact').Ref<HTMLParagraphElement> | undefined;
+}>;
+declare const DialogPortal: ({ children }: {
+    children: ComponentChildren;
+}) => ComponentChildren;
+declare const DialogOverlay: () => null;
+declare const DialogClose: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<h.JSX.HTMLAttributes<HTMLButtonElement>> & {
+    ref?: import('preact').Ref<HTMLButtonElement> | undefined;
+}>;
+export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

package/build/preact/importer/components/ui/flex.d.ts

@@ -0,0 +1,23 @@
+interface FlexProps extends JSX.HTMLAttributes<HTMLDivElement> {
+    direction?: "row" | "column" | "row-reverse" | "column-reverse";
+    align?: "start" | "center" | "end" | "stretch" | "baseline";
+    justify?: "start" | "center" | "end" | "between" | "around" | "evenly";
+    wrap?: boolean;
+    gap?: number | string;
+}
+declare const Flex: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<FlexProps> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+declare const Box: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+declare const HStack: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<Omit<FlexProps, "direction">> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+declare const VStack: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<Omit<FlexProps, "direction">> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+declare const Text: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+export { Flex, Box, HStack, VStack, Text };

package/build/preact/importer/components/ui/input.d.ts

@@ -0,0 +1,6 @@
+export interface InputProps extends JSX.HTMLAttributes<HTMLInputElement> {
+}
+declare const Input: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<InputProps> & {
+    ref?: import('preact').Ref<HTMLInputElement> | undefined;
+}>;
+export { Input };

package/build/preact/importer/components/ui/select.d.ts

@@ -0,0 +1,13 @@
+interface SelectProps extends JSX.SelectHTMLAttributes<HTMLSelectElement> {
+    placeholder?: string;
+    options?: Array<{
+        value: string;
+        label: string;
+        disabled?: boolean;
+    }>;
+    onValueChange?: (value: string) => void;
+}
+declare const Select: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<SelectProps> & {
+    ref?: import('preact').Ref<HTMLSelectElement> | undefined;
+}>;
+export { Select };

package/build/preact/importer/components/ui/switch.d.ts

@@ -0,0 +1,7 @@
+export interface SwitchProps extends Omit<JSX.HTMLAttributes<HTMLInputElement>, 'type'> {
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare const Switch: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<SwitchProps> & {
+    ref?: import('preact').Ref<HTMLInputElement> | undefined;
+}>;
+export { Switch };

package/build/preact/importer/components/ui/toast.d.ts

@@ -0,0 +1,22 @@
+import { h, JSX } from 'preact';
+export interface ToastProps extends JSX.HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'destructive';
+    onClose?: () => void;
+}
+declare const Toast: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<ToastProps> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+declare const ToastAction: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<h.JSX.HTMLAttributes<HTMLButtonElement>> & {
+    ref?: import('preact').Ref<HTMLButtonElement> | undefined;
+}>;
+declare const ToastClose: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<h.JSX.HTMLAttributes<HTMLButtonElement>> & {
+    ref?: import('preact').Ref<HTMLButtonElement> | undefined;
+}>;
+declare const ToastTitle: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<h.JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+declare const ToastDescription: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<h.JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+type ToastActionElement = JSX.Element<typeof ToastAction>;
+export { Toast, ToastAction, ToastClose, ToastTitle, ToastDescription, type ToastActionElement, };

package/build/preact/importer/components/ui/toaster.d.ts

@@ -0,0 +1 @@
+export declare function Toaster(): import("react/jsx-runtime").JSX.Element;

package/build/preact/importer/components/ui/tooltip.d.ts

@@ -0,0 +1,20 @@
+import { ComponentChildren } from 'preact';
+interface TooltipProps {
+    content: ComponentChildren;
+    children: ComponentChildren;
+    delayDuration?: number;
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    className?: string;
+}
+declare const Tooltip: ({ content, children, delayDuration, side, className }: TooltipProps) => import("react/jsx-runtime").JSX.Element;
+declare const TooltipProvider: ({ children }: {
+    children: ComponentChildren;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const TooltipRoot: ({ content, children, delayDuration, side, className }: TooltipProps) => import("react/jsx-runtime").JSX.Element;
+declare const TooltipTrigger: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<any> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+declare const TooltipContent: import('preact').FunctionalComponent<import('preact/compat').PropsWithoutRef<any> & {
+    ref?: import('preact').Ref<HTMLDivElement> | undefined;
+}>;
+export { Tooltip, TooltipRoot, TooltipTrigger, TooltipContent, TooltipProvider };

package/build/preact/importer/components/ui/use-toast.d.ts

@@ -0,0 +1,46 @@
+import { ComponentChildren } from 'preact';
+import { ToastActionElement, ToastProps } from './toast';
+type ToasterToast = ToastProps & {
+    id: string;
+    title?: ComponentChildren;
+    description?: ComponentChildren;
+    action?: ToastActionElement;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+declare const actionTypes: {
+    readonly ADD_TOAST: "ADD_TOAST";
+    readonly UPDATE_TOAST: "UPDATE_TOAST";
+    readonly DISMISS_TOAST: "DISMISS_TOAST";
+    readonly REMOVE_TOAST: "REMOVE_TOAST";
+};
+type ActionType = typeof actionTypes;
+type Action = {
+    type: ActionType["ADD_TOAST"];
+    toast: ToasterToast;
+} | {
+    type: ActionType["UPDATE_TOAST"];
+    toast: Partial<ToasterToast>;
+} | {
+    type: ActionType["DISMISS_TOAST"];
+    toastId?: ToasterToast["id"];
+} | {
+    type: ActionType["REMOVE_TOAST"];
+    toastId?: ToasterToast["id"];
+};
+interface State {
+    toasts: ToasterToast[];
+}
+export declare const reducer: (state: State, action: Action) => State;
+type Toast = Omit<ToasterToast, "id">;
+declare function toast({ ...props }: Toast): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+    toasts: ToasterToast[];
+};
+export { useToast, toast };

package/build/preact/importer/features/complete/index.d.ts

@@ -0,0 +1,2 @@
+import { CompleteProps } from './types';
+export default function Complete({ reload, close, isModal }: CompleteProps): import("react/jsx-runtime").JSX.Element;

package/build/preact/importer/features/complete/types/index.d.ts

@@ -0,0 +1,5 @@
+export type CompleteProps = {
+    reload: () => void;
+    close: () => void;
+    isModal: boolean;
+};

package/build/preact/importer/features/configure-import/index.d.ts

@@ -0,0 +1,13 @@
+import { Column, ColumnMappingDictionary } from '../../../types';
+interface ConfigureImportProps {
+    columns?: Column[];
+    data: any;
+    onSuccess: (mapping: ColumnMappingDictionary, headerRow: number) => void;
+    onCancel?: () => void;
+    isSubmitting?: boolean;
+    importerKey?: string;
+    backendUrl?: string;
+    isDemoMode?: boolean;
+}
+export default function ConfigureImport({ columns, data, onSuccess, onCancel, isSubmitting, importerKey, backendUrl, isDemoMode, }: ConfigureImportProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/preact/importer/features/configure-import/types/index.d.ts

@@ -0,0 +1,13 @@
+import { Template } from '../../../types';
+import { ColumnMapping, ColumnMappingDictionary } from '../../../../types';
+export interface ConfigureImportProps {
+    template: Template;
+    data: any;
+    onSuccess: (mapping: ColumnMappingDictionary, headerRow: number) => void;
+    onCancel?: () => void;
+    isSubmitting?: boolean;
+    importerKey?: string;
+    backendUrl?: string;
+    isDemoMode?: boolean;
+}
+export type { ColumnMapping, ColumnMappingDictionary };

package/build/preact/importer/features/main/hooks/useMutableLocalStorage.d.ts

@@ -0,0 +1 @@
+export default function useMutableLocalStorage(key: string, initialValue: any): any[];

package/build/preact/importer/features/main/hooks/useStepNavigation.d.ts

@@ -0,0 +1,17 @@
+export declare const StepEnum: {
+    Upload: number;
+    RowSelection: number;
+    MapColumns: number;
+    Validation: number;
+    Complete: number;
+};
+declare function useStepNavigation(initialStep: number, skipHeader: boolean, isDemoMode?: boolean): {
+    currentStep: any;
+    setStep: (newStep: number) => void;
+    goBack: (backStep?: number) => void;
+    goNext: (nextStep?: number) => void;
+    stepper: import('../../../components/Stepper/types').StepperProps;
+    stepId: string | number | undefined;
+    setStorageStep: any;
+};
+export default useStepNavigation;

package/build/preact/importer/features/main/index.d.ts

@@ -0,0 +1,2 @@
+import { CSVImporterProps } from '../../../types';
+export default function Main(props: CSVImporterProps): import("react/jsx-runtime").JSX.Element;

package/build/preact/importer/features/main/types/index.d.ts

@@ -0,0 +1,16 @@
+export declare enum Steps {
+    Upload = "upload",
+    RowSelection = "row-selection",
+    MapColumns = "map-columns",
+    Validation = "validation"
+}
+export type FileRow = {
+    index: number;
+    values: string[];
+};
+export type FileData = {
+    fileName: string;
+    rows: FileRow[];
+    sheetList: string[];
+    errors: string[];
+};

package/build/preact/importer/features/map-columns/components/DropDownFields.d.ts

@@ -0,0 +1,21 @@
+import { InputOption } from '../../../components/Input/types';
+type DropdownFieldsProps = {
+    options: {
+        [key: string]: InputOption;
+    };
+    value: string;
+    placeholder: string;
+    onChange: (value: string) => void;
+    selectedValues: {
+        id?: string;
+        key?: string;
+        selected: boolean | undefined;
+    }[];
+    updateSelectedValues: (updatedValues: {
+        id?: string;
+        key?: string;
+        selected: boolean | undefined;
+    }[]) => void;
+};
+export default function DropdownFields({ options, value, placeholder, onChange, selectedValues, updateSelectedValues }: DropdownFieldsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/preact/importer/features/map-columns/hooks/useMapColumnsTable.d.ts

@@ -0,0 +1,16 @@
+import { UploadColumn } from '../../../types';
+import { Column } from '../../../../types';
+import { TemplateColumnMapping } from '../types';
+export default function useMapColumnsTable(uploadColumns: UploadColumn[], templateColumns: Column[] | undefined, columnsValues: {
+    [uploadColumnIndex: number]: TemplateColumnMapping;
+}, isLoading?: boolean, importerKey?: string, backendUrl?: string): {
+    rows: {
+        [x: string]: {
+            raw: string | boolean;
+            content: string | import("react/jsx-runtime").JSX.Element;
+        };
+    }[];
+    formValues: {
+        [key: number]: import('../types').ColumnMapping;
+    };
+};

package/build/preact/importer/features/map-columns/index.d.ts

@@ -0,0 +1,2 @@
+import { MapColumnsProps } from './types';
+export default function MapColumns({ columns, data, columnMapping, selectedHeaderRow, skipHeaderRowSelection, onSuccess, onCancel, isSubmitting, importerKey, backendUrl, }: MapColumnsProps): import("react/jsx-runtime").JSX.Element | null;

package/build/preact/importer/features/map-columns/types/index.d.ts

@@ -0,0 +1,16 @@
+import { Column, ColumnMapping, ColumnMappingDictionary } from '../../../../types';
+import { FileData } from '../../main/types';
+export type { ColumnMapping, ColumnMappingDictionary };
+export type TemplateColumnMapping = ColumnMapping;
+export type MapColumnsProps = {
+    columns?: Column[];
+    data: FileData;
+    columnMapping: ColumnMappingDictionary;
+    selectedHeaderRow: number | null;
+    skipHeaderRowSelection?: boolean;
+    onSuccess: (columnMapping: ColumnMappingDictionary) => void;
+    onCancel: () => void;
+    isSubmitting: boolean;
+    importerKey?: string;
+    backendUrl?: string;
+};

package/build/preact/importer/features/row-selection/index.d.ts

@@ -0,0 +1,2 @@
+import { RowSelectionProps } from './types';
+export default function RowSelection({ data, onSuccess, onCancel, selectedHeaderRow, setSelectedHeaderRow }: RowSelectionProps): import("react/jsx-runtime").JSX.Element;

package/build/preact/importer/features/row-selection/types/index.d.ts

@@ -0,0 +1,8 @@
+import { FileData } from '../../main/types';
+export type RowSelectionProps = {
+    data: FileData;
+    onSuccess: () => void;
+    onCancel: () => void;
+    selectedHeaderRow: number | null;
+    setSelectedHeaderRow: (id: number) => void;
+};

package/build/preact/importer/features/uploader/hooks/useTemplateTable.d.ts

@@ -0,0 +1,10 @@
+import { Column } from '../../../../types';
+export default function useTemplateTable(fields?: Column[]): {
+    [x: string]: string | {
+        raw: string;
+        content: import("react/jsx-runtime").JSX.Element;
+    } | {
+        raw: number;
+        content: import("react/jsx-runtime").JSX.Element;
+    };
+}[];

package/build/preact/importer/features/uploader/index.d.ts

@@ -0,0 +1,2 @@
+import { UploaderProps } from './types';
+export default function Uploader({ columns, skipHeaderRowSelection, onSuccess, showDownloadTemplateButton, setDataError }: UploaderProps): import("react/jsx-runtime").JSX.Element;

package/build/preact/importer/features/uploader/types/index.d.ts

@@ -0,0 +1,9 @@
+import { Column } from '../../../../types';
+import { Dispatch, SetStateAction } from 'preact/hooks';
+export type UploaderProps = {
+    columns?: Column[];
+    skipHeaderRowSelection: boolean;
+    onSuccess: (file: File) => void;
+    showDownloadTemplateButton?: boolean;
+    setDataError: Dispatch<SetStateAction<string | null>>;
+};

package/build/preact/importer/features/validation/Validation.d.ts

@@ -0,0 +1,2 @@
+import { ValidationProps } from './types';
+export default function Validation({ columns, data: fileData, columnMapping, selectedHeaderRow, onSuccess, onCancel, isSubmitting, backendUrl, importerKey, filterInvalidRows, disableOnInvalidRows, }: ValidationProps): import("react/jsx-runtime").JSX.Element;