@nxgt/material 1.0.0

package/dist/lib/components/ui/camera/state/camera.slice.d.ts

@@ -0,0 +1,148 @@
+import { ReducerCreators } from '@reduxjs/toolkit';
+import { CameraAlert, CameraState } from '../types';
+export declare const cameraSlice: import('@reduxjs/toolkit').Slice<CameraState, {
+    readonly setDevices: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: MediaDeviceInfo[];
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly selectDevice: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: string | null;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly setPermission: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly setStreaming: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly setAlert: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: CameraAlert | null;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly setCameraSupported: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly capturePhoto: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: HTMLVideoElement | null;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly requestPermission: import('@reduxjs/toolkit').AsyncThunkReducers<CameraState, void, {
+        hasPermission: boolean;
+        devices: never[];
+        cameraSupported: false;
+    } | {
+        hasPermission: boolean;
+        devices: import('../types').CameraDeviceInfo[];
+        cameraSupported: true;
+    }, {
+        rejectValue: {
+            message: string;
+        };
+        state?: undefined;
+        dispatch?: undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }> & {
+        options?: import('@reduxjs/toolkit').AsyncThunkOptions<void, {
+            rejectValue: {
+                message: string;
+            };
+            state?: undefined;
+            dispatch?: undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }> | undefined;
+    } & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.asyncThunk;
+    } & {
+        payloadCreator: import('@reduxjs/toolkit').AsyncThunkPayloadCreator<{
+            hasPermission: boolean;
+            devices: never[];
+            cameraSupported: false;
+        } | {
+            hasPermission: boolean;
+            devices: import('../types').CameraDeviceInfo[];
+            cameraSupported: true;
+        }, void, {
+            rejectValue: {
+                message: string;
+            };
+            state?: undefined;
+            dispatch?: undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+    };
+    readonly startStream: import('@reduxjs/toolkit').AsyncThunkReducers<CameraState, (stream: MediaStream) => void, void, {
+        rejectValue: {
+            message: string;
+        };
+        state?: undefined;
+        dispatch?: undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }> & {
+        options?: import('@reduxjs/toolkit').AsyncThunkOptions<(stream: MediaStream) => void, {
+            rejectValue: {
+                message: string;
+            };
+            state?: undefined;
+            dispatch?: undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }> | undefined;
+    } & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.asyncThunk;
+    } & {
+        payloadCreator: import('@reduxjs/toolkit').AsyncThunkPayloadCreator<void, (stream: MediaStream) => void, {
+            rejectValue: {
+                message: string;
+            };
+            state?: undefined;
+            dispatch?: undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+    };
+}, "camera", "camera", import('@reduxjs/toolkit').SliceSelectors<CameraState>>;
+type CameraSliceActions = typeof cameraSlice.actions;
+export type CameraActions = {
+    [K in keyof CameraSliceActions]: (...args: Parameters<CameraSliceActions[K]>) => void;
+};
+export type CameraReducerCreators = ReducerCreators<CameraState>;
+export {};

package/dist/lib/components/ui/camera/state/camera.slice.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/components/ui/camera/state/camera.store.d.ts

@@ -0,0 +1,145 @@
+import { CameraState } from '../types';
+export declare const store: import('@reduxjs/toolkit').EnhancedStore<CameraState, import('redux').UnknownAction, import('@reduxjs/toolkit').Tuple<[import('redux').StoreEnhancer<{
+    dispatch: import('redux-thunk').ThunkDispatch<CameraState, undefined, import('redux').UnknownAction>;
+}>, import('redux').StoreEnhancer]>>;
+export declare const useCameraActions: () => import('@reduxjs/toolkit').CaseReducerActions<{
+    readonly setDevices: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: MediaDeviceInfo[];
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly selectDevice: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: string | null;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly setPermission: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly setStreaming: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly setAlert: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: import('../types').CameraAlert | null;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly setCameraSupported: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly capturePhoto: import('@reduxjs/toolkit').CaseReducer<CameraState, {
+        payload: HTMLVideoElement | null;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    readonly requestPermission: import('@reduxjs/toolkit').AsyncThunkReducers<CameraState, void, {
+        hasPermission: boolean;
+        devices: never[];
+        cameraSupported: false;
+    } | {
+        hasPermission: boolean;
+        devices: import('../types').CameraDeviceInfo[];
+        cameraSupported: true;
+    }, {
+        rejectValue: {
+            message: string;
+        };
+        state?: undefined;
+        dispatch?: undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }> & {
+        options?: import('@reduxjs/toolkit').AsyncThunkOptions<void, {
+            rejectValue: {
+                message: string;
+            };
+            state?: undefined;
+            dispatch?: undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }> | undefined;
+    } & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.asyncThunk;
+    } & {
+        payloadCreator: import('@reduxjs/toolkit').AsyncThunkPayloadCreator<{
+            hasPermission: boolean;
+            devices: never[];
+            cameraSupported: false;
+        } | {
+            hasPermission: boolean;
+            devices: import('../types').CameraDeviceInfo[];
+            cameraSupported: true;
+        }, void, {
+            rejectValue: {
+                message: string;
+            };
+            state?: undefined;
+            dispatch?: undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+    };
+    readonly startStream: import('@reduxjs/toolkit').AsyncThunkReducers<CameraState, (stream: MediaStream) => void, void, {
+        rejectValue: {
+            message: string;
+        };
+        state?: undefined;
+        dispatch?: undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }> & {
+        options?: import('@reduxjs/toolkit').AsyncThunkOptions<(stream: MediaStream) => void, {
+            rejectValue: {
+                message: string;
+            };
+            state?: undefined;
+            dispatch?: undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }> | undefined;
+    } & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.asyncThunk;
+    } & {
+        payloadCreator: import('@reduxjs/toolkit').AsyncThunkPayloadCreator<void, (stream: MediaStream) => void, {
+            rejectValue: {
+                message: string;
+            };
+            state?: undefined;
+            dispatch?: undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+    };
+}, "camera">;
+export declare const useCameraSelector: import('react-redux').UseSelector<CameraState>;

package/dist/lib/components/ui/camera/state/camera.thunks.d.ts

@@ -0,0 +1,97 @@
+import { CameraReducerCreators } from './camera.slice';
+export declare const createRequestPermissionThunk: (create: CameraReducerCreators) => import('@reduxjs/toolkit').AsyncThunkReducers<import('../types').CameraState, void, {
+    hasPermission: boolean;
+    devices: never[];
+    cameraSupported: false;
+} | {
+    hasPermission: boolean;
+    devices: import('../types').CameraDeviceInfo[];
+    cameraSupported: true;
+}, {
+    rejectValue: {
+        message: string;
+    };
+    state?: undefined;
+    dispatch?: undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}> & {
+    options?: import('@reduxjs/toolkit').AsyncThunkOptions<void, {
+        rejectValue: {
+            message: string;
+        };
+        state?: undefined;
+        dispatch?: undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }> | undefined;
+} & {
+    _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.asyncThunk;
+} & {
+    payloadCreator: import('@reduxjs/toolkit').AsyncThunkPayloadCreator<{
+        hasPermission: boolean;
+        devices: never[];
+        cameraSupported: false;
+    } | {
+        hasPermission: boolean;
+        devices: import('../types').CameraDeviceInfo[];
+        cameraSupported: true;
+    }, void, {
+        rejectValue: {
+            message: string;
+        };
+        state?: undefined;
+        dispatch?: undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+};
+export declare const createStartStreamThunk: (create: CameraReducerCreators) => import('@reduxjs/toolkit').AsyncThunkReducers<import('../types').CameraState, (stream: MediaStream) => void, void, {
+    rejectValue: {
+        message: string;
+    };
+    state?: undefined;
+    dispatch?: undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}> & {
+    options?: import('@reduxjs/toolkit').AsyncThunkOptions<(stream: MediaStream) => void, {
+        rejectValue: {
+            message: string;
+        };
+        state?: undefined;
+        dispatch?: undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }> | undefined;
+} & {
+    _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.asyncThunk;
+} & {
+    payloadCreator: import('@reduxjs/toolkit').AsyncThunkPayloadCreator<void, (stream: MediaStream) => void, {
+        rejectValue: {
+            message: string;
+        };
+        state?: undefined;
+        dispatch?: undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+};

package/dist/lib/components/ui/camera/state/camera.thunks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/components/ui/camera/state/index.d.ts

@@ -0,0 +1,2 @@
+export * from './camera.slice';
+export * from './camera.store';

package/dist/lib/components/ui/camera/types.d.ts

@@ -0,0 +1,38 @@
+import { CameraActions } from './state';
+export type ImageFormat = 'png' | 'jpeg' | 'webp';
+export type CaptureSettings = {
+    resolution: {
+        width: number;
+        height: number;
+    };
+    quality: number;
+    format: ImageFormat;
+    mirror: boolean;
+};
+export type CameraAlert = {
+    message: string;
+    type: 'success' | 'warn' | 'error' | 'info';
+};
+export type CameraDeviceInfo = Pick<MediaDeviceInfo, 'deviceId' | 'label' | 'groupId'>;
+export type CameraState = {
+    devices: CameraDeviceInfo[];
+    selectedDeviceId: string | null;
+    hasPermission: boolean;
+    isStreaming: boolean;
+    isProcessing: boolean;
+    cameraSupported: boolean;
+    capturedImage: string | null;
+    captureSettings: CaptureSettings;
+    alert: CameraAlert | null;
+};
+export type CameraContextValue = {
+    videoRef: React.RefObject<HTMLVideoElement | null>;
+    canvasRef: React.RefObject<HTMLCanvasElement | null>;
+    streamRef: React.RefObject<MediaStream | null>;
+    state: CameraState;
+    actions: Omit<CameraActions, 'startStream' | 'capturePhoto'> & {
+        capturePhoto: () => void;
+        startStream: () => void;
+        stopStream: () => void;
+    };
+};

package/dist/lib/components/ui/camera/use-camera.d.ts

@@ -0,0 +1,11 @@
+export declare function useCamera(): {
+    videoRef: import('react').RefObject<HTMLVideoElement | null>;
+    canvasRef: import('react').RefObject<HTMLCanvasElement | null>;
+    streamRef: import('react').RefObject<MediaStream | null>;
+    state: import('./types').CameraState;
+    actions: Omit<import('./state').CameraActions, "capturePhoto" | "startStream"> & {
+        capturePhoto: () => void;
+        startStream: () => void;
+        stopStream: () => void;
+    };
+};

package/dist/lib/components/ui/camera/utils/camera.utils.d.ts

@@ -0,0 +1,14 @@
+import { CameraDeviceInfo } from '../types';
+export * from './camera.utils';
+/**
+ * Get available camera devices
+ */
+export declare function getCameraDevices(): Promise<CameraDeviceInfo[]>;
+/**
+ * Request camera permissions
+ */
+export declare function requestCameraPermissions(): Promise<boolean>;
+/**
+ * Check if camera is supported
+ */
+export declare function isCameraSupported(): boolean;

package/dist/lib/components/ui/camera/utils/camera.utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/components/ui/camera/utils/index.d.ts

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

package/dist/lib/components/ui/card.d.ts

@@ -0,0 +1,9 @@
+import { ComponentProps } from 'react';
+declare function Card({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+declare function CardHeader({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+declare function CardTitle({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+declare function CardDescription({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+declare function CardAction({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+declare function CardContent({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+declare function CardFooter({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+export { Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, };

package/dist/lib/components/ui/card.stories.d.ts

@@ -0,0 +1,14 @@
+import { StoryObj } from '@storybook/react';
+import { Card } from '..';
+declare const meta: {
+    title: string;
+    component: typeof Card;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    argTypes: {};
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;

package/dist/lib/components/ui/carousel.d.ts

@@ -0,0 +1,19 @@
+import { default as useEmblaCarousel, UseEmblaCarouselType } from 'embla-carousel-react';
+import { ComponentProps } from 'react';
+import { Button } from './buttons/button';
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: 'horizontal' | 'vertical';
+    setApi?: (api: CarouselApi) => void;
+};
+declare function Carousel({ orientation, opts, setApi, plugins, className, children, ...props }: ComponentProps<'div'> & CarouselProps): import("react").JSX.Element;
+declare function CarouselContent({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+declare function CarouselItem({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+declare function CarouselPrevious({ className, variant, ...props }: ComponentProps<typeof Button>): import("react").JSX.Element;
+declare function CarouselNext({ className, variant, ...props }: ComponentProps<typeof Button>): import("react").JSX.Element;
+export { Carousel, type CarouselApi, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, };

package/dist/lib/components/ui/carousel.stories.d.ts

@@ -0,0 +1,14 @@
+import { StoryObj } from '@storybook/react';
+import { Carousel } from '..';
+declare const meta: {
+    title: string;
+    component: typeof Carousel;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    argTypes: {};
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;

package/dist/lib/components/ui/charts/area-chart.d.ts

@@ -0,0 +1,5 @@
+import { LineSeries } from '@nivo/line';
+import { LineChartProps } from './line-chart';
+export type AreaChartProps<Series extends LineSeries = LineSeries> = LineChartProps<Series>;
+/** A `LineChart` preset with the area fill enabled by default. */
+export declare function AreaChart<Series extends LineSeries = LineSeries>({ enableArea, curve, ...props }: AreaChartProps<Series>): import("react").JSX.Element;

package/dist/lib/components/ui/charts/area-chart.stories.d.ts

@@ -0,0 +1,17 @@
+import { StoryObj } from '@storybook/react';
+import { AreaChart } from '../..';
+declare const meta: {
+    title: string;
+    component: typeof AreaChart;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    argTypes: {};
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;
+export declare const Loading: Story;
+export declare const Empty: Story;
+export declare const Dark: Story;

package/dist/lib/components/ui/charts/bar-chart.d.ts

@@ -0,0 +1,7 @@
+import { BarDatum, ResponsiveBarSvgProps } from '@nivo/bar';
+import { ChartContainerProps } from './chart-container';
+export type BarChartProps<D extends BarDatum = BarDatum> = ResponsiveBarSvgProps<D> & Pick<ChartContainerProps, 'className' | 'height' | 'loading' | 'emptyState'> & {
+    empty?: boolean;
+};
+export declare function BarChart<D extends BarDatum = BarDatum>({ className, height, loading, empty, emptyState, colors, theme, ...props }: BarChartProps<D>): import("react").JSX.Element;
+export type { BarDatum };

package/dist/lib/components/ui/charts/bar-chart.stories.d.ts

@@ -0,0 +1,17 @@
+import { StoryObj } from '@storybook/react';
+import { BarChart } from '../..';
+declare const meta: {
+    title: string;
+    component: typeof BarChart;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    argTypes: {};
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;
+export declare const Loading: Story;
+export declare const Empty: Story;
+export declare const Dark: Story;

package/dist/lib/components/ui/charts/chart-container.d.ts

@@ -0,0 +1,10 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface ChartContainerProps {
+    className?: string;
+    height?: CSSProperties['height'];
+    loading?: boolean;
+    empty?: boolean;
+    emptyState?: ReactNode;
+    children: ReactNode;
+}
+export declare function ChartContainer({ className, height, loading, empty, emptyState, children, }: ChartContainerProps): import("react").JSX.Element;

package/dist/lib/components/ui/charts/funnel-chart.d.ts

@@ -0,0 +1,7 @@
+import { ResponsiveProps } from '@nivo/core';
+import { FunnelDatum, FunnelSvgProps } from '@nivo/funnel';
+import { ChartContainerProps } from './chart-container';
+export type FunnelChartProps<D extends FunnelDatum = FunnelDatum> = ResponsiveProps<FunnelSvgProps<D>> & Pick<ChartContainerProps, 'className' | 'height' | 'loading' | 'emptyState'> & {
+    empty?: boolean;
+};
+export declare function FunnelChart<D extends FunnelDatum = FunnelDatum>({ className, height, loading, empty, emptyState, colors, theme, ...props }: FunnelChartProps<D>): import("react").JSX.Element;

package/dist/lib/components/ui/charts/funnel-chart.stories.d.ts

@@ -0,0 +1,17 @@
+import { StoryObj } from '@storybook/react';
+import { FunnelChart } from '../..';
+declare const meta: {
+    title: string;
+    component: typeof FunnelChart;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    argTypes: {};
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;
+export declare const Loading: Story;
+export declare const Empty: Story;
+export declare const Dark: Story;

package/dist/lib/components/ui/charts/heatmap-chart.d.ts

@@ -0,0 +1,13 @@
+import { ResponsiveProps } from '@nivo/core';
+import { DefaultHeatMapDatum, HeatMapDatum, HeatMapSvgProps } from '@nivo/heatmap';
+import { ChartContainerProps } from './chart-container';
+export type HeatmapChartProps<Datum extends HeatMapDatum = DefaultHeatMapDatum, ExtraProps extends object = Record<string, never>> = ResponsiveProps<HeatMapSvgProps<Datum, ExtraProps>> & Pick<ChartContainerProps, 'className' | 'height' | 'loading' | 'emptyState'> & {
+    empty?: boolean;
+};
+/**
+ * `colors` is intentionally left to nivo's own default (a sequential
+ * gradient) rather than defaulted from `useChartTheme` — that hook exposes
+ * a 5-color categorical palette, which doesn't map to heatmap's continuous
+ * color scale. Only `theme` (axis/grid/tooltip) is applied automatically.
+ */
+export declare function HeatmapChart<Datum extends HeatMapDatum = DefaultHeatMapDatum, ExtraProps extends object = Record<string, never>>({ className, height, loading, empty, emptyState, theme, ...props }: HeatmapChartProps<Datum, ExtraProps>): import("react").JSX.Element;

package/dist/lib/components/ui/charts/heatmap-chart.stories.d.ts

@@ -0,0 +1,17 @@
+import { StoryObj } from '@storybook/react';
+import { HeatmapChart } from '../..';
+declare const meta: {
+    title: string;
+    component: typeof HeatmapChart;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    argTypes: {};
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;
+export declare const Loading: Story;
+export declare const Empty: Story;
+export declare const Dark: Story;