@webority-technologies/mobile-ui 0.0.1

package/lib/typescript/module/form/FormContext.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { FormApi, FormValues } from './types.js';
+export interface FormProps {
+    /** The object returned by {@link useForm}. */
+    form: FormApi<FormValues>;
+    children: React.ReactNode;
+}
+/**
+ * Provides a {@link useForm} instance to descendants so `<FormField name>`,
+ * {@link useField} and {@link useFieldArray} can bind by name.
+ */
+export declare const Form: React.FC<FormProps>;
+/** Read the surrounding form. Throws if there is no `<Form>` ancestor. */
+export declare function useFormContext<Values extends FormValues = FormValues>(): FormApi<Values>;
+/** Read the surrounding form, or null when there is no `<Form>` ancestor. */
+export declare function useOptionalFormContext(): FormApi<FormValues> | null;
+//# sourceMappingURL=FormContext.d.ts.map

package/lib/typescript/module/form/index.d.ts

@@ -0,0 +1,10 @@
+export type { FormProps } from './FormContext.js';
+export { Form, useFormContext, useOptionalFormContext } from './FormContext.js';
+export { deletePath, getPath, setPath } from './path.js';
+import * as rules from './rules.js';
+export type { FieldInputProps, FieldRules, FieldState, FocusableNode, FormApi, FormConfig, FormErrors, FormTouched, FormValidateFn, FormValues, SubmitHelpers, ValidateOn, ValidationResult, ValidationRule, ValidationSchema } from './types.js';
+export type { FieldArrayApi } from './useField.js';
+export { useField, useFieldArray } from './useField.js';
+export { useForm } from './useForm.js';
+export { rules };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/form/path.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Immutable get/set/delete for dot- and bracket-notation field paths
+ * ("address.city", "phones[0]", "items[2].qty"). Lets a single flat `name`
+ * string address nested values and array items, so the form engine can treat
+ * every field uniformly regardless of how deep it lives in the value tree.
+ */
+export declare const getPath: (obj: unknown, path: string) => unknown;
+export declare const setPath: <T>(obj: T, path: string, value: unknown) => T;
+export declare const deletePath: <T>(obj: T, path: string) => T;
+//# sourceMappingURL=path.d.ts.map

package/lib/typescript/module/form/rules.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Validation rule presets — the dependency-free replacement for Yup chains.
+ * Each factory returns a {@link ValidationRule}. Rules built on the project's
+ * `validators` module skip empty values (so `required()` owns emptiness and you
+ * don't get duplicate errors), and accept an optional custom message.
+ */
+import type { PasswordRules } from '@webority-technologies/mobile-core';
+import type { FormValues, ValidationRule } from './types.js';
+export declare const required: (message?: string) => ValidationRule;
+export declare const email: (message?: string) => ValidationRule;
+export declare const mobile: (message?: string) => ValidationRule;
+export declare const phone: (message?: string) => ValidationRule;
+export declare const url: (message?: string) => ValidationRule;
+export declare const numeric: (message?: string) => ValidationRule;
+export declare const integer: (message?: string) => ValidationRule;
+export declare const alphanumeric: (message?: string) => ValidationRule;
+export declare const pincode: (message?: string) => ValidationRule;
+export declare const pan: (message?: string) => ValidationRule;
+export declare const gstin: (message?: string) => ValidationRule;
+export declare const aadhaar: (message?: string) => ValidationRule;
+export declare const ifsc: (message?: string) => ValidationRule;
+export declare const minLength: (length: number, message?: string) => ValidationRule;
+export declare const maxLength: (length: number, message?: string) => ValidationRule;
+export declare const min: (n: number, message?: string) => ValidationRule;
+export declare const max: (n: number, message?: string) => ValidationRule;
+export declare const pattern: (regex: RegExp, message?: string) => ValidationRule;
+export declare const oneOf: (allowed: readonly unknown[], message?: string) => ValidationRule;
+/** Cross-field equality (e.g. confirm-password). `otherField` is a field path. */
+export declare const matches: (otherField: string, message?: string) => ValidationRule<unknown, FormValues>;
+export declare const strongPassword: (rules?: PasswordRules, message?: string) => ValidationRule;
+/**
+ * Wrap any custom check. Return `true` (valid), `false` (invalid → default
+ * message), or a string (invalid → that message). Async is supported — return
+ * a Promise of the same.
+ */
+export declare const custom: <V = unknown>(fn: (value: V, allValues: FormValues) => boolean | string | Promise<boolean | string>, message?: string) => ValidationRule<V>;
+//# sourceMappingURL=rules.d.ts.map

package/lib/typescript/module/form/types.d.ts

@@ -0,0 +1,94 @@
+export type FormValues = Record<string, unknown>;
+export type FormErrors = Record<string, string | undefined>;
+export type FormTouched = Record<string, boolean>;
+export type ValidationResult = string | undefined | null | false;
+/**
+ * A single validation rule. Receives the field value and the whole values
+ * object (so cross-field rules work). Return an error message string when
+ * invalid, or any falsy value when valid. May be async — return a Promise for
+ * server-side checks ("is this email already registered?").
+ */
+export type ValidationRule<V = any, Values extends FormValues = FormValues> = (value: V, allValues: Values) => ValidationResult | Promise<ValidationResult>;
+export type FieldRules<V = any, Values extends FormValues = FormValues> = ValidationRule<V, Values> | ValidationRule<V, Values>[];
+/** Per-field rule map keyed by field path (e.g. `{ email: [rules.required(), rules.email()] }`). */
+export type ValidationSchema<Values extends FormValues = FormValues> = Record<string, FieldRules<any, Values>>;
+/** Form-level validate function returning an errors map keyed by field path. */
+export type FormValidateFn<Values extends FormValues = FormValues> = (values: Values) => FormErrors | Promise<FormErrors>;
+export type ValidateOn = 'change' | 'blur' | 'submit';
+export interface SubmitHelpers<Values extends FormValues = FormValues> {
+    setErrors: (errors: FormErrors) => void;
+    setFieldError: (name: string, error?: string) => void;
+    reset: (nextValues?: Partial<Values>) => void;
+    setSubmitting: (submitting: boolean) => void;
+}
+export interface FormConfig<Values extends FormValues = FormValues> {
+    initialValues: Values;
+    /** Either a per-field rule map or a single form-level validate function. */
+    validate?: ValidationSchema<Values> | FormValidateFn<Values>;
+    /** When validation first runs for a field. Library default: 'submit'. */
+    validateOn?: ValidateOn;
+    /** After a field has surfaced an error once, how it re-validates. Library default: 'change'. */
+    revalidateOn?: 'change' | 'blur';
+    onSubmit: (values: Values, helpers: SubmitHelpers<Values>) => void | Promise<void>;
+    /** Re-initialise values when `initialValues` changes (e.g. async-loaded edit form). Default: false. */
+    enableReinitialize?: boolean;
+}
+export interface FieldState<V = unknown> {
+    value: V;
+    /** Error the UI should show (gated by touched / submit). */
+    error: string | undefined;
+    /** Error regardless of touched — useful for `isValid`-style logic. */
+    rawError: string | undefined;
+    touched: boolean;
+    dirty: boolean;
+}
+/** Props an input needs to bind to a form field. Covers text and non-text controls. */
+export interface FieldInputProps<V = unknown> {
+    name: string;
+    value: V;
+    error: string | undefined;
+    touched: boolean;
+    /** Generic change handler (Select/Switch/DatePicker/Slider…). */
+    onChange: (value: V) => void;
+    /** Text-input alias of `onChange` (TextInput's `onChangeText`). */
+    onChangeText: (text: string) => void;
+    onBlur: () => void;
+    /** Marks this field as the focused one (drives KeyboardToolbar next/prev). */
+    onFocus: () => void;
+    setValue: (value: V, shouldValidate?: boolean) => void;
+}
+export interface FocusableNode {
+    focus?: () => void;
+    measureInWindow?: (cb: (x: number, y: number, w: number, h: number) => void) => void;
+}
+export interface FormApi<Values extends FormValues = FormValues> {
+    values: Values;
+    /** Touched/submit-gated errors — what the UI shows. */
+    errors: FormErrors;
+    /** Every current error regardless of touched. */
+    rawErrors: FormErrors;
+    touched: FormTouched;
+    dirty: boolean;
+    isValid: boolean;
+    isSubmitting: boolean;
+    isValidating: boolean;
+    submitCount: number;
+    setFieldValue: (name: string, value: unknown, shouldValidate?: boolean) => void;
+    setFieldTouched: (name: string, touched?: boolean, shouldValidate?: boolean) => void;
+    setFieldError: (name: string, error?: string) => void;
+    setValues: (next: Partial<Values> | ((prev: Values) => Values), shouldValidate?: boolean) => void;
+    setErrors: (errors: FormErrors) => void;
+    reset: (nextValues?: Partial<Values>) => void;
+    validate: () => Promise<FormErrors>;
+    validateField: (name: string) => Promise<string | undefined>;
+    submit: () => void;
+    getFieldState: (name: string) => FieldState;
+    getFieldProps: (name: string) => FieldInputProps;
+    handleBlur: (name: string) => void;
+    /** Move focus to the next / previous registered field (used by KeyboardToolbar). */
+    focusNext: () => void;
+    focusPrev: () => void;
+    /** Registers a focusable node so a failed submit can focus the first error. */
+    registerField: (name: string, node: FocusableNode | null) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/module/form/useField.d.ts

@@ -0,0 +1,27 @@
+import type { FieldInputProps } from './types.js';
+/**
+ * Bind a single field by name. Returns everything an input needs; pick the
+ * handler your control uses:
+ *   const email = useField('email');
+ *   <Input value={email.value} onChangeText={email.onChangeText} onBlur={email.onBlur} error={email.error} />
+ *   <Select value={country.value} onChange={country.onChange} error={country.error} />
+ *   <Switch value={!!agree.value} onChange={agree.onChange} />
+ */
+export declare function useField<V = unknown>(name: string): FieldInputProps<V>;
+export interface FieldArrayApi<T = unknown> {
+    /** Current array value (empty array when unset). */
+    fields: T[];
+    length: number;
+    push: (item: T) => void;
+    remove: (index: number) => void;
+    insert: (index: number, item: T) => void;
+    move: (from: number, to: number) => void;
+    replace: (index: number, item: T) => void;
+}
+/**
+ * Manage a repeating list field (phone numbers, line items, etc.) by name.
+ * Each helper writes the whole array back through the form so validation and
+ * dirty-tracking stay correct.
+ */
+export declare function useFieldArray<T = unknown>(name: string): FieldArrayApi<T>;
+//# sourceMappingURL=useField.d.ts.map

package/lib/typescript/module/form/useForm.d.ts

@@ -0,0 +1,10 @@
+import type { FormApi, FormConfig, FormValues } from './types.js';
+/**
+ * Dependency-free form engine. Tracks values/errors/touched/dirty, runs
+ * synchronous and async validation (per-field rule maps or a form-level
+ * function), gates error display behind touched/submit, and on a failed submit
+ * focuses the first errored field. The returned object is rebuilt every render
+ * so `<Form>` consumers re-render on state changes.
+ */
+export declare function useForm<Values extends FormValues = FormValues>(config: FormConfig<Values>): FormApi<Values>;
+//# sourceMappingURL=useForm.d.ts.map

package/lib/typescript/module/hooks/index.d.ts

@@ -0,0 +1,9 @@
+export type { UseControllableStateOptions } from './useControllableState.js';
+export { useControllableState } from './useControllableState.js';
+export { useDebounce } from './useDebounce.js';
+export type { UsePressAnimationOptions, UsePressAnimationResult } from './usePressAnimation.js';
+export { usePressAnimation } from './usePressAnimation.js';
+export { useReducedMotion } from './useReducedMotion.js';
+export type { UseToggleResult } from './useToggle.js';
+export { useToggle } from './useToggle.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/hooks/useControllableState.d.ts

@@ -0,0 +1,17 @@
+export interface UseControllableStateOptions<T> {
+    /** Controlled value. When `undefined`, the hook manages state internally. */
+    value?: T;
+    /** Initial value used in uncontrolled mode. */
+    defaultValue: T;
+    /** Called on every change (both modes). */
+    onChange?: (value: T) => void;
+}
+/**
+ * Bridges controlled and uncontrolled usage for a value+onChange pair. When
+ * `value` is provided the component is controlled (the hook just forwards it
+ * and calls `onChange`); otherwise the hook owns the state, seeded from
+ * `defaultValue`. The controlled/uncontrolled decision is locked on first
+ * render so a component never flips modes mid-life.
+ */
+export declare function useControllableState<T>({ value, defaultValue, onChange }: UseControllableStateOptions<T>): [T, (next: T) => void];
+//# sourceMappingURL=useControllableState.d.ts.map

package/lib/typescript/module/hooks/useDebounce.d.ts

@@ -0,0 +1,2 @@
+export declare const useDebounce: <T>(value: T, delay?: number) => T;
+//# sourceMappingURL=useDebounce.d.ts.map

package/lib/typescript/module/hooks/usePressAnimation.d.ts

@@ -0,0 +1,13 @@
+import { Animated } from 'react-native';
+export interface UsePressAnimationOptions {
+    scaleTo?: number;
+    pressDuration?: number;
+    enabled?: boolean;
+}
+export interface UsePressAnimationResult {
+    scale: Animated.Value;
+    pressIn: () => void;
+    pressOut: () => void;
+}
+export declare const usePressAnimation: ({ scaleTo, pressDuration, enabled }?: UsePressAnimationOptions) => UsePressAnimationResult;
+//# sourceMappingURL=usePressAnimation.d.ts.map

package/lib/typescript/module/hooks/useReducedMotion.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tracks the OS "Reduce Motion" accessibility setting. The library's
+ * ThemeProvider uses this to collapse `theme.motion` (durations → 0, springs →
+ * near-instant) so animations don't trigger vestibular discomfort; consumers
+ * can also read it directly to swap an animated path for a static one.
+ */
+export declare const useReducedMotion: () => boolean;
+//# sourceMappingURL=useReducedMotion.d.ts.map

package/lib/typescript/module/hooks/useToggle.d.ts

@@ -0,0 +1,9 @@
+export interface UseToggleResult {
+    value: boolean;
+    toggle: () => void;
+    setOn: () => void;
+    setOff: () => void;
+    setValue: (value: boolean) => void;
+}
+export declare const useToggle: (initial?: boolean) => UseToggleResult;
+//# sourceMappingURL=useToggle.d.ts.map

package/lib/typescript/module/index.d.ts

@@ -0,0 +1,14 @@
+export * from './components/index.js';
+export type { FieldArrayApi, FieldInputProps, FieldRules, FieldState, FocusableNode, FormApi, FormConfig, FormErrors, FormTouched, FormValidateFn, FormValues, SubmitHelpers, ValidateOn, ValidationResult, ValidationRule, ValidationSchema } from './form/index.js';
+export { deletePath, Form, getPath, rules, setPath, useField, useFieldArray, useForm, useFormContext, useOptionalFormContext } from './form/index.js';
+export type { UseControllableStateOptions, UsePressAnimationOptions, UsePressAnimationResult, UseToggleResult } from './hooks/index.js';
+export { useControllableState, useDebounce, usePressAnimation, useReducedMotion, useToggle } from './hooks/index.js';
+export type { InitUIOptions } from './initUI.js';
+export { initUI } from './initUI.js';
+export type { NetworkStatusBannerProps } from './network/index.js';
+export { NetworkStatusBanner } from './network/index.js';
+export type { ColorMode, ColorPalette, ColorSchemePreference, DeepPartial, IconRegistry, IconRenderer, MotionScale, RadiusScale, ShadowDefinition, ShadowScale, SpacingScale, Theme, ThemeOverrides, ThemeProviderProps, TypographyScale } from './theme/index.js';
+export { darkTheme, getColorMode, getTheme, lightTheme, mergeTheme, resetTheme, setColorMode, setTheme, subscribeTheme, ThemeProvider, useTheme, useThemeMode } from './theme/index.js';
+export type { BreakpointKey, FeedbackIntent, HapticType, SpacingToken } from './utils/index.js';
+export { Breakpoints, configureFeedback, feedback, hapticForIntent, isFeedbackEnabled, isScreenSize, isTablet, Margin, Padding, Responsive, ScreenDimensions, Spacing, setHapticImplementation, shadowStyle, triggerHaptic, warnUnknownProps } from './utils/index.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/initUI.d.ts

@@ -0,0 +1,12 @@
+import type { ColorMode, ThemeOverrides } from './theme/types.js';
+export interface InitUIOptions {
+    light?: ThemeOverrides;
+    dark?: ThemeOverrides;
+    defaultMode?: ColorMode;
+}
+/**
+ * Configure the global functional theme API used outside of React tree
+ * (use ThemeProvider for React-tree consumers; both can coexist).
+ */
+export declare const initUI: (options?: InitUIOptions) => void;
+//# sourceMappingURL=initUI.d.ts.map

package/lib/typescript/module/network/NetworkStatusBanner.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { ViewStyle } from 'react-native';
+export interface NetworkStatusBannerProps {
+    /** Override the default offline message. */
+    message?: string;
+    /** Render at the top (default) or bottom of the screen. */
+    position?: 'top' | 'bottom';
+    /** Optional style override for the banner container. */
+    style?: ViewStyle;
+    /** Hide the banner entirely (useful for screens that handle offline themselves). */
+    disabled?: boolean;
+}
+/**
+ * A subtle animated banner that slides in when the device goes offline.
+ * Mount once near the app root (above your navigation tree).
+ */
+export declare const NetworkStatusBanner: React.FC<NetworkStatusBannerProps>;
+export default NetworkStatusBanner;
+//# sourceMappingURL=NetworkStatusBanner.d.ts.map

package/lib/typescript/module/network/index.d.ts

@@ -0,0 +1,3 @@
+export type { NetworkStatusBannerProps } from './NetworkStatusBanner.js';
+export { NetworkStatusBanner } from './NetworkStatusBanner.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/module/theme/Gradient.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { GradientDefinition } from './types.js';
+export interface GradientProps {
+    gradient: GradientDefinition;
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+export declare const Gradient: React.FC<GradientProps>;
+export declare const isGradientAvailable: () => boolean;
+//# sourceMappingURL=Gradient.d.ts.map

package/lib/typescript/module/theme/ThemeContext.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { ColorMode, Theme, ThemeOverrides } from './types.js';
+export type ColorSchemePreference = 'light' | 'dark' | 'system';
+export interface ThemeProviderProps {
+    children: React.ReactNode;
+    initialPreference?: ColorSchemePreference;
+    lightOverrides?: ThemeOverrides;
+    darkOverrides?: ThemeOverrides;
+}
+export declare const ThemeProvider: React.FC<ThemeProviderProps>;
+export declare const useTheme: () => Theme;
+export declare const useThemeMode: () => {
+    mode: ColorMode;
+    preference: ColorSchemePreference;
+    setPreference: (preference: ColorSchemePreference) => void;
+    toggleColorMode: () => void;
+};
+//# sourceMappingURL=ThemeContext.d.ts.map

package/lib/typescript/module/theme/animatedValue.d.ts

@@ -0,0 +1,39 @@
+import { Animated } from 'react-native';
+/**
+ * Create an `Animated.Value` that survives RN 0.85's dev-mode prop deepFreeze.
+ *
+ * RN's Fabric renderer deep-freezes prop trees on host components. If an
+ * `Animated.Value` is reachable from a `style` prop via interpolation chains
+ * (the `_parent` ref on `AnimatedInterpolation` nodes), the recursive freeze
+ * converts the value's `_animation` slot into a throwing setter — the next
+ * `Animated.timing(v).start()` then crashes with
+ *   "_animation: object that is meant to be immutable".
+ *
+ * Sealing the value at construction makes `Object.isSealed(v) === true`,
+ * which causes `deepFreezeAndThrowOnMutationInDev` to skip-and-return at
+ * its top guard. Existing-property mutation (`_animation`, `_value`,
+ * `_listeners`, `_tracking`) keeps working — seal only blocks adding NEW
+ * properties, and `Animated.Value` doesn't add any post-construction.
+ *
+ * Use everywhere the library would otherwise call `new Animated.Value(...)`.
+ *
+ * NOT on web. The reasoning above ("Animated.Value doesn't add any properties
+ * post-construction") holds for React Native but not for react-native-web,
+ * whose `stopTracking()` assigns `_tracking` on an instance that never declared
+ * it — on a sealed object that throws, and the throw happens during unmount, so
+ * it takes the whole tree down. There is no Fabric deep-freeze on web either,
+ * so the seal has nothing to protect against there.
+ */
+export declare const createAnimatedValue: (initial: number, config?: ConstructorParameters<typeof Animated.Value>[1]) => Animated.Value;
+/**
+ * Set an `Animated.Value` to a target without going through JS.
+ *
+ * Once a value has been driven by `useNativeDriver: true`, the underlying
+ * native node owns it — calling `value.setValue(x)` from JS throws
+ *   "Attempting to run JS driven animation on animated node that has been moved to native".
+ * Use this helper for any value that is *also* used in a native-driven
+ * `Animated.timing/spring`. A zero-duration native timing routes the update
+ * through the same driver and stays valid across re-mounts and re-runs.
+ */
+export declare const setNativeValue: (value: Animated.Value, to: number) => void;
+//# sourceMappingURL=animatedValue.d.ts.map

package/lib/typescript/module/theme/index.d.ts

@@ -0,0 +1,18 @@
+import type { ColorMode, Theme, ThemeOverrides } from './types.js';
+export declare const setTheme: (overrides: ThemeOverrides, mode?: ColorMode) => void;
+export declare const setColorMode: (mode: ColorMode) => void;
+export declare const getColorMode: () => ColorMode;
+export declare const getTheme: () => Theme;
+export declare const resetTheme: () => void;
+export declare const subscribeTheme: (callback: () => void) => (() => void);
+export { createAnimatedValue, setNativeValue } from './animatedValue.js';
+export type { GradientProps } from './Gradient.js';
+export { Gradient, isGradientAvailable } from './Gradient.js';
+export { mergeTheme } from './merge.js';
+export type { ColorSchemePreference, ThemeProviderProps } from './ThemeContext.js';
+export { ThemeProvider, useTheme, useThemeMode } from './ThemeContext.js';
+export type { FontWeightKey } from './textStyle.js';
+export { fontFor } from './textStyle.js';
+export { darkTheme, lightTheme } from './tokens.js';
+export type { ColorMode, ColorPalette, DeepPartial, GradientDefinition, GradientScale, IconRegistry, IconRenderer, MotionScale, RadiusScale, ShadowDefinition, ShadowScale, SpacingScale, Theme, ThemeOverrides, TypographyScale } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/theme/merge.d.ts

@@ -0,0 +1,3 @@
+import type { Theme, ThemeOverrides } from './types.js';
+export declare const mergeTheme: (base: Theme, overrides: ThemeOverrides) => Theme;
+//# sourceMappingURL=merge.d.ts.map

package/lib/typescript/module/theme/textStyle.d.ts

@@ -0,0 +1,18 @@
+import type { TextStyle } from 'react-native';
+import type { Theme, TypographyScale } from './types.js';
+export type FontWeightKey = keyof TypographyScale['fontWeight'];
+/**
+ * Resolve text-weight style for the active theme.
+ *
+ * When the consumer registers a brand `theme.typography.fontFamily.<weight>`,
+ * we set `fontFamily` and leave `fontWeight` undefined — RN can't combine the
+ * two reliably across iOS/Android once a custom face is in play, so the brand
+ * file controls the weight glyph itself. Falls back to `fontWeight` when no
+ * brand font is registered for that weight.
+ *
+ * Note: the fontWeight scale uses `normal` while FontFamilyScale uses
+ * `regular` (the conventional font-name suffix). The helper maps between
+ * them transparently.
+ */
+export declare const fontFor: (theme: Theme, weight: FontWeightKey) => Pick<TextStyle, "fontFamily" | "fontWeight">;
+//# sourceMappingURL=textStyle.d.ts.map

package/lib/typescript/module/theme/tokens.d.ts

@@ -0,0 +1,4 @@
+import type { Theme } from './types.js';
+export declare const lightTheme: Theme;
+export declare const darkTheme: Theme;
+//# sourceMappingURL=tokens.d.ts.map