blend-native 0.0.1-beta.0

package/lib/typescript/commonjs/primitives/Pressable.d.ts

@@ -0,0 +1,135 @@
+import React from 'react';
+import { View, type GestureResponderEvent, type PressableProps, type ViewStyle } from 'react-native';
+import { type SurfaceStyleProps } from '../adapters/surfaceStyle';
+import { MIN_TOUCH_TARGET } from './touchTarget';
+export { MIN_TOUCH_TARGET };
+/**
+ * Native `Pressable` — the interactive surface for buttons, tags, and any
+ * other pressable token-driven component.
+ *
+ * Web's `PrimitiveButton` is a styled-components `button` with `_active`,
+ * `_hover`, `_focusVisible` and `_disabled` pseudo-state objects. RN has no
+ * CSS pseudo-selectors; instead `Pressable` exposes a `style` callback
+ * receiving `{ pressed }`. This primitive takes the same token-derived CSS
+ * strings, translates them through the shared adapter, and composes them per
+ * state.
+ *
+ * `_hover` is ignored — RN has no hover. `_focusVisible` is ignored — there
+ * is no focus ring on touch.
+ */
+/**
+ * `expo-linear-gradient` is an **optional** peer (probe shared with
+ * Skeleton in `adapters/optionalGradient`). When it is absent the surface
+ * falls back to the gradient's first colour, which `resolveSurfaceStyle`
+ * already supplies as `backgroundColor` — so a gradient button degrades to
+ * a solid one rather than rendering transparent.
+ */
+/**
+ * Note this extends `SurfaceStyleProps`, exactly as `BlockProps` does.
+ *
+ * That shared base is load-bearing, not cosmetic. Components that switch
+ * between `Block` and `Pressable` depending on interactivity (Tag, and web's
+ * `TagElement = onClick ? PrimitiveButton : Block` pattern) build one surface
+ * object and hand it to whichever they render. If the two accepted different
+ * prop sets, the extras would fall silently into `...rest` in one branch and
+ * vanish — and TypeScript would not catch it, because spreading an object
+ * into JSX skips excess-property checking. Keeping one base makes that class
+ * of bug unrepresentable.
+ */
+export type PrimitivePressableProps = SurfaceStyleProps & {
+    children?: React.ReactNode;
+    /** Active-state background (CSS string). */
+    activeBackground?: string;
+    /** Disabled-state background (CSS string). */
+    disabledBackground?: string;
+    activeBorder?: string;
+    disabledBorder?: string;
+    activeBoxShadow?: string;
+    disabled?: boolean;
+    /**
+     * Render a spinner in place of `children` while keeping the surface
+     * chrome (background, border, padding) intact — the same substitution
+     * web performs in `renderButtonContent`.
+     */
+    loading?: boolean;
+    loaderColor?: string;
+    loaderSize?: number | 'small' | 'large';
+    /** Announced to screen readers when `loading` becomes true. */
+    loadingAccessibilityLabel?: string;
+    /** Pressed scale transform (web uses `scale(0.99)`). */
+    pressedScale?: number;
+    /**
+     * Colour of the Android ripple. Defaults to the active-state background
+     * token, so press feedback tracks the design system without callers
+     * having to supply anything.
+     *
+     * Ignored on every other platform — see the note on `pressFeedback`.
+     */
+    rippleColor?: string;
+    /**
+     * Whether the ripple is drawn without bounds (a circle centred on the
+     * touch, used for icon-only controls). Mirrors RN's `android_ripple.borderless`.
+     */
+    rippleBorderless?: boolean;
+    /**
+     * Minimum tappable size in points. When the rendered surface is smaller,
+     * `hitSlop` expands the touch area without changing the visual box.
+     *
+     * Apple HIG asks for 44x44pt and Material for 48x48dp; small controls
+     * (an `xs` Tag is 20pt tall) fall well under both by design, so the tap
+     * target has to be widened rather than the control. Pass `0` to opt out.
+     */
+    minTouchTarget?: number;
+    onPress?: (event: GestureResponderEvent) => void;
+    style?: ViewStyle;
+} & Omit<PressableProps, 'style' | 'onPress' | 'disabled' | 'children'>;
+/** Memoised — see the note on `Block`. */
+export declare const Pressable: React.NamedExoticComponent<SurfaceStyleProps & {
+    children?: React.ReactNode;
+    /** Active-state background (CSS string). */
+    activeBackground?: string;
+    /** Disabled-state background (CSS string). */
+    disabledBackground?: string;
+    activeBorder?: string;
+    disabledBorder?: string;
+    activeBoxShadow?: string;
+    disabled?: boolean;
+    /**
+     * Render a spinner in place of `children` while keeping the surface
+     * chrome (background, border, padding) intact — the same substitution
+     * web performs in `renderButtonContent`.
+     */
+    loading?: boolean;
+    loaderColor?: string;
+    loaderSize?: number | "small" | "large";
+    /** Announced to screen readers when `loading` becomes true. */
+    loadingAccessibilityLabel?: string;
+    /** Pressed scale transform (web uses `scale(0.99)`). */
+    pressedScale?: number;
+    /**
+     * Colour of the Android ripple. Defaults to the active-state background
+     * token, so press feedback tracks the design system without callers
+     * having to supply anything.
+     *
+     * Ignored on every other platform — see the note on `pressFeedback`.
+     */
+    rippleColor?: string;
+    /**
+     * Whether the ripple is drawn without bounds (a circle centred on the
+     * touch, used for icon-only controls). Mirrors RN's `android_ripple.borderless`.
+     */
+    rippleBorderless?: boolean;
+    /**
+     * Minimum tappable size in points. When the rendered surface is smaller,
+     * `hitSlop` expands the touch area without changing the visual box.
+     *
+     * Apple HIG asks for 44x44pt and Material for 48x48dp; small controls
+     * (an `xs` Tag is 20pt tall) fall well under both by design, so the tap
+     * target has to be widened rather than the control. Pass `0` to opt out.
+     */
+    minTouchTarget?: number;
+    onPress?: (event: GestureResponderEvent) => void;
+    style?: ViewStyle;
+} & Omit<PressableProps, "children" | "style" | "onPress" | "disabled"> & React.RefAttributes<View>>;
+export default Pressable;
+//# sourceMappingURL=Pressable.d.ts.map

package/lib/typescript/commonjs/primitives/Pressable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pressable.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Pressable.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA2D,MAAM,OAAO,CAAA;AAC/E,OAAO,EAGH,IAAI,EAEJ,KAAK,qBAAqB,EAE1B,KAAK,cAAc,EAEnB,KAAK,SAAS,EACjB,MAAM,cAAc,CAAA;AAMrB,OAAO,EAEH,KAAK,iBAAiB,EACzB,MAAM,0BAA0B,CAAA;AAKjC,OAAO,EACH,gBAAgB,EAInB,MAAM,eAAe,CAAA;AAItB,OAAO,EAAE,gBAAgB,EAAE,CAAA;AAE3B;;;;;;;;;;;;;GAaG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,uBAAuB,GAAG,iBAAiB,GAAG;IACtD,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,4CAA4C;IAC5C,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,8CAA8C;IAC9C,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,eAAe,CAAC,EAAE,MAAM,CAAA;IAExB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;IACvC,+DAA+D;IAC/D,yBAAyB,CAAC,EAAE,MAAM,CAAA;IAClC,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IAEvB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAA;IAChD,KAAK,CAAC,EAAE,SAAS,CAAA;CACpB,GAAG,IAAI,CAAC,cAAc,EAAE,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC,CAAA;AAoZvE,0CAA0C;AAC1C,eAAO,MAAM,SAAS;eApcP,KAAK,CAAC,SAAS;IAC1B,4CAA4C;uBACzB,MAAM;IACzB,8CAA8C;yBACzB,MAAM;mBACZ,MAAM;qBACJ,MAAM;sBACL,MAAM;eAEb,OAAO;IAClB;;;;OAIG;cACO,OAAO;kBACH,MAAM;iBACP,MAAM,GAAG,OAAO,GAAG,OAAO;IACvC,+DAA+D;gCACnC,MAAM;IAClC,wDAAwD;mBACzC,MAAM;IACrB;;;;;;OAMG;kBACW,MAAM;IACpB;;;OAGG;uBACgB,OAAO;IAC1B;;;;;;;OAOG;qBACc,MAAM;cAEb,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI;YACxC,SAAS;oGAsZuB,CAAA;AAG5C,eAAe,SAAS,CAAA"}

package/lib/typescript/commonjs/primitives/PrimitiveInput.d.ts

@@ -0,0 +1,42 @@
+import { TextInput as RNTextInput, type TextInputProps as RNTextInputProps, type TextStyle } from 'react-native';
+/**
+ * Native `PrimitiveInput` — a bare RN `TextInput` driven by token-shaped
+ * text props, the input counterpart of `Text`.
+ *
+ * Deliberately *only* the text field: web's `PrimitiveInput` styles the
+ * `<input>` element itself with border and padding, but RN inputs carry
+ * leading/trailing slots, so the bordered container is a `Block` row that
+ * the field component owns and this primitive sits inside with `flex: 1`.
+ *
+ * Font family comes from the provider's role map (`body`), matching `Text`,
+ * and OS font scaling stays on per the package policy.
+ */
+export type PrimitiveInputProps = {
+    /** CSS string like `"14px"` or a number. */
+    fontSize?: string | number;
+    /** CSS font-weight keyword or numeric string (`"500"`). */
+    fontWeight?: string | number;
+    /** Text colour for the current state. */
+    color?: string;
+    /** CSS line-height like `"20px"` or a number. */
+    lineHeight?: string | number;
+    /** Placeholder colour for the current state. */
+    placeholderColor?: string;
+    style?: TextStyle;
+} & Omit<RNTextInputProps, 'style' | 'placeholderTextColor'>;
+/** Memoised — see the note on `Block`. */
+export declare const PrimitiveInput: import("react").NamedExoticComponent<{
+    /** CSS string like `"14px"` or a number. */
+    fontSize?: string | number;
+    /** CSS font-weight keyword or numeric string (`"500"`). */
+    fontWeight?: string | number;
+    /** Text colour for the current state. */
+    color?: string;
+    /** CSS line-height like `"20px"` or a number. */
+    lineHeight?: string | number;
+    /** Placeholder colour for the current state. */
+    placeholderColor?: string;
+    style?: TextStyle;
+} & Omit<RNTextInputProps, "style" | "placeholderTextColor"> & import("react").RefAttributes<RNTextInput>>;
+export default PrimitiveInput;
+//# sourceMappingURL=PrimitiveInput.d.ts.map

package/lib/typescript/commonjs/primitives/PrimitiveInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimitiveInput.d.ts","sourceRoot":"","sources":["../../../../src/primitives/PrimitiveInput.tsx"],"names":[],"mappings":"AACA,OAAO,EACH,SAAS,IAAI,WAAW,EAExB,KAAK,cAAc,IAAI,gBAAgB,EACvC,KAAK,SAAS,EACjB,MAAM,cAAc,CAAA;AAKrB;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,mBAAmB,GAAG;IAC9B,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC1B,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,gDAAgD;IAChD,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,KAAK,CAAC,EAAE,SAAS,CAAA;CACpB,GAAG,IAAI,CAAC,gBAAgB,EAAE,OAAO,GAAG,sBAAsB,CAAC,CAAA;AAoC5D,0CAA0C;AAC1C,eAAO,MAAM,cAAc;IAhDvB,4CAA4C;eACjC,MAAM,GAAG,MAAM;IAC1B,2DAA2D;iBAC9C,MAAM,GAAG,MAAM;IAC5B,yCAAyC;YACjC,MAAM;IACd,iDAAiD;iBACpC,MAAM,GAAG,MAAM;IAC5B,gDAAgD;uBAC7B,MAAM;YACjB,SAAS;0GAsCiC,CAAA;AAatD,eAAe,cAAc,CAAA"}

package/lib/typescript/commonjs/primitives/Separator.d.ts

@@ -0,0 +1,28 @@
+import { type ViewStyle } from 'react-native';
+/**
+ * Decorative divider.
+ *
+ * Native counterpart of web's `components/common/Seperator.tsx` — a fixed-size
+ * block of colour used to separate adjacent content. Alert renders one between
+ * its actions and its close button when the actions sit inline.
+ *
+ * Always hidden from assistive tech: it carries no information that the
+ * surrounding content does not already convey.
+ */
+export type SeparatorProps = {
+    /** Which way the line runs. Defaults to vertical, as Alert needs. */
+    orientation?: 'vertical' | 'horizontal';
+    /** Length along the run of the line. Token string or number. */
+    length?: string | number;
+    /** Thickness across the line. Token string or number. */
+    thickness?: string | number;
+    color?: string;
+    style?: ViewStyle;
+    testID?: string;
+};
+export declare function Separator({ orientation, length, thickness, color, style, testID, }: SeparatorProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Separator {
+    var displayName: string;
+}
+export default Separator;
+//# sourceMappingURL=Separator.d.ts.map

package/lib/typescript/commonjs/primitives/Separator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Separator.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Separator.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAI/D;;;;;;;;;GASG;AAEH,MAAM,MAAM,cAAc,GAAG;IACzB,qEAAqE;IACrE,WAAW,CAAC,EAAE,UAAU,GAAG,YAAY,CAAA;IACvC,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACxB,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAMD,wBAAgB,SAAS,CAAC,EACtB,WAAwB,EACxB,MAAuB,EACvB,SAA6B,EAC7B,KAAqB,EACrB,KAAK,EACL,MAAM,GACT,EAAE,cAAc,2CAsBhB;yBA7Be,SAAS;;;AAiCzB,eAAe,SAAS,CAAA"}

package/lib/typescript/commonjs/primitives/Slot.d.ts

@@ -0,0 +1,48 @@
+import React from 'react';
+import { type ViewStyle } from 'react-native';
+import { tintSlot } from './tintSlot';
+export { tintSlot };
+/**
+ * Leading / trailing icon slot.
+ *
+ * Shared by `Button` and `Tag`, both of which need identical behaviour and
+ * both of which previously got it wrong in the same three ways:
+ *
+ * 1. **Tinting.** On web, components pass `color` to `Block`, which maps to
+ *    CSS `color`, and SVG icons pick it up through `currentColor`. The native
+ *    `Block` mapped `color` to `backgroundColor`, so the same call painted a
+ *    solid rectangle *behind* the icon and never tinted the icon at all. RN
+ *    has no `currentColor`, so the tint has to be handed to the element
+ *    explicitly — that is what this component does.
+ * 2. **Per-slot `maxHeight`.** `leftSlot.maxHeight` / `rightSlot.maxHeight`
+ *    are part of the web prop contract and were ignored.
+ * 3. **Screen readers.** Web marks slots `aria-hidden` when the component
+ *    also renders text, so the icon is not announced separately from the
+ *    label. Native rendered them as visible accessibility nodes.
+ */
+export type SlotProps = {
+    /** The icon element to render. */
+    children?: React.ReactNode;
+    /**
+     * Colour to tint the icon with. Passed to the child as `color` (and
+     * `fill`, which `react-native-svg` elements use).
+     */
+    color?: string;
+    /**
+     * Max height for the icon box. Accepts token strings (`"16px"`),
+     * percentages (`"100%"`, used by Button's inline subType), or numbers.
+     */
+    maxHeight?: string | number;
+    /**
+     * Hide from screen readers. Should be `true` whenever the parent also
+     * renders a text label, matching web's `aria-hidden`.
+     */
+    hidden?: boolean;
+    style?: ViewStyle;
+    testID?: string;
+};
+declare function SlotImpl({ children, color, maxHeight, hidden, style, testID, }: SlotProps): import("react/jsx-runtime").JSX.Element | null;
+/** Memoised — see the note on `Block`. */
+export declare const Slot: React.MemoExoticComponent<typeof SlotImpl>;
+export default Slot;
+//# sourceMappingURL=Slot.d.ts.map

package/lib/typescript/commonjs/primitives/Slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slot.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Slot.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAe,MAAM,OAAO,CAAA;AACnC,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAE/D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,OAAO,EAAE,QAAQ,EAAE,CAAA;AAEnB;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,SAAS,GAAG;IACpB,kCAAkC;IAClC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,iBAAS,QAAQ,CAAC,EACd,QAAQ,EACR,KAAK,EACL,SAAS,EACT,MAAc,EACd,KAAK,EACL,MAAM,GACT,EAAE,SAAS,kDAuBX;AAED,0CAA0C;AAC1C,eAAO,MAAM,IAAI,4CAAiB,CAAA;AAYlC,eAAe,IAAI,CAAA"}

package/lib/typescript/commonjs/primitives/Text.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import { type TextProps as RNTextProps, type TextStyle } from 'react-native';
+import type { NativeFontRole } from '../theme/fonts';
+/**
+ * Native `Text` — renders a RN `Text` from token-driven style props.
+ *
+ * Mirrors the web `Text` component's API (`fontSize`, `fontWeight`, `color`,
+ * `lineHeight`, `textAlign`) but accepts CSS-string values directly from
+ * Blend tokens and translates them to `TextStyle` numbers.
+ *
+ * **Font family** comes from the provider's resolved role map (web has CSS
+ * inheritance; RN does not, so the provider is the inheritance mechanism).
+ * Defaults to the `body` role; `fontRole` picks another role and an explicit
+ * `fontFamily` wins outright.
+ *
+ * **Font scaling** is deliberately left ON (RN's default). The package policy
+ * is to respect OS Dynamic Type and let controls grow — components size with
+ * `minHeight`, never a fixed `height`, so scaled text expands the control
+ * instead of clipping. Consumers needing a cap can pass RN's own
+ * `maxFontSizeMultiplier` through `...rest`.
+ */
+export type BlendTextProps = {
+    children?: React.ReactNode;
+    /** CSS string like `"14px"` or a number. */
+    fontSize?: string | number;
+    /** CSS font-weight keyword or number (`"500"`, `500`, `"bold"`). */
+    fontWeight?: string | number;
+    color?: string;
+    /** CSS line-height like `"20px"` or a number. */
+    lineHeight?: string | number;
+    textAlign?: 'left' | 'right' | 'center' | 'justify';
+    /**
+     * Explicit font family. Overrides the provider's role map; rarely needed
+     * outside consumer escape hatches.
+     */
+    fontFamily?: string;
+    /** Which provider font role to use when `fontFamily` is not given. */
+    fontRole?: NativeFontRole;
+    /** Set true to hide from screen readers (web `aria-hidden`). */
+    'aria-hidden'?: boolean;
+    /** Flex display — web `Text` is sometimes `inline`; on RN Text is always inline. */
+    as?: string;
+} & Omit<RNTextProps, 'style'> & {
+    style?: TextStyle;
+};
+declare function TextImpl({ children, fontSize, fontWeight, color, lineHeight, textAlign, fontFamily, fontRole, style, ...rest }: BlendTextProps): import("react/jsx-runtime").JSX.Element;
+/** Memoised — see the note on `Block`. */
+export declare const Text: React.MemoExoticComponent<typeof TextImpl>;
+export default Text;
+//# sourceMappingURL=Text.d.ts.map

package/lib/typescript/commonjs/primitives/Text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Text.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Text.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA2B,MAAM,OAAO,CAAA;AAC/C,OAAO,EAGH,KAAK,SAAS,IAAI,WAAW,EAC7B,KAAK,SAAS,EACjB,MAAM,cAAc,CAAA;AAIrB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,cAAc,GAAG;IACzB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC1B,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAA;IACnD;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB,gEAAgE;IAChE,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,oFAAoF;IACpF,EAAE,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,GAAG;IACzB,KAAK,CAAC,EAAE,SAAS,CAAA;CACpB,CAAA;AAEL,iBAAS,QAAQ,CAAC,EACd,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,KAAK,EACL,UAAU,EACV,SAAS,EACT,UAAU,EACV,QAAiB,EACjB,KAAK,EACL,GAAG,IAAI,EACV,EAAE,cAAc,2CAoBhB;AAED,0CAA0C;AAC1C,eAAO,MAAM,IAAI,4CAAiB,CAAA;AAOlC,eAAe,IAAI,CAAA"}

package/lib/typescript/commonjs/primitives/pressFeedback.d.ts

@@ -0,0 +1,39 @@
+import type { ViewStyle } from 'react-native';
+/**
+ * Press feedback is platform-idiomatic, not uniform.
+ *
+ * Web scales the surface by `0.99`, and that reads correctly on iOS where a
+ * subtle depress is the convention. Android users expect a **ripple**, and a
+ * scale transform there looks like a bug. Applying both would double the
+ * feedback.
+ *
+ * The decision lives here — a leaf module with no `react-native` value import
+ * — so it is unit-testable outside a renderer, the same split as
+ * `theme/breakpoint.ts`, `primitives/touchTarget.ts` and the shadow handling
+ * in `adapters/surfaceStyle.ts`. `Pressable` passes the real `Platform.OS`.
+ */
+export type PressFeedbackPlatform = 'ios' | 'android' | 'web' | 'windows' | 'macos';
+export type AndroidRipple = {
+    color: string;
+    borderless: boolean;
+};
+export type PressFeedback = {
+    /** Passed to RN's `android_ripple`; `undefined` off Android. */
+    androidRipple?: AndroidRipple;
+    /** Style merged in while pressed; empty on Android, where the ripple carries it. */
+    pressedTransform: ViewStyle;
+};
+/**
+ * Ripple colour used when neither the caller nor the active-state token
+ * supplies one. Low-alpha black is Android's own default for light surfaces.
+ */
+export declare const DEFAULT_RIPPLE_COLOR = "rgba(0, 0, 0, 0.12)";
+export declare function resolvePressFeedback(platform: PressFeedbackPlatform, options?: {
+    /** Explicit ripple colour from the caller. */
+    rippleColor?: string;
+    /** Active-state background token, used when no explicit colour is set. */
+    activeBackgroundColor?: string;
+    rippleBorderless?: boolean;
+    pressedScale?: number;
+}): PressFeedback;
+//# sourceMappingURL=pressFeedback.d.ts.map

package/lib/typescript/commonjs/primitives/pressFeedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pressFeedback.d.ts","sourceRoot":"","sources":["../../../../src/primitives/pressFeedback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C;;;;;;;;;;;;GAYG;AAEH,MAAM,MAAM,qBAAqB,GAC3B,KAAK,GACL,SAAS,GACT,KAAK,GACL,SAAS,GACT,OAAO,CAAA;AAEb,MAAM,MAAM,aAAa,GAAG;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,OAAO,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IACxB,gEAAgE;IAChE,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,oFAAoF;IACpF,gBAAgB,EAAE,SAAS,CAAA;CAC9B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,wBAAwB,CAAA;AAEzD,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,GAAE;IACL,8CAA8C;IAC9C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,0EAA0E;IAC1E,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAA;CACnB,GACP,aAAa,CA0Bf"}

package/lib/typescript/commonjs/primitives/textStyle.d.ts

@@ -0,0 +1,13 @@
+import type { TextStyle } from 'react-native';
+/**
+ * Shared text-style resolution for `Text` and `PrimitiveInput`.
+ *
+ * Leaf module with only a type import from `react-native`, so it stays
+ * vitest-testable — the `theme/breakpoint.ts` pattern.
+ */
+/**
+ * Resolve a CSS font-weight value to a RN-compatible `TextStyle['fontWeight']`.
+ * RN accepts `'normal' | 'bold' | '100'..'900'` (as string or number).
+ */
+export declare function resolveFontWeight(w: string | number | undefined): TextStyle['fontWeight'];
+//# sourceMappingURL=textStyle.d.ts.map

package/lib/typescript/commonjs/primitives/textStyle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textStyle.d.ts","sourceRoot":"","sources":["../../../../src/primitives/textStyle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C;;;;;GAKG;AAEH;;;GAGG;AACH,wBAAgB,iBAAiB,CAC7B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAC/B,SAAS,CAAC,YAAY,CAAC,CAQzB"}

package/lib/typescript/commonjs/primitives/tintSlot.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+/**
+ * Apply a tint to an icon element.
+ *
+ * Only sets `color`, and only when the element has not set it explicitly —
+ * an icon rendered as `<Icon color="red" />` keeps red. Non-element children
+ * (a bare string, a number, `null`) are returned untouched.
+ */
+export declare function tintSlot(node: ReactNode, color: string | undefined): ReactNode;
+//# sourceMappingURL=tintSlot.d.ts.map

package/lib/typescript/commonjs/primitives/tintSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tintSlot.d.ts","sourceRoot":"","sources":["../../../../src/primitives/tintSlot.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,OAAO,CAAA;AAyBpD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACpB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,MAAM,GAAG,SAAS,GAC1B,SAAS,CAOX"}

package/lib/typescript/commonjs/primitives/touchTarget.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Minimum tap-target policy.
+ *
+ * Kept in its own leaf module — importing nothing from `react-native` — so it
+ * stays unit-testable outside a renderer. (RN's entrypoint ships Flow syntax
+ * that non-Metro bundlers cannot parse, so any module that value-imports it is
+ * unusable from a plain Node test runner. Same split as `theme/breakpoint.ts`.)
+ */
+/** Inset applied to each edge of the touch region. */
+export type HitSlop = {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+/**
+ * Apple's Human Interface Guidelines minimum tappable size, in points. Also
+ * clears Material's 48dp target once RN's density conversion is applied.
+ */
+export declare const MIN_TOUCH_TARGET = 44;
+/**
+ * Slop needed to bring a rendered control up to the minimum tap target.
+ *
+ * Design-system controls are frequently smaller than the guideline by intent —
+ * an `xs` Tag is 20pt tall — so the fix is to widen the *touch* region rather
+ * than the control. Returns `undefined` when the control already complies (or
+ * when the minimum is disabled with `0`), so no `hitSlop` prop is emitted.
+ *
+ * ```
+ * resolveHitSlop(120, 48) -> undefined          // already compliant
+ * resolveHitSlop(60, 20)  -> { top: 12, bottom: 12, left: 0, right: 0 }
+ * resolveHitSlop(24, 24)  -> { top: 10, bottom: 10, left: 10, right: 10 }
+ * ```
+ */
+export declare function resolveHitSlop(width: number, height: number, minTouchTarget?: number): HitSlop | undefined;
+/**
+ * Whether two slop values are equivalent.
+ *
+ * Lets callers skip a state update when a re-measure produces the same result,
+ * which keeps a control that never needed slop from re-rendering at all.
+ */
+export declare function sameHitSlop(a?: HitSlop, b?: HitSlop): boolean;
+//# sourceMappingURL=touchTarget.d.ts.map

package/lib/typescript/commonjs/primitives/touchTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touchTarget.d.ts","sourceRoot":"","sources":["../../../../src/primitives/touchTarget.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,sDAAsD;AACtD,MAAM,MAAM,OAAO,GAAG;IAClB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,KAAK,CAAA;AAElC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,cAAc,GAAE,MAAyB,GAC1C,OAAO,GAAG,SAAS,CAarB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAS7D"}

package/lib/typescript/commonjs/theme/BlendNativeProvider.d.ts

@@ -0,0 +1,69 @@
+import React from 'react';
+import { FOUNDATION_THEME, Theme, type BreakpointType } from '@juspay/blend-design-system/node';
+import type { NativeComponentTokenOverrides } from './nativeTokenRegistry';
+import { type NativeFontFamilies, type NativeFontFamilyOption } from './fonts';
+import { SYSTEM_THEME, type NativeThemeSetting } from './systemTheme';
+/**
+ * Theme context for `blend-native`.
+ *
+ * Replaces the per-component `theme` prop the package shipped with. A prop
+ * meant no app-wide dark mode (every call site had to thread it), no nested
+ * theme scopes, and — most importantly — no `componentTokens` overrides,
+ * which is a first-class feature of web Blend that native consumers simply
+ * did not have.
+ *
+ * Mirrors web's `ThemeProvider` API (`{ theme, componentTokens,
+ * foundationTokens }`) so the two platforms are configured the same way, and
+ * like web it is optional: components fall back to these defaults when no
+ * provider is mounted.
+ *
+ * Two native-only additions:
+ *
+ * - `theme="system"` follows the OS appearance via `useColorScheme`,
+ *   re-rendering when the user flips light/dark. The sentinel is resolved
+ *   *before* the value enters context, so consumers only ever see a concrete
+ *   theme.
+ * - `fontFamily` resolves one font family per role (see `theme/fonts.ts`) —
+ *   RN's replacement for web's CSS font inheritance.
+ */
+export type BlendNativeThemeValue = {
+    theme: Theme | string;
+    componentTokens: NativeComponentTokenOverrides;
+    foundationTokens: typeof FOUNDATION_THEME;
+    breakpoints: BreakpointType;
+    /** Resolved family per role; `null` leaves the platform font. */
+    fontFamily: NativeFontFamilies;
+};
+export declare const DEFAULT_NATIVE_THEME: BlendNativeThemeValue;
+export declare const BlendNativeThemeContext: React.Context<BlendNativeThemeValue>;
+export type BlendNativeProviderProps = {
+    children?: React.ReactNode;
+    /**
+     * `'light' | 'dark' | 'system'`. Defaults to light. `'system'` follows
+     * the OS appearance setting.
+     */
+    theme?: NativeThemeSetting;
+    /**
+     * Partial per-slot token overrides, deep-merged onto the active theme's
+     * defaults. Supply only the paths you want to change — every untouched
+     * path keeps its light/dark value.
+     */
+    componentTokens?: NativeComponentTokenOverrides;
+    /** Override foundation tokens (colours, spacing, radii, ...). */
+    foundationTokens?: typeof FOUNDATION_THEME;
+    /** Override breakpoint thresholds. */
+    breakpoints?: BreakpointType;
+    /**
+     * Font families per role. Defaults to the foundation `font.family`
+     * tokens; pass `'system'` for platform fonts, or a partial map to
+     * override/disable individual roles. See `theme/fonts.ts`.
+     */
+    fontFamily?: NativeFontFamilyOption;
+};
+export declare function BlendNativeProvider({ children, theme, componentTokens, foundationTokens, breakpoints, fontFamily, }: BlendNativeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace BlendNativeProvider {
+    var displayName: string;
+}
+export { SYSTEM_THEME };
+export default BlendNativeProvider;
+//# sourceMappingURL=BlendNativeProvider.d.ts.map

package/lib/typescript/commonjs/theme/BlendNativeProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlendNativeProvider.d.ts","sourceRoot":"","sources":["../../../../src/theme/BlendNativeProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAiC,MAAM,OAAO,CAAA;AAErD,OAAO,EAEH,gBAAgB,EAChB,KAAK,EACL,KAAK,cAAc,EACtB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAA;AAG1E,OAAO,EAEH,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC9B,MAAM,SAAS,CAAA;AAChB,OAAO,EAEH,YAAY,EACZ,KAAK,kBAAkB,EAC1B,MAAM,eAAe,CAAA;AAEtB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,MAAM,qBAAqB,GAAG;IAChC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAA;IACrB,eAAe,EAAE,6BAA6B,CAAA;IAC9C,gBAAgB,EAAE,OAAO,gBAAgB,CAAA;IACzC,WAAW,EAAE,cAAc,CAAA;IAC3B,iEAAiE;IACjE,UAAU,EAAE,kBAAkB,CAAA;CACjC,CAAA;AAID,eAAO,MAAM,oBAAoB,EAAE,qBAMlC,CAAA;AAED,eAAO,MAAM,uBAAuB,sCAC0B,CAAA;AAE9D,MAAM,MAAM,wBAAwB,GAAG;IACnC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B;;;OAGG;IACH,KAAK,CAAC,EAAE,kBAAkB,CAAA;IAC1B;;;;OAIG;IACH,eAAe,CAAC,EAAE,6BAA6B,CAAA;IAC/C,iEAAiE;IACjE,gBAAgB,CAAC,EAAE,OAAO,gBAAgB,CAAA;IAC1C,sCAAsC;IACtC,WAAW,CAAC,EAAE,cAAc,CAAA;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,sBAAsB,CAAA;CACtC,CAAA;AAED,wBAAgB,mBAAmB,CAAC,EAChC,QAAQ,EACR,KAAmB,EACnB,eAAiC,EACjC,gBAAmC,EACnC,WAAyB,EACzB,UAAU,GACb,EAAE,wBAAwB,2CAwC1B;yBA/Ce,mBAAmB;;;AAmDnC,OAAO,EAAE,YAAY,EAAE,CAAA;AAEvB,eAAe,mBAAmB,CAAA"}

package/lib/typescript/commonjs/theme/breakpoint.d.ts

@@ -0,0 +1,27 @@
+import { type BreakpointType } from '@juspay/blend-design-system/node';
+/**
+ * Pure breakpoint resolution.
+ *
+ * Kept in its own leaf module — importing nothing from `react-native` — so it
+ * stays testable and reusable outside a React render. `useNativeBreakpoint`
+ * layers the `useWindowDimensions` subscription on top.
+ *
+ * (React Native's entrypoint ships Flow syntax that non-Metro bundlers cannot
+ * parse, so any module that value-imports it is unusable from a plain Node
+ * test runner. Splitting the logic out is the same pattern the web package
+ * uses for `shared/datetime/timeCore.ts`.)
+ */
+export type NativeBreakpoint = keyof BreakpointType;
+/**
+ * Resolve a viewport width to a Blend breakpoint label.
+ *
+ * Mirrors web's `useBreakPoints` exactly, including its quirk: **only**
+ * 320–1023 maps to `'sm'`; everything else — including widths below 320 —
+ * returns `'lg'`. Reproduced deliberately so a given width resolves to the
+ * same tokens on both platforms.
+ *
+ * Thresholds come from `BREAKPOINTS` in the web package rather than being
+ * duplicated, so retuning them stays a one-line change in one place.
+ */
+export declare function resolveBreakpoint(width: number, breakpoints?: BreakpointType): NativeBreakpoint;
+//# sourceMappingURL=breakpoint.d.ts.map

package/lib/typescript/commonjs/theme/breakpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breakpoint.d.ts","sourceRoot":"","sources":["../../../../src/theme/breakpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,KAAK,cAAc,EACtB,MAAM,kCAAkC,CAAA;AAEzC;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,gBAAgB,GAAG,MAAM,cAAc,CAAA;AAEnD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC7B,KAAK,EAAE,MAAM,EACb,WAAW,GAAE,cAA4B,GAC1C,gBAAgB,CAGlB"}

package/lib/typescript/commonjs/theme/fonts.d.ts

@@ -0,0 +1,34 @@
+import { FOUNDATION_THEME } from '@juspay/blend-design-system/node';
+/**
+ * Font-family policy.
+ *
+ * Web never applies Blend's font tokens — components inherit whatever face the
+ * host document loads (`fontFamily: 'inherit'` in the primitives), and the
+ * consuming app supplies InterDisplay via `@font-face`. React Native has no
+ * inheritance and no `@font-face`, so the provider is the inheritance
+ * mechanism: it resolves one family per role and `Text` applies it.
+ *
+ * Defaults come from the foundation tokens (`font.family`), so out of the box
+ * native asks for the same faces the design system names. A consumer that has
+ * not loaded those fonts sees the platform fallback (plus a dev warning on
+ * iOS) — load them with `expo-font` or native assets, or opt out:
+ *
+ * - `fontFamily="system"` — platform fonts everywhere, no families applied.
+ * - `fontFamily={{ mono: 'JetBrainsMono' }}` — override one role, keep the
+ *   token defaults for the rest.
+ * - `fontFamily={{ body: null }}` — disable one role only.
+ *
+ * Kept as a leaf module with no `react-native` value import so it stays
+ * testable under plain vitest — the same constraint as `theme/breakpoint.ts`.
+ */
+export type NativeFontRole = 'display' | 'body' | 'heading' | 'mono';
+/** One resolved family per role; `null` means "leave the platform font". */
+export type NativeFontFamilies = Record<NativeFontRole, string | null>;
+/** What `BlendNativeProvider` accepts for its `fontFamily` prop. */
+export type NativeFontFamilyOption = 'system' | Partial<Record<NativeFontRole, string | null>>;
+/**
+ * Resolve the provider's `fontFamily` option against the active foundation
+ * tokens. Pure; called once per provider render.
+ */
+export declare function resolveFontFamilies(foundationTokens?: typeof FOUNDATION_THEME, option?: NativeFontFamilyOption): NativeFontFamilies;
+//# sourceMappingURL=fonts.d.ts.map

package/lib/typescript/commonjs/theme/fonts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fonts.d.ts","sourceRoot":"","sources":["../../../../src/theme/fonts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAEnE;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAA;AAEpE,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;AAEtE,oEAAoE;AACpE,MAAM,MAAM,sBAAsB,GAC5B,QAAQ,GACR,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAA;AAIpD;;;GAGG;AACH,wBAAgB,mBAAmB,CAC/B,gBAAgB,GAAE,OAAO,gBAAmC,EAC5D,MAAM,CAAC,EAAE,sBAAsB,GAChC,kBAAkB,CAkBpB"}

package/lib/typescript/commonjs/theme/nativeTokenRegistry.d.ts

@@ -0,0 +1,34 @@
+import { FOUNDATION_THEME, Theme, type BreakpointType } from '@juspay/blend-design-system/node';
+/**
+ * Slot name → token factory.
+ *
+ * **This is the only file to edit when adding a component.** Web needs three
+ * files changed in lockstep for a new token slot (`context/ThemeContext.tsx`
+ * for the type + default, `context/initComponentTokens.ts` for the `??`
+ * fallback, `context/useComponentToken.ts` for the union and `switch` case) —
+ * and missing one throws at runtime. Native collapses that to a single
+ * registry entry, with the slot union derived from the object rather than
+ * hand-maintained alongside it.
+ *
+ * Factories come from `@juspay/blend-design-system/node`, the React-free
+ * entry, so registering one pulls in no UI code.
+ */
+export declare const NATIVE_TOKEN_REGISTRY: {
+    readonly ALERTV2: (foundationToken: import("@juspay/blend-design-system/node").FoundationTokenType, theme?: Theme | string) => import("@juspay/blend-design-system/node").ResponsiveAlertV2Tokens;
+    readonly BUTTONV2: (foundationToken: import("@juspay/blend-design-system/node").FoundationTokenType, theme?: Theme | string) => import("@juspay/blend-design-system/node").ResponsiveButtonV2Tokens;
+    readonly SKELETON: (foundationToken: import("@juspay/blend-design-system/node").FoundationTokenType, theme?: Theme | string) => import("@juspay/blend-design-system/node").ResponsiveSkeletonTokens;
+    readonly TAGV2: (foundationToken: import("@juspay/blend-design-system/node").FoundationTokenType, theme?: Theme | string) => import("@juspay/blend-design-system/node").ResponsiveTagV2Tokens;
+    readonly TEXT_INPUTV2: (foundationToken: import("@juspay/blend-design-system/node").FoundationTokenType, theme?: Theme | string) => import("@juspay/blend-design-system/node").ResponsiveTextInputV2Tokens;
+};
+/** Every component slot native can resolve. Derived, never hand-written. */
+export type NativeTokenSlot = keyof typeof NATIVE_TOKEN_REGISTRY;
+/**
+ * A Blend token factory: pure, takes foundation tokens plus a theme, and
+ * returns one token object per breakpoint.
+ */
+export type TokenFactory<T> = (foundation: typeof FOUNDATION_THEME, theme?: Theme | string) => Record<keyof BreakpointType, T>;
+/** Overrides accepted by `BlendNativeProvider`, keyed by slot. */
+export type NativeComponentTokenOverrides = Partial<Record<NativeTokenSlot, unknown>>;
+export declare const NATIVE_TOKEN_SLOTS: NativeTokenSlot[];
+export declare function isNativeTokenSlot(value: string): value is NativeTokenSlot;
+//# sourceMappingURL=nativeTokenRegistry.d.ts.map