@peripheries/core 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peripheries/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "The shared core lineage: layout, the document kit and the display cells, on the semantic tokens",
   "type": "module",
   "license": "UNLICENSED",

package/types/core/Accordion/Accordion.d.ts

@@ -0,0 +1,17 @@
+import { type CSSProperties, type ReactNode } from 'react';
+export type AccordionItem = {
+    id?: string;
+    question: string;
+    answer: string;
+    open?: boolean;
+};
+export interface AccordionProps {
+    items?: AccordionItem[];
+    children?: ReactNode;
+    numbered?: boolean;
+    single?: boolean;
+    rules?: 'strong' | 'subtle';
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Accordion({ items, children, numbered, single, rules, className, ...rest }: AccordionProps): import("react").JSX.Element;

package/types/core/Card/Card.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode, CSSProperties } from 'react';
+export type CardTone = 'plain' | 'raised' | 'sunken';
+export interface CardProps {
+    media?: ReactNode;
+    header?: ReactNode;
+    body?: ReactNode;
+    footer?: ReactNode;
+    children?: ReactNode;
+    tone?: CardTone;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Card({ media, header, body, footer, children, tone, className, ...rest }: CardProps): import("react").JSX.Element;

package/types/core/Columns/Columns.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode, CSSProperties } from 'react';
+export type ColumnsRatio = '1:1' | '2:1' | '1:2' | '3:1' | '1:3';
+export interface ColumnsProps {
+    start?: ReactNode;
+    end?: ReactNode;
+    children?: ReactNode;
+    ratio?: ColumnsRatio | string;
+    gap?: number | string;
+    stackBelow?: 'narrow' | 'compact';
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Columns({ start, end, children, ratio, gap, stackBelow, className, ...rest }: ColumnsProps): import("react").JSX.Element;
+export declare const Split: typeof Columns;

package/types/core/Disclosure/Disclosure.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode, CSSProperties } from 'react';
+export interface DisclosureProps {
+    summary?: ReactNode;
+    content?: ReactNode;
+    children?: ReactNode;
+    open?: boolean;
+    onToggle?: (open: boolean) => void;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Disclosure({ summary, content, children, open, onToggle, className, ...rest }: DisclosureProps): import("react").JSX.Element;

package/types/core/Grid/Grid.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode, type CSSProperties } from 'react';
+export interface GridProps {
+    items?: ReactNode;
+    children?: ReactNode;
+    min?: number | string;
+    columns?: number;
+    gap?: number | string;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Grid({ items, children, min, columns, gap, className, style, ...rest }: GridProps): import("react").JSX.Element;

package/types/core/Repeat/Repeat.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode, type CSSProperties } from 'react';
+export type RepeatLayout = 'stack' | 'inline' | 'grid';
+export interface RepeatProps {
+    item?: ReactNode;
+    each?: unknown;
+    as?: string;
+    layout?: RepeatLayout;
+    gap?: number | string;
+    min?: number | string;
+    empty?: string;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Repeat({ item, each: _each, as: _as, layout, gap, min, empty, className, style, ...rest }: RepeatProps): import("react").JSX.Element | null;

package/types/core/actions/Button/Button.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode, CSSProperties } from 'react';
+import { type PressProps } from '../_shared/press';
+export type ButtonVariant = 'primary' | 'secondary' | 'ghost';
+export type ButtonSize = 'sm' | 'md' | 'lg';
+export type ButtonTone = 'neutral' | 'danger';
+export interface ButtonProps extends PressProps {
+    children?: ReactNode;
+    label?: string;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    tone?: ButtonTone;
+    iconLeft?: ReactNode;
+    iconRight?: ReactNode;
+    loading?: boolean;
+    disabled?: boolean;
+    type?: 'button' | 'submit' | 'reset';
+    fullWidth?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Button({ children, label, variant, size, tone, iconLeft, iconRight, loading, disabled, type, fullWidth, className, href, action, input, actions, navigate, onClick, ...rest }: ButtonProps): import("react").JSX.Element;

package/types/core/actions/Chip/Chip.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode, CSSProperties } from 'react';
+import { type PressProps } from '../_shared/press';
+export interface ChipProps extends PressProps {
+    children?: ReactNode;
+    label?: string;
+    variant?: 'prompt' | 'toggle';
+    size?: 'sm' | 'md';
+    selected?: boolean;
+    onToggle?: (next: boolean) => void;
+    iconLeft?: ReactNode;
+    disabled?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Chip({ children, label, variant, size, selected, onToggle, iconLeft, disabled, className, href, action, input, actions, navigate, onClick, ...rest }: ChipProps): import("react").JSX.Element;

package/types/core/actions/IconButton/IconButton.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode, CSSProperties } from 'react';
+import { type PressProps } from '../_shared/press';
+export interface IconButtonProps extends PressProps {
+    icon?: ReactNode;
+    children?: ReactNode;
+    label: string;
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'ghost' | 'secondary' | 'primary';
+    pressed?: boolean;
+    disabled?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function IconButton({ icon, children, label, size, variant, pressed, disabled, className, href, action, input, actions, navigate, onClick, ...rest }: IconButtonProps): import("react").JSX.Element;

package/types/core/actions/Link/Link.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode, CSSProperties } from 'react';
+import { type PressProps } from '../_shared/press';
+export interface LinkProps extends Omit<PressProps, 'action' | 'input'> {
+    href: string;
+    children?: ReactNode;
+    label?: string;
+    variant?: 'default' | 'subtle';
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Link({ href, children, label, variant, className, navigate, onClick, ...rest }: LinkProps): import("react").JSX.Element;

package/types/core/actions/SegmentedControl/SegmentedControl.d.ts

@@ -0,0 +1,19 @@
+import { type CSSProperties } from 'react';
+export type Segment = {
+    value: string;
+    label: string;
+    disabled?: boolean;
+};
+export interface SegmentedControlProps {
+    options: Segment[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    label?: string;
+    fullWidth?: boolean;
+    size?: 'sm' | 'md';
+    className?: string;
+    setValue?: (value: string) => void;
+    style?: CSSProperties;
+}
+export declare function SegmentedControl({ options, value, defaultValue, onChange, label, fullWidth, size, className, setValue, ...rest }: SegmentedControlProps): import("react").JSX.Element;

package/types/core/actions/_shared/press.d.ts

@@ -0,0 +1,18 @@
+import { type MouseEvent } from 'react';
+type CellAction = (input: unknown) => Promise<unknown>;
+export interface PressProps {
+    href?: string;
+    action?: string;
+    input?: unknown;
+    actions?: Record<string, CellAction>;
+    navigate?: (to: string) => void;
+    onClick?: (e: MouseEvent<HTMLElement>) => void;
+}
+export declare const isInApp: (href: string) => boolean;
+export declare const isFragment: (href: string) => boolean;
+export declare function usePress({ href, action, input, actions, navigate, onClick }: PressProps): {
+    busy: boolean;
+    onClick: (e: MouseEvent<HTMLElement>) => void;
+    external: boolean;
+};
+export {};

package/types/core/display/DataTable/DataTable.d.ts

@@ -8,7 +8,9 @@ export interface DataTableColumn {
     sublabel?: ReactNode;
     align?: DataTableAlign;
     minWidth?: number;
+    format?: DataTableColumnFormat;
 }
+export type DataTableColumnFormat = 'date' | 'datetime';
 export interface DataTableCell {
     value: FormattableValue | ReactNode;
     tone?: Tone | string;

package/types/core/document/Contents/Contents.d.ts

@@ -8,7 +8,7 @@ export interface ContentsEntry {
     page?: number;
 }
 export interface ContentsProps {
-    entries: ReadonlyArray<ContentsEntry>;
+    entries?: ReadonlyArray<ContentsEntry>;
     depth?: number;
     title?: string;
     profileId?: ProfileId;

package/types/core/events/EventCard/EventCard.d.ts

@@ -0,0 +1,11 @@
+import type { CSSProperties, ReactElement } from 'react';
+import { type EventView } from '../_shared/event';
+export interface EventCardProps {
+    event: EventView;
+    href?: string;
+    locale?: string;
+    timeZone?: string;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function EventCard(props: EventCardProps): ReactElement;

package/types/core/events/EventDetail/EventDetail.d.ts

@@ -0,0 +1,29 @@
+import type { CSSProperties, ReactElement } from 'react';
+import { type Action, type EventView, type Response } from '../_shared/event';
+export interface EventNoteView {
+    body: string;
+    audience?: 'shared' | 'staff';
+    author?: string;
+    createdAt?: string;
+}
+export interface EventParticipantView {
+    name: string;
+    role?: string;
+    response?: Response;
+}
+export interface EventDetailProps {
+    event: EventView;
+    notes?: ReadonlyArray<EventNoteView>;
+    participants?: ReadonlyArray<EventParticipantView>;
+    viewerResponse?: Response;
+    actions?: {
+        respond?: Action<{
+            response: string;
+        }>;
+    };
+    locale?: string;
+    timeZone?: string;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function EventDetail(props: EventDetailProps): ReactElement;

package/types/core/events/EventLogForm/EventLogForm.d.ts

@@ -0,0 +1,24 @@
+import { type CSSProperties, type ReactElement } from 'react';
+import { type Action, type EventTypeOption, type WriteResult } from '../_shared/event';
+export interface LogEventInput {
+    event: Record<string, unknown>;
+    notes?: Array<{
+        body: string;
+        audience: 'shared' | 'staff';
+    }>;
+}
+export interface EventLogFormProps {
+    types: ReadonlyArray<EventTypeOption>;
+    orgId: string;
+    projectId?: string;
+    subjects?: ReadonlyArray<string>;
+    defaultTypeId?: string;
+    canWriteStaffNotes?: boolean;
+    actions?: {
+        logEvent?: Action<LogEventInput>;
+    };
+    onDone?: (result: WriteResult) => void;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function EventLogForm(props: EventLogFormProps): ReactElement;

package/types/core/events/EventRespond/EventRespond.d.ts

@@ -0,0 +1,13 @@
+import { type CSSProperties, type ReactElement } from 'react';
+import { type Action, type Response } from '../_shared/event';
+export interface EventRespondProps {
+    response?: Response;
+    actions?: {
+        respond?: Action<{
+            response: string;
+        }>;
+    };
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function EventRespond(props: EventRespondProps): ReactElement;

package/types/core/events/EventSchedule/EventSchedule.d.ts

@@ -0,0 +1,15 @@
+import type { CSSProperties, ReactElement } from 'react';
+import { type RenderComponent, type EventView } from '../_shared/event';
+export interface EventScheduleProps {
+    occurrences: ReadonlyArray<EventView>;
+    view?: 'week' | 'agenda';
+    weekOf?: string;
+    weekParam?: string;
+    eventHref?: string;
+    locale?: string;
+    timeZone?: string;
+    renderComponent?: RenderComponent;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function EventSchedule(props: EventScheduleProps): ReactElement;

package/types/core/events/EventTimeline/EventTimeline.d.ts

@@ -0,0 +1,21 @@
+import type { CSSProperties, ReactElement } from 'react';
+import { type RenderComponent, type EventView } from '../_shared/event';
+export interface ActivityItem {
+    id?: string;
+    at: string;
+    summary?: string;
+    actor?: string;
+    op?: string;
+    event?: EventView;
+}
+export interface EventTimelineProps {
+    items: ReadonlyArray<ActivityItem>;
+    eventHref?: string;
+    emptyText?: string;
+    locale?: string;
+    timeZone?: string;
+    renderComponent?: RenderComponent;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function EventTimeline(props: EventTimelineProps): ReactElement;

package/types/core/events/_shared/event.d.ts

@@ -0,0 +1,51 @@
+export interface EventView {
+    id?: string;
+    name: string;
+    typeName?: string;
+    kind?: 'scheduled' | 'record';
+    status?: 'tentative' | 'confirmed' | 'cancelled' | 'completed';
+    startsAt?: string;
+    endsAt?: string;
+    tzid?: string;
+    startOn?: string;
+    endOn?: string;
+    location?: string;
+    cardComponent?: string;
+}
+export type RenderComponent = (key: string, props?: Record<string, unknown>) => unknown;
+export declare function typeCard(e: EventView, renderComponent: RenderComponent | undefined, props: Record<string, unknown>): unknown;
+export interface EventTypeOption {
+    id: string;
+    name: string;
+    kind: 'scheduled' | 'record';
+    dataSchema?: {
+        properties?: Record<string, JsonField>;
+        required?: string[];
+    } | null;
+}
+export interface JsonField {
+    type?: 'string' | 'number' | 'integer' | 'boolean';
+    enum?: string[];
+    title?: string;
+    description?: string;
+}
+export interface WriteResult {
+    success: boolean;
+    id?: string;
+    data?: unknown;
+    errors?: string;
+    code?: 'DENIED' | 'CONFLICT' | 'INVALID' | 'FAILED';
+}
+export type Action<I> = (input: I) => Promise<WriteResult>;
+export declare const RESPONSES: readonly ["accepted", "tentative", "declined"];
+export type Response = (typeof RESPONSES)[number] | 'needs_action' | 'delegated';
+export declare function eventWhen(e: EventView, locale?: string, timeZone?: string): string;
+export declare const localZone: () => string;
+export declare function localToInstant(value: string): string | undefined;
+export declare function nowLocal(): string;
+export declare function writeMessage(r: WriteResult): string;
+export declare function dateIn(instant: string | Date, timeZone?: string): string;
+export declare function addDays(date: string, n: number): string;
+export declare function weekStart(date: string): string;
+export declare function datesOf(e: EventView, timeZone?: string): string[];
+export declare const hrefFrom: (template: string | undefined, id: string | undefined) => string | undefined;

package/types/core/feedback/Badge/Badge.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode, CSSProperties } from 'react';
+export interface BadgeProps {
+    label?: string;
+    children?: ReactNode;
+    tone?: string;
+    variant?: 'soft' | 'solid' | 'outline';
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Badge({ label, children, tone, variant, className, ...rest }: BadgeProps): import("react").JSX.Element;

package/types/core/feedback/Notice/Notice.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode, CSSProperties } from 'react';
+export interface NoticeProps {
+    title?: string;
+    message?: string;
+    children?: ReactNode;
+    tone?: 'info' | 'success' | 'warning' | 'danger' | string;
+    action?: ReactNode;
+    onDismiss?: () => void;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Notice({ title, message, children, tone, action, onDismiss, className, ...rest }: NoticeProps): import("react").JSX.Element;

package/types/core/feedback/Progress/Progress.d.ts

@@ -0,0 +1,12 @@
+import type { CSSProperties } from 'react';
+export interface ProgressProps {
+    value?: number;
+    max?: number;
+    label?: string;
+    showValue?: boolean;
+    tone?: string;
+    size?: 'sm' | 'md';
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Progress({ value, max, label, showValue, tone, size, className, style, ...rest }: ProgressProps): import("react").JSX.Element;

package/types/core/feedback/Skeleton/Skeleton.d.ts

@@ -0,0 +1,10 @@
+import type { CSSProperties } from 'react';
+export interface SkeletonProps {
+    shape?: 'text' | 'block' | 'circle';
+    lines?: number;
+    width?: number | string;
+    height?: number | string;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Skeleton({ shape, lines, width, height, className, style: given, ...rest }: SkeletonProps): import("react").JSX.Element;

package/types/core/feedback/Spinner/Spinner.d.ts

@@ -0,0 +1,8 @@
+import type { CSSProperties } from 'react';
+export interface SpinnerProps {
+    label?: string;
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Spinner({ label, size, className, ...rest }: SpinnerProps): import("react").JSX.Element;

package/types/core/feedback/Tooltip/Tooltip.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode, type CSSProperties } from 'react';
+export interface TooltipProps {
+    content?: ReactNode;
+    text?: string;
+    children?: ReactNode;
+    side?: 'top' | 'bottom';
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Tooltip({ content, text, children, side, className, ...rest }: TooltipProps): import("react").JSX.Element;

package/types/core/forms/Checkbox/Checkbox.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode, type Ref, type CSSProperties } from 'react';
+import { type FieldProps } from '../_shared/field';
+export interface CheckboxProps extends FieldProps<boolean> {
+    children?: ReactNode;
+    ref?: Ref<HTMLInputElement>;
+    style?: CSSProperties;
+}
+export declare function Checkbox({ value, defaultValue, onChange, setValue, id, name, label, children, hint, error, required, disabled, readOnly, className, style, ref }: CheckboxProps): import("react").JSX.Element;

package/types/core/forms/CheckboxGroup/CheckboxGroup.d.ts

@@ -0,0 +1,11 @@
+import { type Ref, type CSSProperties } from 'react';
+import { type ChoiceOption, type FieldProps } from '../_shared/field';
+export interface CheckboxGroupProps extends FieldProps<string[]> {
+    options: ChoiceOption[];
+    orientation?: 'vertical' | 'horizontal';
+    min?: number;
+    max?: number;
+    ref?: Ref<HTMLInputElement>;
+    style?: CSSProperties;
+}
+export declare function CheckboxGroup({ options, value, defaultValue, onChange, setValue, id, name, label, hint, error, required, disabled, readOnly, orientation, min, max, className, style, ref }: CheckboxGroupProps): import("react").JSX.Element;

package/types/core/forms/DateRange/DateRange.d.ts

@@ -0,0 +1,15 @@
+import { type Ref, type CSSProperties } from 'react';
+import { type FieldProps } from '../_shared/field';
+export type DateRangeValue = {
+    from: string | null;
+    to: string | null;
+};
+export interface DateRangeProps extends FieldProps<DateRangeValue> {
+    min?: string;
+    max?: string;
+    fromLabel?: string;
+    toLabel?: string;
+    ref?: Ref<HTMLInputElement>;
+    style?: CSSProperties;
+}
+export declare function DateRange({ value, defaultValue, onChange, setValue, id, name, label, hint, error, required, disabled, readOnly, min, max, fromLabel, toLabel, className, style, ref }: DateRangeProps): import("react").JSX.Element;

package/types/core/forms/FileField/FileField.d.ts

@@ -0,0 +1,28 @@
+import { type Ref, type CSSProperties } from 'react';
+import { type FieldProps } from '../_shared/field';
+export type StoredFile = {
+    bucket: string;
+    path: string;
+    name: string;
+    type: string;
+    size: number;
+    doc_hash?: string;
+};
+export type FileValue = {
+    v: 1;
+    file: StoredFile;
+};
+export type UploadResult = FileValue | {
+    error: string;
+};
+export interface FileFieldProps extends FieldProps<FileValue | null> {
+    upload?: (file: File, options: {
+        hash: boolean;
+    }) => Promise<UploadResult>;
+    accept?: string;
+    hash?: boolean;
+    ref?: Ref<HTMLButtonElement>;
+    style?: CSSProperties;
+}
+export declare function fileSize(bytes: number): string;
+export declare function FileField({ value, defaultValue, onChange, setValue, id, name, label, hint, error, required, disabled, readOnly, upload, accept, hash, className, style, ref }: FileFieldProps): import("react").JSX.Element;

package/types/core/forms/FormField/FormField.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode, type CSSProperties } from 'react';
+export interface FormFieldProps {
+    label?: string;
+    hint?: string;
+    error?: string;
+    required?: boolean;
+    htmlFor?: string;
+    hintId?: string;
+    errorId?: string;
+    as?: 'div' | 'fieldset';
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function FormField({ label, hint, error, required, htmlFor, hintId, errorId, as, children, className, style }: FormFieldProps): import("react").JSX.Element;

package/types/core/forms/RadioGroup/RadioGroup.d.ts

@@ -0,0 +1,9 @@
+import { type Ref, type CSSProperties } from 'react';
+import { type ChoiceOption, type FieldProps } from '../_shared/field';
+export interface RadioGroupProps extends FieldProps<string | null> {
+    options: ChoiceOption[];
+    orientation?: 'vertical' | 'horizontal';
+    ref?: Ref<HTMLInputElement>;
+    style?: CSSProperties;
+}
+export declare function RadioGroup({ options, value, defaultValue, onChange, setValue, id, name, label, hint, error, required, disabled, readOnly, orientation, className, style, ref }: RadioGroupProps): import("react").JSX.Element;

package/types/core/forms/SearchField/SearchField.d.ts

@@ -0,0 +1,10 @@
+import { type Ref, type CSSProperties } from 'react';
+import type { FieldProps } from '../_shared/field';
+export interface SearchFieldProps extends FieldProps<string> {
+    placeholder?: string;
+    onSearch?: (query: string) => void;
+    size?: 'sm' | 'md';
+    ref?: Ref<HTMLInputElement>;
+    style?: CSSProperties;
+}
+export declare function SearchField({ value, defaultValue, onChange, setValue, label, onSearch, size, className, ...rest }: SearchFieldProps): import("react").JSX.Element;

package/types/core/forms/Select/Select.d.ts

@@ -0,0 +1,10 @@
+import { type Ref, type CSSProperties } from 'react';
+import { type ChoiceOption, type FieldProps } from '../_shared/field';
+export type { ChoiceOption };
+export interface SelectProps extends FieldProps<string | null> {
+    options: ChoiceOption[];
+    placeholder?: string;
+    ref?: Ref<HTMLSelectElement>;
+    style?: CSSProperties;
+}
+export declare function Select({ options, value, defaultValue, onChange, setValue, id, name, label, hint, error, required, disabled, readOnly, placeholder, className, style, ref }: SelectProps): import("react").JSX.Element;

package/types/core/forms/Slider/Slider.d.ts

@@ -0,0 +1,11 @@
+import { type Ref, type CSSProperties } from 'react';
+import { type FieldProps } from '../_shared/field';
+export interface SliderProps extends FieldProps<number> {
+    min?: number;
+    max?: number;
+    step?: number;
+    format?: (value: number) => string;
+    ref?: Ref<HTMLInputElement>;
+    style?: CSSProperties;
+}
+export declare function Slider({ value, defaultValue, onChange, setValue, id, name, label, hint, error, required, disabled, readOnly, min, max, step, format, className, style, ref }: SliderProps): import("react").JSX.Element;

package/types/core/forms/Switch/Switch.d.ts

@@ -0,0 +1,7 @@
+import { type Ref, type CSSProperties } from 'react';
+import { type FieldProps } from '../_shared/field';
+export interface SwitchProps extends FieldProps<boolean> {
+    ref?: Ref<HTMLButtonElement>;
+    style?: CSSProperties;
+}
+export declare function Switch({ value, defaultValue, onChange, setValue, id, name, label, hint, error, disabled, readOnly, className, style, ref }: SwitchProps): import("react").JSX.Element;

package/types/core/forms/TextArea/TextArea.d.ts

@@ -0,0 +1,13 @@
+import { type KeyboardEvent, type Ref, type CSSProperties } from 'react';
+import { type FieldProps } from '../_shared/field';
+export interface TextAreaProps extends FieldProps<string> {
+    placeholder?: string;
+    rows?: number;
+    autoGrow?: boolean;
+    maxLength?: number;
+    onKeyDown?: (event: KeyboardEvent<HTMLTextAreaElement>) => void;
+    onBlur?: () => void;
+    ref?: Ref<HTMLTextAreaElement>;
+    style?: CSSProperties;
+}
+export declare function TextArea({ value, defaultValue, onChange, setValue, id, name, label, hint, error, required, disabled, readOnly, placeholder, rows, autoGrow, maxLength, onKeyDown, onBlur, className, style, ref }: TextAreaProps): import("react").JSX.Element;