pixelize-native-library 1.0.6

package/lib/typescript/modules/file-upload/FileUpload.variants.d.ts

@@ -0,0 +1,114 @@
+/**
+ * FileUpload's pure logic: the native-picker calls, the raw-result → `FileUploadResult` mapping,
+ * the accessible-name derivation, and the structural resolvers.
+ *
+ * This is the one module in the library whose "pure" file is NOT free of a native runtime import —
+ * every sibling's `*.variants.ts` header says "free of React and of any native/lucide import"
+ * because that module owns no native call of its own. FileUpload does: `pickImageFile`/
+ * `pickDocumentFile` call `expo-image-picker`/`expo-document-picker` directly, PLAIN top-level
+ * imports (no lazy-loading), the same established pattern `core/icon` uses for its optional-peer
+ * native deps. Colocating the call with its own result-mapping keeps both testable the same way —
+ * `FileUpload.test.ts` mocks the two packages at the module level and asserts on the real call
+ * (options forwarded, cancel vs success vs rejection) — rather than splitting "call" (untestable
+ * without mounting) from "map" (pure) across files. Both packages are already mandatory peers for
+ * this subpath regardless of which `source` a given instance uses (see `FileUpload.tsx`'s header),
+ * so this adds no new install requirement.
+ *
+ * Free of React, so this file (and `FileUpload.test.ts`) never needs `@testing-library/react-native`
+ * — only `react-native`'s `StyleSheet` is mocked to identity, same as every sibling's pure test.
+ */
+import * as DocumentPicker from "expo-document-picker";
+import * as ImagePicker from "expo-image-picker";
+import type { Theme } from "../../theme";
+export type FileUploadSource = "image" | "document";
+export type FileUploadSize = "sm" | "md" | "lg";
+export interface FileUploadResult {
+    readonly uri: string;
+    readonly name: string;
+    readonly size?: number;
+    readonly mimeType?: string;
+}
+/** Shown below the control when a pick attempt fails outright (see `FileUpload.tsx`'s `openPicker`). */
+export declare const FILE_UPLOAD_PICK_ERROR_MESSAGE = "Couldn't open the picker. Check that photo or file access is allowed, then try again.";
+/**
+ * Falls back to the URI's last path segment when a picker doesn't supply a name —
+ * `ImagePickerAsset.fileName` can be `null` "when the name is unavailable or the user gave limited
+ * permission to access the media library" (its own doc comment). Strips a query/fragment first (a
+ * content:// or blob-style URI can carry one), then decodes percent-escapes so the displayed name
+ * reads like a normal filename instead of `my%20photo.jpg`.
+ */
+export declare function fileNameFromUri(uri: string): string;
+/**
+ * Maps `ImagePicker.launchImageLibraryAsync`'s result onto the public shape. `null` for a user
+ * cancellation (`canceled: true`) AND, defensively, for an empty `assets` array — the type allows
+ * it even though a single, non-multi-select call should never resolve that way. The caller (`
+ * FileUpload.tsx`) is the one that decides what a `null` MEANS (cancel → leave `value` alone,
+ * reject → clear it) by checking `result.canceled` itself; this function only normalizes the shape.
+ */
+export declare function resolveImagePickResult(result: ImagePicker.ImagePickerResult): FileUploadResult | null;
+/** Maps `DocumentPicker.getDocumentAsync`'s result onto the public shape — same `canceled`/empty-array handling as `resolveImagePickResult`. `DocumentPickerAsset.name` is always present, so no filename fallback is needed. */
+export declare function resolveDocumentPickResult(result: DocumentPicker.DocumentPickerResult): FileUploadResult | null;
+/**
+ * Opens the OS media-library picker and returns the normalized result, or `null` on cancel.
+ *
+ * Deliberately calls NO permission API first. Read directly from the installed `expo-image-picker`
+ * (v57)'s own native source: `launchImageLibraryAsync` with the default (non-editing) options never
+ * touches the media-library permission requester at all on either platform —
+ * `ImagePickerModule.swift`'s `launchImageLibraryAsync` goes straight to `launchMultiSelectPicker`
+ * (`PHPickerViewController`, permission-less by OS design) whenever `allowsEditing` is false, and
+ * `ImagePickerModule.kt`'s `launchImageLibraryAsync` never calls its permission helper either
+ * (unlike `launchCameraAsync`, which explicitly does on both platforms). So the "modern
+ * limited-access picker flow doesn't require an explicit permission request" is not a guess here —
+ * it's what the native module actually does for this call shape.
+ *
+ * `allowsEditing: true` is the one case that's genuinely uncertain: it routes iOS through the
+ * LEGACY `UIImagePickerController`, which (per Apple's own OS behaviour, outside this module's
+ * code) can trigger the native photo-library permission prompt on first use — see the "Known gaps"
+ * note in MODULE.md. Either way, this function does not special-case it: a rejection (denied
+ * permission, or any other native failure) simply propagates to the caller, which is the ONE place
+ * — `FileUpload.tsx`'s `openPicker` — that decides how to surface it (clear `value`, show the
+ * error row, warn in dev). A `canceled: true` resolution and a thrown rejection are the two
+ * possible "nothing was picked" outcomes; this function does not conflate them.
+ */
+export declare function pickImageFile(allowsEditing: boolean): Promise<FileUploadResult | null>;
+/**
+ * Opens the OS document picker and returns the normalized result, or `null` on cancel.
+ * `expo-document-picker` exposes no permission API whatsoever — it's backed by the platform's own
+ * file-picker UI (iOS Files / Android Storage Access Framework), which is inherently
+ * permission-less: the user grants access to the one file they pick, not to a library.
+ */
+export declare function pickDocumentFile(allowedMimeTypes: string[] | undefined): Promise<FileUploadResult | null>;
+/**
+ * The trigger Button's accessible name — folds in the current selection so a screen-reader user
+ * learns the state without needing to reach the separate "selected file" row. Reuses Button's own
+ * `accessibilityLabel` prop (never a second, parallel a11y mechanism) — see MODULE.md.
+ */
+export declare function resolveFileUploadTriggerLabel(label: string, value: FileUploadResult | null | undefined): string;
+/**
+ * The remove control's accessible name — one announcement naming BOTH the target and the action,
+ * matching how a screen reader should read a removable chip (e.g. "Selected file: report.pdf,
+ * remove"). The filename `Text` next to it is decorative (hidden from the accessibility tree, same
+ * reasoning as `Input.tsx`'s visible label), so this is the only place that name reaches AT.
+ */
+export declare function resolveFileUploadRemoveLabel(fileName: string): string;
+/**
+ * Root container — a vertical stack with a gap between the trigger, the optional "selected file"
+ * row, and the optional error message. `alignSelf: "flex-start"` is a deliberate, explicit default
+ * (not an omission): unlike `Select`/`MultiSelect`, which force `alignSelf: "stretch"` because they
+ * ARE an Input-box replica meant to span a form row, FileUpload's trigger is a plain `Button` (which
+ * hugs its own content width) — hard-coding a predictable "hug content" default here, rather than
+ * silently inheriting whatever `alignItems` the parent happens to have, means a consumer who DOES
+ * want it to span a row opts in explicitly via `style={{ alignSelf: "stretch" }}` (a `LayoutStyle`
+ * key), instead of the result depending on ambient parent layout.
+ */
+export declare const fileUploadContainerStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/**
+ * The "selected file" row — a bordered chip below the trigger. `border.interactive`, NOT the
+ * decorative `border.default`: `Card.variants.ts` documents `border.default` as measuring
+ * ~1.0–1.4:1 against `bg.surface` on every brand × mode — nowhere near a legible boundary. This row
+ * is a real UI grouping (WCAG 1.4.11), so it makes the identical substitution `Card`'s `outline`
+ * variant and `Button`'s `outline` variant both make, for the identical reason — measured against
+ * `bg.canvas` in `FileUpload.test.ts`, the same backdrop `Card.test.ts` uses for its own border.
+ */
+export declare const fileUploadRowStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+//# sourceMappingURL=FileUpload.variants.d.ts.map

package/lib/typescript/modules/file-upload/FileUpload.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileUpload.variants.d.ts","sourceRoot":"","sources":["../../../../src/modules/file-upload/FileUpload.variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAC;AAEjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGzC,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,UAAU,CAAC;AACpD,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAEhD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,wGAAwG;AACxG,eAAO,MAAM,8BAA8B,0FAC8C,CAAC;AAE1F;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAYnD;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,WAAW,CAAC,iBAAiB,GAAG,gBAAgB,GAAG,IAAI,CAUrG;AAED,iOAAiO;AACjO,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,cAAc,CAAC,oBAAoB,GAAG,gBAAgB,GAAG,IAAI,CAU9G;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,aAAa,CAAC,aAAa,EAAE,OAAO,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAG5F;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAG/G;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,GACzC,MAAM,CAER;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,uKAKtC,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,uKAUhC,CAAC"}

package/lib/typescript/modules/file-upload/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Public surface of `pixelize-native-library/file-upload`. Value exports and type exports are split for
+ * `verbatimModuleSyntax`. The picker calls, result resolvers, and structural resolvers stay
+ * internal — a consumer configures a FileUpload through its props, never by importing its internals.
+ */
+export { FileUpload } from "./FileUpload";
+export type { FileUploadProps } from "./FileUpload";
+export type { FileUploadResult, FileUploadSize, FileUploadSource } from "./FileUpload.variants";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/file-upload/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/file-upload/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC"}

package/lib/typescript/modules/filter-sheet/FilterChip.d.ts

@@ -0,0 +1,25 @@
+/**
+ * FilterChip — a small chip showing ONE currently-applied filter fact (e.g. "Status: Open"), with
+ * an optional "x" to remove it. NOT a `Badge`: `Badge` is documented, by its own file-level comment,
+ * as non-interactive ("no press, focus, loading, or disabled state") — this library never widens an
+ * existing component's contract to add press behaviour it was deliberately built without. A
+ * genuinely interactive chip is its own component, co-located here rather than exported from
+ * `../badge`.
+ *
+ * `onRemove` is the ENTIRE interactivity switch: provided → a `Pressable` with a trailing "x" icon
+ * (`accessibilityRole="button"`, a label that folds in the remove affordance). Omitted → a plain,
+ * non-interactive `View` with the identical visual shape — this is a "locked" chip (e.g. a board's
+ * own admin-pinned default filter the current user can't remove, matching web's `lockedChipKeys`
+ * concept), not a disabled-looking control.
+ */
+import type { LayoutStyle } from "../../core/style";
+export interface FilterChipProps {
+    label: string;
+    /** Omit → renders a non-removable/"locked" chip: no press, no "x", no accessibilityRole. */
+    onRemove?: () => void;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const FilterChip: import("react").NamedExoticComponent<FilterChipProps>;
+//# sourceMappingURL=FilterChip.d.ts.map

package/lib/typescript/modules/filter-sheet/FilterChip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterChip.d.ts","sourceRoot":"","sources":["../../../../src/modules/filter-sheet/FilterChip.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAWpD,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,4FAA4F;IAC5F,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,8FAA8F;IAC9F,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAID,eAAO,MAAM,UAAU,uDAyDrB,CAAC"}

package/lib/typescript/modules/filter-sheet/FilterSheet.d.ts

@@ -0,0 +1,54 @@
+/**
+ * FilterSheet — wraps this library's OWN `Drawer` (`../drawer`) as the sheet shell for a fully
+ * app-supplied set of filter DIMENSIONS (project/status/priority/type/label/… in tickets-web's own
+ * FilterBar, but this library hardcodes none of that vocabulary — see `FilterDimension` below). A
+ * consumer never touches `Drawer` directly for this use case, consumed exactly as `BottomNav`
+ * consumes `Drawer` for its own overflow sheet — through `Drawer`'s public props, never its internal
+ * `Drawer.variants.ts`.
+ *
+ * Deliberately narrow scope — a product decision, not an omission (see MODULE.md): no date-range
+ * filtering (`FilterDimensionKind` is closed to exactly `"single" | "multi"`), no advanced
+ * field/operator/value query builder, no per-board admin default-filter editor, no saved views, and
+ * no search input — a consuming app places its own `Input` for that elsewhere, the same stance
+ * tickets-web's `FilterBar` already takes (search lives outside the grouped filter panel).
+ *
+ * Internal STAGED state: opening the sheet seeds a local copy of the `values` prop (re-seeded on
+ * every closed→open transition, not on every render — see the effect below). Every edit made while
+ * the sheet is open — quick-chip taps, a dimension control's own selection, Reset — mutates ONLY
+ * that local copy. `onApply` is the sheet's one and only commit point; every other dismissal path
+ * discards the staged edits. See MODULE.md's interaction model for the full, numbered account.
+ */
+export type FilterDimensionKind = "single" | "multi";
+export interface FilterOption {
+    readonly label: string;
+    readonly value: string;
+    /** Renders as a one-tap pinned shortcut above this dimension's own control (e.g. a "Me" style
+     *  shortcut) — toggled immediately into the staged state, not gated behind Apply. See MODULE.md
+     *  interaction model, point 7. */
+    readonly quick?: boolean;
+}
+export interface FilterDimension {
+    readonly key: string;
+    readonly label: string;
+    readonly kind: FilterDimensionKind;
+    readonly options: FilterOption[];
+}
+export type FilterValues = Record<string, string | string[]>;
+export interface FilterSheetProps {
+    visible: boolean;
+    onRequestClose: () => void;
+    /** Fully consumer-supplied — zero hardcoded domain vocabulary in this library. */
+    dimensions: FilterDimension[];
+    /** Controlled — the currently APPLIED values, not the sheet's own in-progress edits. */
+    values: FilterValues;
+    onApply: (values: FilterValues) => void;
+    /** Omit → no Reset row/button renders at all. */
+    onReset?: () => void;
+    /** Sheet header text. */
+    title?: string;
+    applyLabel?: string;
+    resetLabel?: string;
+    testID?: string;
+}
+export declare const FilterSheet: import("react").NamedExoticComponent<FilterSheetProps>;
+//# sourceMappingURL=FilterSheet.d.ts.map

package/lib/typescript/modules/filter-sheet/FilterSheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterSheet.d.ts","sourceRoot":"","sources":["../../../../src/modules/filter-sheet/FilterSheet.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AASH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,OAAO,CAAC;AAErD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;sCAEkC;IAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,YAAY,EAAE,CAAC;CAClC;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;AAE7D,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,kFAAkF;IAClF,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,wFAAwF;IACxF,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IACxC,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,yBAAyB;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAMD,eAAO,MAAM,WAAW,wDAkEtB,CAAC"}

package/lib/typescript/modules/filter-sheet/FilterSheet.variants.d.ts

@@ -0,0 +1,98 @@
+/**
+ * FilterSheet's style + behaviour resolution — same split as every sibling module:
+ *  - STRUCTURE (padding/gaps/radius/border WIDTH) lives in the `createThemedVariants` resolvers
+ *    below, registered once per theme identity.
+ *  - COLOUR is resolved from the theme's ROLE colours by `resolveFilterChipColors` /
+ *    `resolveQuickChipColors`, never a raw ramp, never a hardcoded hex.
+ *  - `resolveFilterChipAccessibility` derives `FilterChip`'s removable-vs-locked a11y surface
+ *    purely, so the contract is unit-testable without rendering React Native.
+ *  - `resolveFilterSheetBodyHeight` caps the sheet's own scrollable dimension list to a fraction of
+ *    the window — the same "medium detent" approximation `BottomNav.variants.ts`'s
+ *    `resolveOverflowSheetHeight` already uses — so the title header and the Apply/Reset footer
+ *    stay fixed above and below it. Drawer's own 90%-of-window cap still bounds the whole panel.
+ *
+ * Free of React and of any lucide 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";
+/** Same touch-target floor as every interactive control in this library (44dp — Apple HIG minimum,
+ *  WCAG 2.5.5 AAA). */
+export declare const MIN_TOUCH_TARGET = 44;
+/** The sheet's scrollable dimension-list cap — a fraction of the window, capped at an absolute
+ *  maximum, the same approximation `resolveOverflowSheetHeight` uses for BottomNav's own sheet. The
+ *  title header and the Apply/Reset footer render OUTSIDE this cap so they stay visible regardless
+ *  of how many dimensions a consumer supplies. */
+export declare const FILTER_SHEET_BODY_HEIGHT_RATIO = 0.5;
+export declare const FILTER_SHEET_BODY_MAX_HEIGHT = 420;
+export declare function resolveFilterSheetBodyHeight(windowHeight: number): number;
+/** `FilterChip`'s fixed visual height. It is a passive/removable label, not a `size`-scaled
+ *  control — no `size` prop (see MODULE.md), the same single-fixed-shape stance Drawer takes. */
+export declare const FILTER_CHIP_HEIGHT = 28;
+export declare const FILTER_CHIP_ICON_SIZE = 14;
+export declare const FILTER_CHIP_HIT_SLOP: number;
+export interface FilterChipColors {
+    readonly background: string;
+    readonly border: string;
+    /** Label AND icon colour — the icon deliberately does NOT get its own weaker tone: sharing the
+     *  label's colour means it inherits the same measured ≥ 4.5:1 (so also ≥ 3:1 non-text) guarantee
+     *  instead of introducing a second, separately-measured pairing. Same choice `Badge`'s own icon
+     *  makes (`color={toneColors.text}`, not a distinct field). */
+    readonly text: string;
+}
+/**
+ * One fixed look for every `FilterChip`, removable or locked alike — a chip states a
+ * currently-applied filter FACT, not a severity or emphasis level, so there is no `tone` prop to
+ * resolve here (unlike `Badge`, which is a passive label with several tones). Reuses `Badge`'s own
+ * "neutral" tone recipe (`bg.sunken` fill + `border.interactive` outline) — already measured
+ * ≥ 3:1 against the canvas AND against this exact fill for every brand × mode in `Badge.test.ts`,
+ * so this module doesn't re-derive a fresh, untested pairing.
+ */
+export declare function resolveFilterChipColors(colors: RoleColors): FilterChipColors;
+export interface FilterChipAccessibilityInput {
+    readonly label: string;
+    readonly removable: boolean;
+}
+export interface FilterChipAccessibilityProps {
+    readonly accessible: true;
+    readonly accessibilityRole: "button" | undefined;
+    readonly accessibilityLabel: string;
+}
+/**
+ * Derives `FilterChip`'s a11y surface once, purely. Removable → `accessibilityRole="button"` with a
+ * label that folds in the remove affordance (`"${label}, remove filter"`) so a screen reader
+ * announces what the press does — the same "one accessible node reports the whole meaning"
+ * contract `Badge` documents for its own chip. Locked (no `onRemove`) → no role at all: the
+ * component renders a plain `View`, not a `Pressable`, so there is nothing to press.
+ */
+export declare function resolveFilterChipAccessibility(input: FilterChipAccessibilityInput): FilterChipAccessibilityProps;
+/** The one-tap quick-shortcut pill rendered above a dimension's Accordion section (e.g. a "Me"
+ *  shortcut). Visually a chip, but a DISTINCT, PRIVATE component from the public `FilterChip`: it
+ *  is always pressable and carries a SELECTED look, neither of which `FilterChip`'s frozen
+ *  (`label`/`onRemove`) shape supports — see this module's MODULE.md. */
+export declare const QUICK_CHIP_HEIGHT = 32;
+export declare const QUICK_CHIP_HIT_SLOP: number;
+export interface QuickChipColors {
+    readonly background: string;
+    readonly border: string;
+    readonly text: string;
+}
+/**
+ * Maps a quick chip's selected state onto role colours. Selected reads as a filled accent pill (the
+ * component additionally bolds the label weight, so selection is never conveyed by colour alone —
+ * WCAG 1.4.1, the same principle `BottomNav`'s active indicator documents); resting reads as a
+ * neutral outlined pill on the sheet's own surface.
+ */
+export declare function resolveQuickChipColors(colors: RoleColors, selected: boolean): QuickChipColors;
+/** The header row hosting the sheet's title. */
+export declare const filterSheetHeaderStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** One dimension's quick-chip row — wraps onto multiple lines rather than scrolling horizontally,
+ *  since the sheet already scrolls vertically. */
+export declare const filterSheetQuickRowStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** The Apply/Reset footer row — right-aligned, matching Modal's own action-row convention. */
+export declare const filterSheetFooterStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** `FilterChip`'s own structural shape — pill height/padding/radius/border WIDTH. Colour is
+ *  resolved by `resolveFilterChipColors`, applied inline over this. */
+export declare const filterChipStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** The quick-shortcut pill's own structural shape. */
+export declare const quickChipStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+//# sourceMappingURL=FilterSheet.variants.d.ts.map

package/lib/typescript/modules/filter-sheet/FilterSheet.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterSheet.variants.d.ts","sourceRoot":"","sources":["../../../../src/modules/filter-sheet/FilterSheet.variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGrD;uBACuB;AACvB,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAKnC;;;kDAGkD;AAClD,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAClD,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAEhD,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED;iGACiG;AACjG,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,eAAO,MAAM,oBAAoB,QAA8B,CAAC;AAEhE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;mEAG+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,UAAU,GAAG,gBAAgB,CAM5E;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;IAC1B,QAAQ,CAAC,iBAAiB,EAAE,QAAQ,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;CACrC;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,4BAA4B,GAClC,4BAA4B,CAI9B;AAED;;;yEAGyE;AACzE,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,mBAAmB,QAA6B,CAAC;AAE9D,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,GAAG,eAAe,CAI7F;AAED,gDAAgD;AAChD,eAAO,MAAM,0BAA0B,uKAKpC,CAAC;AAEJ;kDACkD;AAClD,eAAO,MAAM,4BAA4B,uKAQtC,CAAC;AAEJ,8FAA8F;AAC9F,eAAO,MAAM,0BAA0B,uKAQpC,CAAC;AAEJ;uEACuE;AACvE,eAAO,MAAM,mBAAmB,uKAU7B,CAAC;AAEJ,sDAAsD;AACtD,eAAO,MAAM,kBAAkB,uKAS5B,CAAC"}

package/lib/typescript/modules/filter-sheet/FilterSheetBody.d.ts

@@ -0,0 +1,28 @@
+/**
+ * FilterSheetBody — PRIVATE sub-component (not exported from `index.ts`, same status as
+ * `BottomNavOverflowSheet`), handed to `FilterSheet.tsx`'s `<Drawer>` as `children`: the title
+ * header, each dimension's optional quick-chip row, a single-open `Accordion` of per-dimension
+ * facet controls, and the Apply/Reset footer.
+ *
+ * Caps its own scrollable dimension list to a fraction of the window via
+ * `resolveFilterSheetBodyHeight` — the same "keep the header/footer fixed, only the middle scrolls"
+ * shape `BottomNavOverflowSheet` uses for its own search box + rows — so Apply/Reset stay reachable
+ * regardless of how many dimensions a consumer supplies, all still within Drawer's own 90%-of-window
+ * cap.
+ */
+import type { FilterDimension, FilterValues } from "./FilterSheet";
+interface FilterSheetBodyProps {
+    readonly dimensions: FilterDimension[];
+    readonly staged: FilterValues;
+    readonly onQuickToggle: (dimension: FilterDimension, optionValue: string) => void;
+    readonly onDimensionChange: (dimension: FilterDimension, next: string | string[]) => void;
+    readonly onApply: () => void;
+    readonly onReset: (() => void) | undefined;
+    readonly title: string;
+    readonly applyLabel: string;
+    readonly resetLabel: string;
+    readonly testID: string | undefined;
+}
+export declare function FilterSheetBody({ dimensions, staged, onQuickToggle, onDimensionChange, onApply, onReset, title, applyLabel, resetLabel, testID, }: FilterSheetBodyProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=FilterSheetBody.d.ts.map

package/lib/typescript/modules/filter-sheet/FilterSheetBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterSheetBody.d.ts","sourceRoot":"","sources":["../../../../src/modules/filter-sheet/FilterSheetBody.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAYH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAYnE,UAAU,oBAAoB;IAC5B,QAAQ,CAAC,UAAU,EAAE,eAAe,EAAE,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,CAAC,SAAS,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IAClF,QAAQ,CAAC,iBAAiB,EAAE,CAAC,SAAS,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,IAAI,CAAC;IAC1F,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,wBAAgB,eAAe,CAAC,EAC9B,UAAU,EACV,MAAM,EACN,aAAa,EACb,iBAAiB,EACjB,OAAO,EACP,OAAO,EACP,KAAK,EACL,UAAU,EACV,UAAU,EACV,MAAM,GACP,EAAE,oBAAoB,+BAyFtB"}

package/lib/typescript/modules/filter-sheet/filterSheet.helpers.d.ts

@@ -0,0 +1,45 @@
+/**
+ * FilterSheet's pure, framework-free logic — no React, no `react-native` import at all. Types are
+ * imported `import type` only (erased by `verbatimModuleSyntax`), so this file pulls in no runtime
+ * dependency on `FilterSheet.tsx`, React, or React Native — it stays testable under plain jest with
+ * zero mocking, the same "orthogonal concern gets its own file" call `BottomNav.search.ts` makes.
+ *
+ * `values`/`staged` are always the CONSUMER's shape (`Record<string, string | string[]>`); every
+ * helper here normalises defensively rather than trusting a caller passed exactly what a
+ * dimension's `kind` expects (e.g. a stale `string` left over for a dimension that became
+ * `kind: "multi"` in a later release of the consumer's own dimension config).
+ */
+import type { FilterDimension, FilterValues } from "./FilterSheet";
+/**
+ * How many DIMENSIONS currently have a selection — not the total number of selected options. A
+ * `multi` dimension with 3 selected values still counts as ONE active filter, matching the
+ * "N filters applied" badge this exists to power (see MODULE.md's interaction model). Exported from
+ * `index.ts` as the module's one pure, UI-free public helper — every consumer needs this arithmetic
+ * and would otherwise reimplement it slightly differently each time.
+ */
+export declare function countActiveFilters(dimensions: FilterDimension[], values: FilterValues): number;
+/**
+ * Normalises a consumer's `values` into the shape every dimension's `kind` actually expects —
+ * defensive, not a plain copy: a `multi` dimension always gets a real array (never a stray leftover
+ * string), and a `single` dimension with no/empty value is OMITTED entirely rather than carrying an
+ * empty string, so `values[key]` reads `undefined` exactly like a freshly-reset one. Used both to
+ * seed the sheet's staged state on open and to build the Reset target below.
+ */
+export declare function normalizeFilterValues(dimensions: FilterDimension[], values: FilterValues): FilterValues;
+/** Every dimension cleared: `multi` → `[]`, `single` → omitted (see `normalizeFilterValues` above).
+ *  Reset only ever replaces the SHEET's own staged state — it never calls `onApply` (see MODULE.md
+ *  interaction model, point 5). */
+export declare function resolveResetValues(dimensions: FilterDimension[]): FilterValues;
+/**
+ * Applies ONE quick-option tap to a dimension's staged value, immediately (not gated behind Apply —
+ * see MODULE.md interaction model, point 7). `multi` toggles the value in/out of the array, exactly
+ * like `MultiSelect`'s own row toggle; `single` toggles the WHOLE dimension between that value and
+ * cleared — a second tap on the same quick option un-selects it, since a quick option is the only
+ * way to clear a `single` dimension short of the sheet's own Reset button.
+ */
+export declare function applyQuickToggle(values: FilterValues, dimension: FilterDimension, optionValue: string): FilterValues;
+/** Whether ONE option is currently selected within a dimension's (usually staged) values — shared
+ *  by the quick-chip row, which needs this to render its own selected look independent of whichever
+ *  Accordion section happens to be expanded. */
+export declare function isOptionSelected(dimension: FilterDimension, values: FilterValues, optionValue: string): boolean;
+//# sourceMappingURL=filterSheet.helpers.d.ts.map

package/lib/typescript/modules/filter-sheet/filterSheet.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterSheet.helpers.d.ts","sourceRoot":"","sources":["../../../../src/modules/filter-sheet/filterSheet.helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AASnE;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,eAAe,EAAE,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAK9F;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,eAAe,EAAE,EAAE,MAAM,EAAE,YAAY,GAAG,YAAY,CAWvG;AAED;;mCAEmC;AACnC,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,YAAY,CAE9E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,MAAM,GAClB,YAAY,CAgBd;AAED;;gDAEgD;AAChD,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,eAAe,EAC1B,MAAM,EAAE,YAAY,EACpB,WAAW,EAAE,MAAM,GAClB,OAAO,CAKT"}

package/lib/typescript/modules/filter-sheet/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Public surface of `pixelize-native-library/filter-sheet`. Value exports and type exports are split
+ * for `verbatimModuleSyntax`. `FilterSheetBody`, every resolver in `FilterSheet.variants.ts`, and
+ * every helper in `filterSheet.helpers.ts` OTHER than `countActiveFilters` stay internal — a
+ * consumer configures a FilterSheet through its props, never by importing its internals.
+ */
+export { FilterSheet } from "./FilterSheet";
+export type { FilterSheetProps, FilterDimension, FilterDimensionKind, FilterOption, FilterValues, } from "./FilterSheet";
+export { FilterChip } from "./FilterChip";
+export type { FilterChipProps } from "./FilterChip";
+export { countActiveFilters } from "./filterSheet.helpers";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/filter-sheet/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/filter-sheet/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,YAAY,EACZ,YAAY,GACb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC"}

package/lib/typescript/modules/input/Input.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Input — wraps RN's `TextInput`. Colour is `status`-driven (never a free `color` prop), structure
+ * comes from `createThemedVariants`, and the focus indicator is the same offset-ring pattern as
+ * Button: a `border.focus` ring drawn a small gap OUTSIDE the field, on the canvas, because that is
+ * the role token proven ≥ 3:1 against the canvas (over the field's own border it isn't guaranteed).
+ */
+import type { IconName } from "../../core/icon";
+import type { LayoutStyle } from "../../core/style";
+import type { InputSize, InputStatus } from "./Input.variants";
+export interface InputProps {
+    value: string;
+    onChangeText: (text: string) => void;
+    placeholder?: string;
+    size?: InputSize;
+    status?: InputStatus;
+    disabled?: boolean;
+    /** Rendered above the field. Also becomes `accessibilityLabel` unless one is passed explicitly. */
+    label?: string;
+    /** Shown below the field when `status` is `"default"`. */
+    helperText?: string;
+    /** Shown below the field, with `accessibilityLiveRegion="polite"`, when `status` is `"error"`. */
+    errorText?: string;
+    leadingIcon?: IconName;
+    trailingIcon?: IconName;
+    secureTextEntry?: boolean;
+    /** Overrides the label→`accessibilityLabel` fallback. */
+    accessibilityLabel?: string;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    containerStyle?: LayoutStyle;
+    testID?: string;
+}
+export declare const Input: import("react").NamedExoticComponent<InputProps>;
+//# sourceMappingURL=Input.d.ts.map

package/lib/typescript/modules/input/Input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Input.d.ts","sourceRoot":"","sources":["../../../../src/modules/input/Input.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AASpD,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/D,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mGAAmG;IACnG,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kGAAkG;IAClG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,QAAQ,CAAC;IACvB,YAAY,CAAC,EAAE,QAAQ,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,yDAAyD;IACzD,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,8FAA8F;IAC9F,cAAc,CAAC,EAAE,WAAW,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAKD,eAAO,MAAM,KAAK,kDAmHhB,CAAC"}

package/lib/typescript/modules/input/Input.variants.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Input's style + behaviour resolution — same split as Button.variants:
+ *  - STRUCTURE (height, padding, radius, border WIDTH) lives in the themed `inputStructure`
+ *    resolver, static per (brand, mode), registered once via `StyleSheet.create`.
+ *  - COLOUR is `status`-driven (never a free `color` prop) and resolved from the theme's ROLE
+ *    colours by `resolveInputStatus`, so it is guaranteed legible in both modes.
+ *  - ACCESSIBILITY prop derivation is `resolveInputAccessibility`, kept pure so the
+ *    "accessibilityLabel falls back to the visible label / disabled blocks editing" contract is
+ *    unit-testable without rendering React Native.
+ *
+ * Free of `lucide` and of any React tree, so the WCAG + behaviour tests import it directly
+ * (mocking only `react-native`'s `StyleSheet`, as `core/style` does).
+ */
+import type { RoleColors } from "../../theme";
+import type { Theme } from "../../theme";
+export type InputSize = "sm" | "md" | "lg";
+/** A state, not a brand tone — an input's colour reports validity, so it is never called `tone`. */
+export type InputStatus = "default" | "error";
+/** Same floor as Button — 44dp (WCAG 2.5.5 / HIG). Duplicated, not imported: modules stay isolated. */
+export declare const MIN_TOUCH_TARGET = 44;
+export interface InputSizeSpec {
+    /** Visual height in dp. */
+    readonly height: number;
+    /** Value/placeholder text size, on the theme's `fontSizes` scale. */
+    readonly fontSize: number;
+    /** Leading/trailing icon glyph size in dp. */
+    readonly iconSize: number;
+    /** Symmetric touch expansion so `height + 2·hitSlop ≥ 44`. */
+    readonly hitSlop: number;
+}
+/**
+ * Input-specific dimensions. Height/iconSize/slop are the component's own design constants;
+ * `fontSize` sits on the theme's `fontSizes` scale (14/16/18) — same numbers as Button's sizes, so
+ * an icon-adjacent label and a field row line up when placed side by side.
+ */
+export declare const INPUT_SIZES: {
+    readonly sm: {
+        readonly height: 32;
+        readonly fontSize: 14;
+        readonly iconSize: 16;
+        readonly hitSlop: number;
+    };
+    readonly md: {
+        readonly height: 40;
+        readonly fontSize: 16;
+        readonly iconSize: 18;
+        readonly hitSlop: number;
+    };
+    readonly lg: {
+        readonly height: 48;
+        readonly fontSize: 18;
+        readonly iconSize: 20;
+        readonly hitSlop: number;
+    };
+};
+export interface InputStatusColors {
+    /** Field border — the neutral interactive outline, or the danger outline in "error" (≥ 3:1). */
+    readonly border: string;
+    /** Helper/error message under the field (≥ 4.5:1 on the canvas). */
+    readonly message: string;
+}
+/**
+ * Maps `status` onto the theme's role colours. The whole reason the prop is a closed union and not
+ * `color?: string`: every colour an Input can show is one of these role lookups, so it can never be
+ * an off-palette value an app invented, and it inverts light↔dark for free.
+ *
+ * The error border deliberately reads `status.danger.solid`, NOT `status.danger.border` —
+ * `StatusColors.border` is documented as the decorative chip/badge outline (`ramp[200]`) and
+ * measures below 3:1 against the canvas on every brand × mode (as low as 2.07:1). A 1px field
+ * outline is a real UI boundary (WCAG 1.4.11), so it needs the rung that actually clears 3:1;
+ * `solid` does, comfortably, everywhere (≥ 3.37:1 light, ≥ 5.05:1 dark) — see `Input.test.ts`.
+ */
+export declare function resolveInputStatus(colors: RoleColors, status: InputStatus): InputStatusColors;
+export interface InputAccessibilityInput {
+    readonly label?: string | undefined;
+    readonly accessibilityLabel?: string | undefined;
+    readonly disabled?: boolean | undefined;
+}
+export interface InputAccessibilityProps {
+    /** Falls back to the visible label — a sibling `Text`, not a wrapping element RN can associate. */
+    readonly accessibilityLabel: string | undefined;
+    readonly accessibilityState: {
+        readonly disabled: boolean;
+    };
+    /** The `TextInput` `editable` prop — false while disabled, so the field blocks input. */
+    readonly editable: boolean;
+}
+/**
+ * Derives the accessibility surface once, purely, so the fallback contract is testable without a
+ * renderer. RN's `TextInput` has no `htmlFor`-equivalent link to a sibling label `Text`, so the
+ * label's content must be copied onto `accessibilityLabel` directly (an explicit
+ * `accessibilityLabel` always wins).
+ */
+export declare function resolveInputAccessibility(input: InputAccessibilityInput): InputAccessibilityProps;
+/**
+ * Structural styles only — layout, height, padding, radius, border WIDTH. No colours (those are
+ * status-driven and applied inline over this), so this compiles once per theme identity via the
+ * `WeakMap`-cached themed resolver and never rebuilds per render.
+ */
+export declare const inputStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    size: {
+        sm: {
+            height: 32;
+            paddingHorizontal: 12;
+        };
+        md: {
+            height: 40;
+            paddingHorizontal: 16;
+        };
+        lg: {
+            height: 48;
+            paddingHorizontal: 24;
+        };
+    };
+}, import("react-native").ViewStyle>;
+//# sourceMappingURL=Input.variants.d.ts.map

package/lib/typescript/modules/input/Input.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Input.variants.d.ts","sourceRoot":"","sources":["../../../../src/modules/input/Input.variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGzC,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAC3C,oGAAoG;AACpG,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAE9C,uGAAuG;AACvG,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAInC,MAAM,WAAW,aAAa;IAC5B,2BAA2B;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;CAI6B,CAAC;AAEtD,MAAM,WAAW,iBAAiB;IAChC,gGAAgG;IAChG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,iBAAiB,CAK7F;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACzC;AAED,MAAM,WAAW,uBAAuB;IACtC,mGAAmG;IACnG,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;IAChD,QAAQ,CAAC,kBAAkB,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;IAC5D,yFAAyF;IACzF,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,uBAAuB,GAAG,uBAAuB,CAOjG;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;oCAgBxB,CAAC"}

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

@@ -0,0 +1,10 @@
+/**
+ * Public surface of `pixelize-native-library/input`. Value exports and type exports are split for
+ * `verbatimModuleSyntax`. The visual/behaviour resolvers (`resolveInputStatus`, `INPUT_SIZES`, …)
+ * stay internal — a consumer configures an Input through its props, never by importing its internals.
+ */
+export { Input } from "./Input";
+export type { InputProps } from "./Input";
+export type { InputSize, InputStatus } from "./Input.variants";
+export type { IconName } from "../../core/icon";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/input/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/input/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAI/D,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}