pixelize-native-library 1.0.7 → 1.2.1

package/lib/typescript/modules/composer/Composer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Composer — chat message input row with multiline field and send affordance.
+ *
+ * The focus ring is its only motion: it crossfades on focus/blur, never while the message list
+ * below it scrolls, so `core/motion`'s per-row rule still holds. Same offset-ring pattern as Input —
+ * a `border.focus` ring a small gap outside the field, on the canvas, where that token is the one
+ * proven ≥ 3:1.
+ */
+import type { LayoutStyle } from "../../core/style";
+export interface ComposerProps {
+    value: string;
+    onChangeText: (text: string) => void;
+    onSend: () => void;
+    placeholder?: string;
+    /**
+     * The field's accessible name. Defaults to `placeholder`, which is the only text this component
+     * renders — but a placeholder is not a label (it disappears the moment there is a value), so a
+     * caller with more than one composer on screen needs to be able to name them apart.
+     */
+    accessibilityLabel?: string;
+    disabled?: boolean;
+    sending?: boolean;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const Composer: import("react").NamedExoticComponent<ComposerProps>;
+//# sourceMappingURL=Composer.d.ts.map

package/lib/typescript/modules/composer/Composer.variants.d.ts

@@ -0,0 +1,7 @@
+import type { Theme } from "../../theme/hooks";
+export declare const composerStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** Carries the row's `flex: 1` so the focus ring can be an absolute sibling of the `TextInput`. */
+export declare const composerFieldStructure: import("../../core/style").VariantResolver<import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const composerInputStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const composerSendStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+//# sourceMappingURL=Composer.variants.d.ts.map

package/lib/typescript/modules/composer/index.d.ts

@@ -0,0 +1,3 @@
+export { Composer } from "./Composer";
+export type { ComposerProps } from "./Composer";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/copy-button/CopyButton.d.ts

@@ -0,0 +1,21 @@
+/**
+ * CopyButton — copies a string to the clipboard with brief success feedback. Three closed
+ * variants: icon-only, outlined button, or menu-row shape.
+ */
+import type { LayoutStyle } from "../../core/style";
+import type { CopyButtonSize, CopyButtonVariant } from "./CopyButton.variants";
+export interface CopyButtonProps {
+    value: string;
+    variant?: CopyButtonVariant;
+    label?: string;
+    copiedLabel?: string;
+    /** Shown and announced when the clipboard write fails (e.g. the optional native peer is absent). */
+    failedLabel?: string;
+    size?: CopyButtonSize;
+    onCopy?: (value: string) => void;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const CopyButton: import("react").NamedExoticComponent<CopyButtonProps>;
+//# sourceMappingURL=CopyButton.d.ts.map

package/lib/typescript/modules/copy-button/CopyButton.variants.d.ts

@@ -0,0 +1,42 @@
+import type { RoleColors, Theme } from "../../theme/hooks";
+export type CopyButtonVariant = "icon" | "button" | "menu-item";
+export type CopyButtonSize = "sm" | "md";
+export declare const COPY_FEEDBACK_MS = 1500;
+/**
+ * Same touch-target floor as `Button`/`Checkbox` (44dp — Apple HIG minimum, WCAG 2.5.5 AAA).
+ * Duplicated rather than imported — modules never import across `src/modules/*`.
+ */
+export declare const MIN_TOUCH_TARGET = 44;
+export interface CopyButtonSizeSpec {
+    /** Glyph size in dp — also the `icon` variant's whole visual footprint (it has no padding). */
+    readonly iconSize: number;
+    /** Symmetric touch expansion so `iconSize + 2·hitSlop ≥ 44` on the bare-icon variant. */
+    readonly hitSlop: number;
+}
+/**
+ * CopyButton-specific dimensions. Kept a plain constant — no theme dependency — so the hit-target
+ * test can assert `iconSize + 2·hitSlop ≥ 44` without a provider, same as `BUTTON_SIZES`.
+ */
+export declare const COPY_BUTTON_SIZES: {
+    readonly sm: {
+        readonly iconSize: 14;
+        readonly hitSlop: number;
+    };
+    readonly md: {
+        readonly iconSize: 16;
+        readonly hitSlop: number;
+    };
+};
+export interface CopyButtonColors {
+    readonly default: string;
+    readonly success: string;
+    readonly danger: string;
+    readonly border: string;
+}
+export declare function resolveCopyButtonColors(colors: RoleColors): CopyButtonColors;
+/** The row shapes reach 44dp with `minHeight`, not `hitSlop` — the `MENU_ROW_MIN_HEIGHT` /
+ *  `MULTI_SELECT_ROW_MIN_HEIGHT` precedent: a row is already its own full-width touch target. */
+export declare const copyButtonMenuRowStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const copyButtonOutlineStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare function writeClipboard(value: string): Promise<boolean>;
+//# sourceMappingURL=CopyButton.variants.d.ts.map

package/lib/typescript/modules/copy-button/index.d.ts

@@ -0,0 +1,4 @@
+export { CopyButton } from "./CopyButton";
+export type { CopyButtonProps } from "./CopyButton";
+export type { CopyButtonSize, CopyButtonVariant } from "./CopyButton.variants";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/data-table/DataTable.d.ts

@@ -0,0 +1,44 @@
+/**
+ * DataTable — a horizontally-scrollable, column-configured table for phone screens. Header and
+ * body live in ONE vertical `FlatList` (header as `ListHeaderComponent`, `stickyHeaderIndices={[0]}`
+ * for the pin) nested inside a single horizontal `ScrollView` — so header and rows are always the
+ * same width and scroll sideways together, without hand-syncing two independent scroll offsets.
+ *
+ * Sort and selection are fully controlled, the same contract `Select` uses for `value`: this
+ * component never sorts `data` itself and never owns `selectedKeys` — it only reports the next
+ * state via `onSortChange`/`onSelectionChange` and renders whatever the caller passes back in.
+ */
+import type { ReactNode } from "react";
+import type { LayoutStyle } from "../../core/style";
+import type { DataTableAlign, DataTableSortDirection } from "./DataTable.variants";
+export interface DataTableColumn<T> {
+    readonly key: string;
+    readonly header: string;
+    readonly width?: number;
+    readonly align?: DataTableAlign;
+    readonly render?: (row: T, index: number) => ReactNode;
+    readonly sortable?: boolean;
+}
+export interface DataTableProps<T> {
+    columns: DataTableColumn<T>[];
+    data: T[];
+    keyExtractor: (row: T, index: number) => string;
+    onRowPress?: (row: T, index: number) => void;
+    sortBy?: string;
+    sortDirection?: DataTableSortDirection;
+    onSortChange?: (key: string, direction: DataTableSortDirection) => void;
+    selectable?: boolean;
+    selectedKeys?: string[];
+    onSelectionChange?: (keys: string[]) => void;
+    loading?: boolean;
+    emptyMessage?: string;
+    stickyHeader?: boolean;
+    rowHeight?: number;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+declare function DataTableInner<T>({ columns, data, keyExtractor, onRowPress, sortBy, sortDirection, onSortChange, selectable, selectedKeys, onSelectionChange, loading, emptyMessage, stickyHeader, rowHeight, style, testID, }: DataTableProps<T>): import("react").JSX.Element;
+export declare const DataTable: typeof DataTableInner;
+export {};
+//# sourceMappingURL=DataTable.d.ts.map

package/lib/typescript/modules/data-table/DataTable.variants.d.ts

@@ -0,0 +1,118 @@
+/**
+ * DataTable's style + behaviour resolution — the same split every sibling module copies
+ * (see `Select.variants.ts` / `Menu.variants.ts`):
+ *  - STRUCTURE (row/cell layout, padding, border WIDTH) lives in the variant resolvers below —
+ *    static per (brand, mode), registered once via `StyleSheet.create`.
+ *  - COLOUR is resolved from the theme's ROLE colours (`resolveDataTableColors`), never a raw ramp,
+ *    never a hardcoded hex. A table has no per-instance colour choice, so the resolver takes no
+ *    selector argument (same shape as `resolveCheckboxColors`).
+ *  - BEHAVIOUR (sort cycling, selection set maths, the sorted-column accessible name) is pure here
+ *    so the contract is unit-testable without rendering React Native.
+ *
+ * Free of React, of `lucide`, and of any native import, so the WCAG + behaviour tests import it
+ * directly (mocking only `react-native`'s `StyleSheet`, as `core/style` does).
+ */
+import type { RoleColors, Theme } from "../../theme/hooks";
+export type DataTableAlign = "left" | "center" | "right";
+export type DataTableSortDirection = "asc" | "desc";
+/** The three glyphs a header can show. A literal union rather than an `IconName` import, so this
+ *  file stays free of the icon registry (which pulls `lucide` at runtime); `Icon`'s own `name` prop
+ *  still type-checks these against the closed `IconName` set at the call site. */
+export type DataTableSortIcon = "chevron-up" | "chevron-down" | "chevrons-up-down";
+/** Same touch-target floor as Button/Select (44dp — Apple HIG minimum, WCAG 2.5.5 AAA). */
+export declare const MIN_TOUCH_TARGET = 44;
+/** Header cells are sortable buttons, so the header is a direct 44dp target — never slop-expanded. */
+export declare const DATA_TABLE_HEADER_HEIGHT = 44;
+export declare const DATA_TABLE_DEFAULT_ROW_HEIGHT = 48;
+export declare const DATA_TABLE_DEFAULT_COLUMN_WIDTH = 120;
+export declare const DATA_TABLE_SELECT_COLUMN_WIDTH = 48;
+export declare const DATA_TABLE_SORT_ICON_SIZE = 14;
+export declare const DATA_TABLE_SKELETON_ROW_COUNT = 5;
+export declare const DATA_TABLE_SKELETON_CELL_HEIGHT = 12;
+/**
+ * Symmetric touch expansion for a pressable row, so `rowHeight + 2·slop ≥ 44` even when a caller
+ * passes a compact `rowHeight` (same `slopFor` technique `Button`/`Select` use for their short sizes).
+ */
+export declare function rowTouchSlop(rowHeight: number): number;
+export declare function resolveColumnWidth(width: number | undefined): number;
+/** The row's full width — what the header and every body row are pinned to, so the two stay aligned
+ *  while the shared horizontal `ScrollView` moves them together. */
+export declare function resolveTotalWidth(widths: readonly (number | undefined)[], selectable: boolean): number;
+export interface DataTableColors {
+    /** Header fill. `bg.sunken` separates the header band from the body without a second border. */
+    readonly headerBackground: string;
+    /** Header label — `fg.muted`, measured ≥ 4.5:1 on `headerBackground` for every brand × mode. */
+    readonly headerText: string;
+    /** Sort glyph. The SAME value as `headerText`: a colour that clears the stricter 4.5:1 text
+     *  minimum clears the icon's 3:1 non-text minimum for free (Menu/Select's identical argument). */
+    readonly headerIcon: string;
+    /** The header/body boundary — `border.interactive` (≥ 3:1, WCAG 1.4.11), not the decorative
+     *  `border.default`, which is a ~1.2:1 StyleSheet.hairlineWidth on every brand. */
+    readonly headerBorder: string;
+    /** Even-row fill. */
+    readonly rowBackground: string;
+    /** Odd-row zebra fill. */
+    readonly rowBackgroundAlt: string;
+    /** Pressed-row fill. `bg.raised` rather than `bg.sunken`, because `bg.sunken` is already the zebra
+     *  stripe — pressing an odd row would otherwise change nothing. `bg.hover` is excluded for the
+     *  reason `ListItem` documents (it drops `fg.default` below 4.5:1 on 4 light brands). */
+    readonly rowPressed: string;
+    /** Body cell text, measured ≥ 4.5:1 on all three row fills above. */
+    readonly cellText: string;
+}
+export declare function resolveDataTableColors(colors: RoleColors): DataTableColors;
+/** Zebra striping, or the pressed fill when the row is being touched. */
+export declare function resolveRowBackground(colors: DataTableColors, index: number, pressed: boolean): string;
+/**
+ * asc → desc → asc on the active column; any other column starts at asc. Pressing a new column
+ * never inherits the previous column's direction — a fresh sort reads ascending.
+ */
+export declare function nextSortDirection(columnKey: string, activeKey: string | undefined, activeDirection: DataTableSortDirection | undefined): DataTableSortDirection;
+export declare function resolveSortIcon(columnKey: string, activeKey: string | undefined, activeDirection: DataTableSortDirection | undefined): DataTableSortIcon;
+/**
+ * WCAG 1.3.3 / 4.1.2 — the sort glyph is a visual-only cue, so the header's accessible name carries
+ * the same state in words. Without this a screen-reader user hears only the column title and cannot
+ * tell which column the table is sorted by.
+ */
+export declare function resolveSortAccessibilityLabel(header: string, columnKey: string, activeKey: string | undefined, activeDirection: DataTableSortDirection | undefined): string;
+/**
+ * Fallback cell text when a column has no `render`. `row` is generic and unconstrained (a table
+ * accepts any shape of data), so reading `column.key` off it is a deliberate, narrow escape from
+ * `T` rather than a real type hole — the alternative is forcing every caller to supply `render`.
+ */
+export declare function resolveDefaultCellText(row: unknown, key: string): string;
+export declare function toggleSelectionKey(selectedKeys: readonly string[], key: string): string[];
+export interface DataTableSelectAllState {
+    readonly checked: boolean;
+    readonly indeterminate: boolean;
+}
+export declare function resolveSelectAllState(selectedKeys: readonly string[], rowKeys: readonly string[]): DataTableSelectAllState;
+/**
+ * Select-all only ever adds or removes the rows currently in `data` — a key selected elsewhere
+ * (a previous page, a filtered-out row) survives both directions, so the caller owns the full set.
+ */
+export declare function resolveSelectAllSelection(selectedKeys: readonly string[], rowKeys: readonly string[]): string[];
+export declare const dataTableRowStructure: import("../../core/style").VariantResolver<import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const dataTableHeaderRowStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const dataTableCellStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    align: {
+        left: {
+            justifyContent: "flex-start";
+        };
+        center: {
+            justifyContent: "center";
+        };
+        right: {
+            justifyContent: "flex-end";
+        };
+    };
+}, import("react-native").ViewStyle>;
+/**
+ * The keyboard/AT focus ring for a sortable header cell or a pressable row, drawn INSIDE the
+ * element's own bounds. Both are full-bleed: a header cell abuts its neighbours and a row spans the
+ * table's whole width, so the gap-outside ring `Button`/`CopyButton` use would be clipped by the
+ * table's own scroll containers. Square, like the cells it sits in. Colour is applied inline.
+ */
+export declare const dataTableFocusRingStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+export declare const dataTableSelectCellStructure: import("../../core/style").VariantResolver<import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+//# sourceMappingURL=DataTable.variants.d.ts.map

package/lib/typescript/modules/data-table/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Public surface of `pixelize-native-library/data-table`. Value exports and type exports are split
+ * for `verbatimModuleSyntax`. The resolvers (`resolveDataTableColors`, `nextSortDirection`, …) stay
+ * internal — a consumer configures a DataTable through its props, never by importing its internals.
+ */
+export { DataTable } from "./DataTable";
+export type { DataTableProps, DataTableColumn } from "./DataTable";
+export type { DataTableAlign, DataTableSortDirection } from "./DataTable.variants";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/date-picker/Calendar.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Calendar — the inline month grid every other export in this module composes. All of its date
+ * arithmetic lives in `DatePicker.variants.ts` (pure, unit-tested); this file is layout, state and
+ * accessibility only.
+ *
+ * The header doubles as a quick-jump toggle: while it is open the grid shows the twelve months of
+ * the cursor's year and the ‹ › controls page YEARS instead of months — one panel covering both
+ * dimensions, instead of a separate year grid and month grid to navigate between. The ‹ › controls
+ * themselves are the library's own `Button` (icon-only, ghost/neutral) — composed, not
+ * reimplemented; only the toggle needs a custom `Pressable`, for the `aria-expanded` (WCAG 4.1.2)
+ * `Button`'s closed a11y contract can't express (see `resolveCalendarChromeColors`).
+ *
+ * Keyboard (web only, WCAG 2.1.1): the 42 day cells are ONE tab stop, not 42 — exactly one carries
+ * `tabIndex={0}` and the arrows/Home/End/PageUp/PageDown move which. The DOM half lives in
+ * `Calendar.keys.web.ts`, the date arithmetic in `resolveCalendarFocusMove`; Enter/Space are left
+ * to `react-native-web`'s own `role="button"` press handling.
+ */
+import type { LayoutStyle } from "../../core/style";
+import type { CalendarSelectionMode, DateRange, FirstDayOfWeek } from "./DatePicker.variants";
+export interface CalendarProps {
+    /** The selected day in `"single"` mode. Ignored in `"range"` mode. */
+    value?: Date | null;
+    /** Fires with the tapped day at local noon. Alias: `onSelect`. */
+    onChange?: (date: Date) => void;
+    /** Same as `onChange` — preferred name for single-select usage. */
+    onSelect?: (date: Date) => void;
+    mode?: CalendarSelectionMode;
+    rangeValue?: DateRange | null;
+    onRangeChange?: (range: DateRange) => void;
+    minDate?: Date;
+    maxDate?: Date;
+    disabledDates?: Date[];
+    /** `1` = Monday (default), `0` = Sunday. */
+    firstDayOfWeek?: FirstDayOfWeek;
+    /** Drives month + weekday NAMES only, via `Intl.DateTimeFormat`. */
+    locale?: string;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const Calendar: import("react").NamedExoticComponent<CalendarProps>;
+//# sourceMappingURL=Calendar.d.ts.map

package/lib/typescript/modules/date-picker/Calendar.keys.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Native/default counterpart of `Calendar.keys.web.ts`. A physical keyboard driving a month grid is
+ * a web concern, so both hooks are no-ops here with identical signatures.
+ *
+ * Same `.ts` / `.web.ts` pair `core/a11y/keyboard.ts` and `../modal/renderWebPortal.ts` use: Metro
+ * resolves the `.web.ts` only for a web bundle, so no DOM code enters the native graph, and Jest
+ * (whose `react-native` preset has no `web` platform) always resolves THIS file — the web half is
+ * tested by importing it explicitly.
+ *
+ * These live in the module rather than in `core/a11y` on purpose: `useRovingKeys` models one flat
+ * list on one axis, and a month grid is 2-D over Dates (week wrapping, month paging). Forcing it
+ * into that helper would distort both.
+ */
+import type { RefObject } from "react";
+import type { View } from "react-native";
+import type { CalendarFocusMove } from "./DatePicker.variants";
+export declare function useCalendarGridKeys(_ref: RefObject<View | null>, _active: boolean, _onMove: (move: CalendarFocusMove) => void): void;
+export declare function useCalendarGridFocus(_ref: RefObject<View | null>, _focusedKey: string, _active: boolean): void;
+//# sourceMappingURL=Calendar.keys.d.ts.map

package/lib/typescript/modules/date-picker/Calendar.keys.web.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Web implementation of the Calendar day-grid's keyboard navigation. Metro only resolves this file
+ * for a web bundle (see `Calendar.keys.ts`), so it is the one place here that may assume a DOM.
+ *
+ * The DOM types are hand-written for the same reason `core/a11y/keyboard.web.ts` writes its own:
+ * `tsconfig.json` sets `"lib": ["ESNext"]`, `any` is lint-banned, and augmenting `react-native`'s
+ * types would ship through `lib/typescript/**`. A module-local structural surface plus
+ * `declare const document` erases entirely at emit.
+ *
+ * This file owns ONLY the DOM half — which key means which move, and moving real focus. Every date
+ * calculation lives in `resolveCalendarFocusMove` (`DatePicker.variants.ts`), pure and unit-tested.
+ *
+ * Enter and Space are deliberately unhandled: the day cells are `role="button"`, which
+ * `react-native-web`'s `PressResponder.isValidKeyPress` already presses on both keys. Handling them
+ * here too would select the day twice.
+ */
+import type { RefObject } from "react";
+import type { View } from "react-native";
+import type { CalendarFocusMove } from "./DatePicker.variants";
+/**
+ * Arrow/Home/End/PageUp/PageDown on the grid container. Listens on the CONTAINER (capture phase),
+ * never on `document`, so two calendars on one page never fight over the same arrow key, and so an
+ * arrow pressed on the ‹ › header buttons is left alone.
+ */
+export declare function useCalendarGridKeys(ref: RefObject<View | null>, active: boolean, onMove: (move: CalendarFocusMove) => void): void;
+/**
+ * Moves real DOM focus onto whichever day cell currently owns `tabIndex={0}`, after `focusedKey`
+ * changed the roving index.
+ *
+ * The `contains` guard is the whole safety of this hook: it only ever moves focus that is ALREADY
+ * inside the grid. Without it, a caller's own selection (or the first mount) would rip focus out of
+ * the field that opened the picker.
+ */
+export declare function useCalendarGridFocus(ref: RefObject<View | null>, focusedKey: string, active: boolean): void;
+//# sourceMappingURL=Calendar.keys.web.d.ts.map

package/lib/typescript/modules/date-picker/DatePicker.d.ts

@@ -0,0 +1,40 @@
+/**
+ * DatePicker — a field styled like `Input`'s box (`PickerField`) that opens `Calendar` and/or
+ * `TimePicker` in `PickerShell` (React Native's OWN `Modal` — see `PickerShell.tsx`). In
+ * `"datetime"` mode the sheet shows a Date | Time `Tabs` strip above the active panel — the
+ * library's own `Tabs` component, composed rather than reimplemented.
+ *
+ * The sheet edits a local DRAFT, never `value` directly: `Calendar`/`TimePicker` inside the modal
+ * report into `draft`, and only Confirm commits it via `onChange`. Cancel — and the backdrop, which
+ * is the same dismissal — discards the draft, so "Cancel restores the prior value" holds by
+ * construction (the prior value was never touched).
+ */
+import type { LayoutStyle } from "../../core/style";
+import type { DatePickerMode, FirstDayOfWeek } from "./DatePicker.variants";
+export interface DatePickerProps {
+    value?: Date | null;
+    onChange: (date: Date | null) => void;
+    mode?: DatePickerMode;
+    /** When true (default for `mode="date"`), tapping a day commits and closes the sheet. */
+    confirmOnSelect?: boolean;
+    label?: string;
+    placeholder?: string;
+    minDate?: Date;
+    maxDate?: Date;
+    disabled?: boolean;
+    error?: string;
+    clearable?: boolean;
+    /** Replaces the ENTIRE field text, including the time half in `"datetime"` mode. Defaults to a
+     *  medium `Intl` date (plus a hand-built clock string — see `formatTime`'s doc comment). */
+    format?: (date: Date) => string;
+    use24Hour?: boolean;
+    /** `1` = Monday (default), `0` = Sunday. */
+    firstDayOfWeek?: FirstDayOfWeek;
+    /** Drives month + weekday NAMES only, via `Intl.DateTimeFormat`. */
+    locale?: string;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    containerStyle?: LayoutStyle;
+    testID?: string;
+}
+export declare const DatePicker: import("react").NamedExoticComponent<DatePickerProps>;
+//# sourceMappingURL=DatePicker.d.ts.map