@nxgt/material 1.0.0

package/dist/lib/components/ui/stx-player/stx-player.slice.d.ts

@@ -0,0 +1,226 @@
+import { StxPlayerState, StxTrack } from './types';
+export declare const createInitialState: (overrides?: Partial<StxPlayerState>) => StxPlayerState;
+export declare const stxPlayerSlice: import('@reduxjs/toolkit').Slice<StxPlayerState, {
+    setQueue: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: StxTrack[];
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setIndex: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: number;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    playNext: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: void;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    playPrev: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: void;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setPlaying: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setDuration: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: number;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setVolume: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: number;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setMuted: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    toggleMuted: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: void;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setPlaybackRate: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: number;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setStatus: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: import('./types').StxPlayerStatus;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setError: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: string | null;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setFullscreen: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setPip: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setCaptions: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: {
+            enabled: boolean;
+            lang?: string | null;
+        };
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setLoop: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    toggleLoop: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: void;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+}, "stx-player", "stx-player", import('@reduxjs/toolkit').SliceSelectors<StxPlayerState>>;
+export declare const stxPlayerActions: import('@reduxjs/toolkit').CaseReducerActions<{
+    setQueue: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: StxTrack[];
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setIndex: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: number;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    playNext: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: void;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    playPrev: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: void;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setPlaying: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setDuration: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: number;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setVolume: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: number;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setMuted: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    toggleMuted: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: void;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setPlaybackRate: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: number;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setStatus: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: import('./types').StxPlayerStatus;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setError: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: string | null;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setFullscreen: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setPip: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setCaptions: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: {
+            enabled: boolean;
+            lang?: string | null;
+        };
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    setLoop: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: boolean;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+    toggleLoop: import('@reduxjs/toolkit').CaseReducer<StxPlayerState, {
+        payload: void;
+        type: string;
+    }> & {
+        _reducerDefinitionType: import("@reduxjs/toolkit").ReducerType.reducer;
+    };
+}, "stx-player">;
+export type StxPlayerSliceActions = {
+    [K in keyof typeof stxPlayerActions]: (...args: Parameters<(typeof stxPlayerActions)[K]>) => void;
+};
+export declare function bindStxPlayerSlice(dispatch: (action: any) => void): StxPlayerSliceActions;
+export declare const stxPlayerSelectors: {
+    selectCurrentTrack: (state: StxPlayerState) => StxTrack | undefined;
+    selectCanNext: (state: StxPlayerState) => boolean;
+    selectCanPrev: (state: StxPlayerState) => boolean;
+    selectHasCaptions: (state: StxPlayerState) => boolean;
+};

package/dist/lib/components/ui/stx-player/stx-player.slice.test.d.ts

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

package/dist/lib/components/ui/stx-player/stx-player.stories.d.ts

@@ -0,0 +1,24 @@
+import { StoryObj } from '@storybook/react';
+import { StxPlayer, StxTrack } from '../..';
+declare const meta: {
+    title: string;
+    component: typeof StxPlayer;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    args: {
+        tracks: StxTrack[];
+        showQueue: true;
+        loop: false;
+        autoPlay: false;
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Video: Story;
+export declare const Audio: Story;
+export declare const Playlist: Story;
+export declare const Mini: Story;
+export declare const ErrorState: Story;
+export declare const Dark: Story;

package/dist/lib/components/ui/stx-player/types.d.ts

@@ -0,0 +1,82 @@
+import { ComponentProps, ReactNode, RefObject } from 'react';
+export type StxMediaKind = 'video' | 'audio';
+export type StxCaptionTrack = {
+    src: string;
+    label: string;
+    srclang: string;
+    default?: boolean;
+};
+export type StxTrack = {
+    id: string;
+    src: string;
+    kind: StxMediaKind;
+    title: string;
+    artist?: string;
+    album?: string;
+    artwork?: string;
+    captions?: StxCaptionTrack[];
+};
+export type StxPlayerStatus = 'idle' | 'loading' | 'ready' | 'buffering' | 'error';
+export type StxPlayerLayout = 'full' | 'mini';
+export type StxPlayerState = {
+    queue: StxTrack[];
+    currentIndex: number;
+    isPlaying: boolean;
+    duration: number;
+    volume: number;
+    muted: boolean;
+    playbackRate: number;
+    status: StxPlayerStatus;
+    error: string | null;
+    isFullscreen: boolean;
+    isPip: boolean;
+    captionsEnabled: boolean;
+    captionLang: string | null;
+    loop: boolean;
+};
+export type StxPlayerActions = {
+    setQueue: (tracks: StxTrack[]) => void;
+    setIndex: (index: number) => void;
+    playNext: () => void;
+    playPrev: () => void;
+    togglePlay: () => void;
+    seek: (time: number) => void;
+    seekBy: (delta: number) => void;
+    setVolume: (volume: number) => void;
+    toggleMute: () => void;
+    setPlaybackRate: (rate: number) => void;
+    toggleFullscreen: () => void;
+    togglePip: () => void;
+    toggleCaptions: (lang?: string | null) => void;
+    toggleLoop: () => void;
+    retry: () => void;
+};
+export type StxPlayerContextValue = {
+    mediaRef: RefObject<HTMLVideoElement | null>;
+    setMediaNode: (node: HTMLVideoElement | null) => void;
+    containerRef: RefObject<HTMLDivElement | null>;
+    state: StxPlayerState;
+    actions: StxPlayerActions;
+    current: StxTrack | undefined;
+    canNext: boolean;
+    canPrev: boolean;
+};
+export type StxPlayerProviderProps = {
+    tracks: StxTrack[];
+    currentIndex?: number;
+    defaultIndex?: number;
+    autoPlay?: boolean;
+    loop?: boolean;
+    onTrackChange?: (index: number, track: StxTrack) => void;
+    children: ReactNode;
+};
+export type StxPlayerProps = {
+    tracks: StxTrack[];
+    currentIndex?: number;
+    defaultIndex?: number;
+    autoPlay?: boolean;
+    loop?: boolean;
+    layout?: StxPlayerLayout;
+    showQueue?: boolean;
+    onTrackChange?: (index: number, track: StxTrack) => void;
+} & Omit<ComponentProps<'div'>, 'children'>;

package/dist/lib/components/ui/stx-player/use-media-bindings.d.ts

@@ -0,0 +1,20 @@
+import { RefObject } from 'react';
+import { StxPlayerSliceActions } from './stx-player.slice';
+import { StxPlayerState, StxTrack } from './types';
+type Bindings = {
+    mediaRef: RefObject<HTMLVideoElement | null>;
+    containerRef: RefObject<HTMLDivElement | null>;
+    hasMedia: boolean;
+    state: StxPlayerState;
+    sliceActions: StxPlayerSliceActions;
+    autoPlay: boolean;
+    onTrackChange?: (index: number, track: StxTrack) => void;
+    togglePlay: () => void;
+    playNext: () => void;
+    playPrev: () => void;
+    seekBy: (delta: number) => void;
+    toggleFullscreen: () => void;
+    togglePip: () => void;
+};
+export declare function useMediaBindings({ mediaRef, containerRef, hasMedia, state, sliceActions, autoPlay, onTrackChange, togglePlay, playNext, playPrev, seekBy, toggleFullscreen, togglePip, }: Bindings): void;
+export {};

package/dist/lib/components/ui/stx-player/use-media-events.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+import { StxPlayerSliceActions } from './stx-player.slice';
+export declare function useMediaEvents({ mediaRef, hasMedia, sliceActions, queueLength, currentIndex, loopRef, playNext, }: {
+    mediaRef: RefObject<HTMLVideoElement | null>;
+    hasMedia: boolean;
+    sliceActions: StxPlayerSliceActions;
+    queueLength: number;
+    currentIndex: number;
+    loopRef: RefObject<boolean>;
+    playNext: () => void;
+}): void;

package/dist/lib/components/ui/stx-player/use-player-shell.d.ts

@@ -0,0 +1,20 @@
+import { RefObject } from 'react';
+import { StxPlayerSliceActions } from './stx-player.slice';
+import { StxPlayerKeyNav } from './stx-player-keyboard';
+import { StxTrack } from './types';
+export declare function useDisplayBindings({ mediaRef, containerRef, sliceActions, }: {
+    mediaRef: RefObject<HTMLVideoElement | null>;
+    containerRef: RefObject<HTMLDivElement | null>;
+    sliceActions: StxPlayerSliceActions;
+}): void;
+export declare function useKeyboardBindings({ containerRef, togglePlay, playNext, playPrev, seekBy, toggleFullscreen, togglePip, toggleMute, adjustVolume, toggleCaptions, toggleLoop, }: {
+    containerRef: RefObject<HTMLDivElement | null>;
+} & StxPlayerKeyNav): void;
+export declare function useMediaSession({ current, togglePlay, playNext, playPrev, seekBy, isPlaying, }: {
+    current: StxTrack | undefined;
+    togglePlay: () => void;
+    playNext: () => void;
+    playPrev: () => void;
+    seekBy: (delta: number) => void;
+    isPlaying: boolean;
+}): void;

package/dist/lib/components/ui/stx-player/use-stx-player.d.ts

@@ -0,0 +1,4 @@
+import { StxPlayerContextValue, StxPlayerProviderProps } from './types';
+type Options = Omit<StxPlayerProviderProps, 'children'>;
+export declare function useStxPlayer({ tracks, currentIndex, defaultIndex, autoPlay, loop, onTrackChange, }: Options): StxPlayerContextValue;
+export {};

package/dist/lib/components/ui/summary-data.d.ts

@@ -0,0 +1,10 @@
+export type SummaryDataProps = {
+    leading?: React.ReactNode;
+    data?: {
+        label: string;
+        value?: React.ReactNode;
+    }[];
+    inline?: boolean;
+    showEmpty?: boolean;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, 'title'>;
+export declare function SummaryData({ color, leading, data, className, inline, children, showEmpty, ...props }: SummaryDataProps): import("react").JSX.Element;

package/dist/lib/components/ui/summary-data.stories.d.ts

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

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

@@ -0,0 +1,9 @@
+import { Switch as SwitchPrimitive } from 'radix-ui';
+import { ComponentProps, ReactNode } from 'react';
+export type SwitchProps = {
+    label?: ReactNode;
+    error?: boolean;
+    helperText?: ReactNode;
+    placeholder?: ReactNode;
+} & ComponentProps<typeof SwitchPrimitive.Root>;
+export declare function Switch({ error, helperText, label, placeholder, className, ...props }: SwitchProps): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,15 @@
+import { ComponentProps, ReactNode } from 'react';
+import { DropdownMenuTrigger } from './dropdown-menu';
+export type SwitcherItem = {
+    id: string;
+    icon?: ReactNode;
+    title: string;
+    subtitle?: string;
+};
+export type SwitcherProps = {
+    options: SwitcherItem[];
+    label: ReactNode;
+    value: string;
+    onValueChange?: (value: string) => void;
+} & Omit<ComponentProps<typeof DropdownMenuTrigger>, 'value'>;
+export declare function Switcher({ value, onValueChange, options, label, className, ...props }: SwitcherProps): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,10 @@
+import { ComponentProps } from 'react';
+declare function Table({ className, ...props }: ComponentProps<'table'>): import("react").JSX.Element;
+declare function TableHeader({ className, ...props }: ComponentProps<'thead'>): import("react").JSX.Element;
+declare function TableBody({ className, ...props }: ComponentProps<'tbody'>): import("react").JSX.Element;
+declare function TableFooter({ className, ...props }: ComponentProps<'tfoot'>): import("react").JSX.Element;
+declare function TableRow({ className, ...props }: ComponentProps<'tr'>): import("react").JSX.Element;
+declare function TableHead({ className, ...props }: ComponentProps<'th'>): import("react").JSX.Element;
+declare function TableCell({ className, ...props }: ComponentProps<'td'>): import("react").JSX.Element;
+declare function TableCaption({ className, ...props }: ComponentProps<'caption'>): import("react").JSX.Element;
+export { Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, };

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

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

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

@@ -0,0 +1,9 @@
+import { Tabs as TabsPrimitive } from 'radix-ui';
+import { ComponentProps, ReactNode } from 'react';
+declare function Tabs({ className, ...props }: ComponentProps<typeof TabsPrimitive.Root>): import("react").JSX.Element;
+declare function TabsList({ className, ...props }: ComponentProps<typeof TabsPrimitive.List>): import("react").JSX.Element;
+declare function TabsTrigger({ className, children, icon, ...props }: {
+    icon?: ReactNode;
+} & ComponentProps<typeof TabsPrimitive.Trigger>): import("react").JSX.Element;
+declare function TabsContent({ className, ...props }: ComponentProps<typeof TabsPrimitive.Content>): import("react").JSX.Element;
+export { Tabs, TabsContent, TabsList, TabsTrigger };

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

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

package/dist/lib/components/ui/text-field.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { InputProps } from './input';
+export type TextFieldProps = {
+    label?: ReactNode;
+    helperText?: ReactNode;
+    leading?: ReactNode;
+    trailing?: ReactNode;
+    error?: boolean;
+} & InputProps;
+export declare function TextField({ error, helperText, label, className, leading, trailing, ...props }: TextFieldProps): import("react").JSX.Element;

package/dist/lib/components/ui/text-field.stories.d.ts

@@ -0,0 +1,22 @@
+import { StoryObj } from '@storybook/react';
+import { TextField } from '..';
+declare const meta: {
+    title: string;
+    component: typeof TextField;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    argTypes: {
+        error: {
+            control: "boolean";
+        };
+        disabled: {
+            control: "boolean";
+        };
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;
+export declare const Dark: Story;

package/dist/lib/components/ui/textarea-field.d.ts

@@ -0,0 +1,10 @@
+import { ComponentProps, ReactNode } from 'react';
+export type TextareaProps = {
+    label?: ReactNode;
+    helperText?: ReactNode;
+    error?: boolean;
+    minRows?: number;
+    maxRows?: number;
+    showCount?: boolean;
+} & ComponentProps<'textarea'>;
+export declare function TextareaField({ error, helperText, label, className, placeholder, minRows, maxRows, showCount, maxLength, value, defaultValue, onChange, ...props }: TextareaProps): import("react").JSX.Element;

package/dist/lib/components/ui/textarea-field.stories.d.ts

@@ -0,0 +1,25 @@
+import { StoryObj } from '@storybook/react';
+import { TextareaField } from '..';
+declare const meta: {
+    title: string;
+    component: typeof TextareaField;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    argTypes: {
+        error: {
+            control: "boolean";
+        };
+        disabled: {
+            control: "boolean";
+        };
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;
+export declare const Counter: Story;
+export declare const Autosize: Story;
+export declare const ErrorState: Story;
+export declare const Dark: Story;

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

@@ -0,0 +1,3 @@
+import type * as React from 'react';
+declare function Textarea({ className, ...props }: React.ComponentProps<'textarea'>): React.JSX.Element;
+export { Textarea };

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

@@ -0,0 +1,26 @@
+import { StoryObj } from '@storybook/react';
+import { Textarea } from '..';
+declare const meta: {
+    title: string;
+    component: typeof Textarea;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    argTypes: {
+        disabled: {
+            control: "boolean";
+        };
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;
+export declare const WithValue: Story;
+export declare const WithPlaceholder: Story;
+export declare const Disabled: Story;
+export declare const WithError: Story;
+export declare const ReadOnly: Story;
+export declare const Dark: Story;
+export declare const DarkWithValue: Story;
+export declare const DarkError: Story;

package/dist/lib/components/ui/theme-toggle.d.ts

@@ -0,0 +1,6 @@
+import { ThemePreference } from '../../hooks/resolve-theme';
+export type ThemeToggleProps = {
+    className?: string;
+};
+export declare function ThemeToggle({ className }: ThemeToggleProps): import("react").JSX.Element;
+export type { ThemePreference };

package/dist/lib/components/ui/theme-toggle.stories.d.ts

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