@peripheries/core 0.1.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peripheries/core",
-  "version": "0.1.1",
+  "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,8 +8,9 @@ export interface DataTableColumn {
     sublabel?: ReactNode;
     align?: DataTableAlign;
     minWidth?: number;
-    label?: ReactNode;
+    format?: DataTableColumnFormat;
 }
+export type DataTableColumnFormat = 'date' | 'datetime';
 export interface DataTableCell {
     value: FormattableValue | ReactNode;
     tone?: Tone | string;
@@ -19,7 +20,6 @@ export interface DataTableRow {
     cells: ReadonlyArray<DataTableCellInput> | Readonly<Record<string, DataTableCellInput>>;
     highlighted?: boolean;
     total?: boolean;
-    tone?: 'default' | 'total' | 'highlight' | string;
 }
 export interface DataTableProps {
     title?: string;

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

@@ -1,9 +1,8 @@
 import type { CSSProperties, ReactElement, ReactNode } from 'react';
 export interface DisclaimerBlockProps {
     label?: string;
-    leadIn?: string;
     children?: ReactNode;
     className?: string;
     style?: CSSProperties;
 }
-export declare function DisclaimerBlock({ label, leadIn, children, className, style }: DisclaimerBlockProps): ReactElement;
+export declare function DisclaimerBlock({ label, children, className, style }: DisclaimerBlockProps): ReactElement;

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

@@ -2,7 +2,6 @@ import type { CSSProperties, ReactElement, ReactNode } from 'react';
 import { type Tone } from '../_shared/tone';
 export interface HighlightBoxProps {
     tone?: Tone | string;
-    variant?: string;
     label?: string;
     headline?: ReactNode;
     children?: ReactNode;
@@ -10,4 +9,4 @@ export interface HighlightBoxProps {
     className?: string;
     style?: CSSProperties;
 }
-export declare function HighlightBox({ tone, variant, label, headline, children, trailing, className, style }: HighlightBoxProps): ReactElement;
+export declare function HighlightBox({ tone, label, headline, children, trailing, className, style }: HighlightBoxProps): ReactElement;

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

@@ -12,12 +12,6 @@ export interface KpiCard {
     tone?: Tone | string;
     delta?: FormattableValue;
     badge?: KpiCardBadge;
-    caption?: FormattableValue;
-    borderColor?: string;
-    tag?: {
-        label: FormattableValue;
-        tone?: string;
-    };
 }
 export interface KpiCardGridProps {
     cards?: ReadonlyArray<KpiCard>;
@@ -26,7 +20,5 @@ export interface KpiCardGridProps {
     minColumnWidth?: number;
     className?: string;
     style?: CSSProperties;
-    items?: ReadonlyArray<KpiCard>;
 }
 export declare function KpiCardGrid(props: KpiCardGridProps): ReactElement;
-export declare const KpiGrid: typeof KpiCardGrid;

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

@@ -7,8 +7,6 @@ export interface OptionCardBar {
     fillPercent: number;
     tone?: Tone | string;
     valueTone?: Tone | string;
-    color?: string;
-    accent?: string;
 }
 export interface OptionCardProps {
     number?: number | string;
@@ -21,9 +19,5 @@ export interface OptionCardProps {
     isSelected?: boolean;
     className?: string;
     style?: CSSProperties;
-    name?: string;
-    badge?: FormattableValue;
-    badgeVariant?: string;
-    accent?: string;
 }
 export declare function OptionCard(props: OptionCardProps): ReactElement;

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

@@ -4,7 +4,6 @@ import { type Tone } from '../_shared/tone';
 export interface ProfileRowBadge {
     text: FormattableValue;
     tone?: Tone | string;
-    variant?: string;
 }
 export interface ProfileRow {
     label: string;
@@ -18,6 +17,5 @@ export interface ProfileCardProps {
     rows?: ReadonlyArray<ProfileRow>;
     className?: string;
     style?: CSSProperties;
-    headerAccent?: string;
 }
 export declare function ProfileCard(props: ProfileCardProps): ReactElement;

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

@@ -7,10 +7,7 @@ export interface StatStripProps {
     fillPercent?: number;
     subtitle?: FormattableValue;
     tone?: Tone | string;
-    accentColor?: string;
-    accent?: string;
-    caption?: FormattableValue;
     className?: string;
     style?: CSSProperties;
 }
-export declare function StatStrip({ label, value, fillPercent, subtitle, tone, accentColor, accent, caption, className, style }: StatStripProps): ReactElement;
+export declare function StatStrip({ label, value, fillPercent, subtitle, tone, className, style }: StatStripProps): ReactElement;

package/types/core/display/_shared/tone.d.ts

@@ -1,4 +1,3 @@
 export type Tone = 'neutral' | 'strong' | 'accent' | 'info' | 'success' | 'warning' | 'danger';
 export declare const TONES: ReadonlyArray<Tone>;
 export declare function toneOf(value: unknown, fallback?: Tone): Tone;
-export declare const isToneAlias: (value: unknown) => boolean;

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;