react-native-system-ui 1.0.4 → 1.0.5

package/dist/types/components/dialog/types.d.ts

@@ -0,0 +1,70 @@
+import type React from 'react';
+import type { StyleProp, TextStyle, ViewProps, ViewStyle } from 'react-native';
+import type { DeepPartial } from '../../types';
+import type { DialogTokens } from './tokens';
+export type DialogTheme = 'default' | 'round-button';
+export type DialogMessageAlign = 'left' | 'center' | 'right';
+export type DialogBeforeCloseAction = 'confirm' | 'cancel' | 'close';
+export interface DialogActionState {
+    loading?: boolean;
+    disabled?: boolean;
+}
+export interface DialogProps extends Omit<ViewProps, 'children'> {
+    visible: boolean;
+    title?: React.ReactNode;
+    message?: React.ReactNode;
+    messageAlign?: DialogMessageAlign;
+    theme?: DialogTheme;
+    width?: number | string;
+    closeable?: boolean;
+    closeIcon?: React.ReactNode;
+    overlay?: boolean;
+    overlayStyle?: StyleProp<ViewStyle>;
+    overlayTestID?: string;
+    closeOnBackPress?: boolean;
+    closeOnPopstate?: boolean;
+    closeOnOverlayPress?: boolean;
+    closeOnClickOverlay?: boolean;
+    onClickOverlay?: () => void;
+    onClickCloseIcon?: () => void;
+    beforeClose?: (action: DialogBeforeCloseAction) => boolean | Promise<boolean>;
+    showCancelButton?: boolean;
+    cancelButtonText?: React.ReactNode;
+    cancelButtonColor?: string;
+    cancelProps?: DialogActionState;
+    showConfirmButton?: boolean;
+    confirmButtonText?: React.ReactNode;
+    confirmButtonColor?: string;
+    confirmProps?: DialogActionState;
+    footer?: React.ReactNode;
+    contentStyle?: StyleProp<ViewStyle>;
+    titleStyle?: StyleProp<TextStyle>;
+    messageStyle?: StyleProp<TextStyle>;
+    tokensOverride?: DeepPartial<DialogTokens>;
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+    onCancel?: () => void | boolean | Promise<void | boolean>;
+    onConfirm?: () => void | boolean | Promise<void | boolean>;
+    onClose?: () => void | boolean | Promise<void | boolean>;
+    onClosed?: () => void;
+}
+export type DialogShowOptions = Omit<DialogProps, 'visible'>;
+export type DialogAlertOptions = Omit<DialogShowOptions, 'showCancelButton' | 'onCancel'>;
+export type DialogConfirmOptions = DialogShowOptions;
+export type DialogImperativeMode = 'show' | 'alert' | 'confirm';
+export type DialogSetDefaultOptions = {
+    (options: DialogShowOptions): void;
+    (mode: DialogImperativeMode, options: DialogShowOptions): void;
+};
+export type DialogResetDefaultOptions = {
+    (mode?: DialogImperativeMode): void;
+};
+export interface DialogStatic {
+    Host: React.ComponentType<any>;
+    show: (options?: DialogShowOptions) => () => void;
+    alert: (options?: DialogAlertOptions) => Promise<void>;
+    confirm: (options?: DialogConfirmOptions) => Promise<boolean>;
+    clear: () => void;
+    setDefaultOptions: DialogSetDefaultOptions;
+    resetDefaultOptions: DialogResetDefaultOptions;
+}

package/dist/types/components/divider/types.d.ts

@@ -0,0 +1,48 @@
+import type { StyleProp, TextStyle, ViewProps, ViewStyle } from 'react-native';
+import type { DeepPartial } from '../../types';
+export type DividerContentPosition = 'left' | 'center' | 'right';
+export interface DividerTokens {
+    defaults: {
+        dashed: boolean;
+        hairline: boolean;
+        contentPosition: DividerContentPosition;
+    };
+    layout: {
+        container: ViewStyle;
+        contentWrapper: ViewStyle;
+        text: TextStyle;
+        hairlineWrapper: ViewStyle;
+    };
+    colors: {
+        line: string;
+        text: string;
+    };
+    typography: {
+        fontSize: number;
+        lineHeight: number;
+        fontFamily: string;
+        fontWeight: TextStyle['fontWeight'];
+    };
+    sizing: {
+        sideMinFlex: number;
+    };
+    borders: {
+        thickness: number;
+    };
+    spacing: {
+        vertical: number;
+        contentPadding: number;
+    };
+}
+export interface DividerProps extends ViewProps {
+    children?: React.ReactNode;
+    type?: 'horizontal' | 'vertical';
+    orientation?: 'horizontal' | 'vertical';
+    dashed?: boolean;
+    hairline?: boolean;
+    contentPosition?: DividerContentPosition;
+    textStyle?: StyleProp<TextStyle>;
+    contentStyle?: StyleProp<ViewStyle>;
+    lineColor?: string;
+    tokensOverride?: DeepPartial<DividerTokens>;
+}

package/dist/types/components/empty/types.d.ts

@@ -0,0 +1,44 @@
+import type { StyleProp, TextStyle, ViewProps, ViewStyle } from 'react-native';
+import type { DeepPartial } from '../../types';
+export type EmptyImage = 'default' | 'error' | 'network' | 'search';
+export interface EmptyTokens {
+    defaults: {
+        image: EmptyImage;
+        gap: number;
+    };
+    layout: {
+        container: ViewStyle;
+        imageWrapper: ViewStyle;
+        descriptionText: TextStyle;
+        footer: ViewStyle;
+    };
+    colors: {
+        description: string;
+        icon: string;
+        imageBackground: string;
+    };
+    typography: {
+        descriptionSize: number;
+        descriptionLineHeight: number;
+        descriptionFontFamily: string;
+        descriptionFontWeight: TextStyle['fontWeight'];
+    };
+    sizing: {
+        image: number;
+        iconScale: number;
+    };
+    spacing: {
+        descriptionPaddingHorizontal: number;
+        footerMarginTop: number;
+    };
+}
+export interface EmptyProps extends ViewProps {
+    image?: EmptyImage | string | React.ReactNode;
+    imageSize?: number;
+    imageStyle?: StyleProp<ViewStyle>;
+    description?: React.ReactNode;
+    descriptionStyle?: StyleProp<TextStyle>;
+    children?: React.ReactNode;
+    gap?: number;
+    tokensOverride?: DeepPartial<EmptyTokens>;
+}

package/dist/types/components/error-boundary/types.d.ts

@@ -0,0 +1,18 @@
+import type React from 'react';
+export interface ErrorBoundaryProps {
+    /** Fallback UI when an error is caught. Can be a ReactNode or a render function */
+    fallback?: React.ReactNode | ((error: Error, reset: () => void) => React.ReactNode);
+    /** Callback when an error is caught */
+    onError?: (error: Error, errorInfo: React.ErrorInfo) => void;
+    /** Callback when the error state is reset */
+    onReset?: () => void;
+    /** Children to render */
+    children?: React.ReactNode;
+}
+export interface ErrorBoundaryState {
+    error: Error | null;
+}
+export interface ErrorBoundaryRef {
+    /** Reset the error boundary to re-render children */
+    reset: () => void;
+}

package/dist/types/components/field/types.d.ts

@@ -0,0 +1,86 @@
+import type React from 'react';
+import type { PressableProps, StyleProp, TextInput, TextInputProps, TextStyle, ViewStyle } from 'react-native';
+import type { DeepPartial } from '../../types';
+import type { FieldTokens } from './tokens';
+import type { DialogShowOptions } from '../dialog/types';
+import type { CellArrowDirection, CellGroupProps, CellSize } from '../cell/types';
+export type FieldType = 'tel' | 'text' | 'digit' | 'number' | 'search' | 'password' | 'textarea';
+export type FieldInputAlign = 'left' | 'center' | 'right';
+export type FieldControlAlign = 'left' | 'center' | 'right';
+export type FieldClearTrigger = 'always' | 'focus';
+export type FieldFormatTrigger = 'onBlur' | 'onChange';
+export type FieldAutosizeConfig = {
+    maxRows?: number;
+    minRows?: number;
+};
+export type FieldTooltipProps = DialogShowOptions & {
+    icon?: React.ReactNode;
+};
+export type FieldShowWordLimit = boolean | ((params: {
+    currentCount: number;
+    maxLength?: number;
+}) => React.ReactNode);
+export interface FieldProps extends Omit<TextInputProps, 'style' | 'value' | 'defaultValue' | 'editable' | 'onChange' | 'onChangeText'> {
+    label?: React.ReactNode;
+    labelWidth?: number;
+    labelAlign?: FieldInputAlign;
+    inputAlign?: FieldInputAlign;
+    controlAlign?: FieldControlAlign;
+    required?: boolean;
+    colon?: boolean;
+    intro?: React.ReactNode;
+    description?: React.ReactNode;
+    tooltip?: React.ReactNode | FieldTooltipProps;
+    error?: boolean;
+    errorMessage?: React.ReactNode;
+    errorMessageAlign?: FieldInputAlign;
+    disabled?: boolean;
+    readOnly?: boolean;
+    clearable?: boolean;
+    clearTrigger?: FieldClearTrigger;
+    clearIcon?: React.ReactNode;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+    button?: React.ReactNode;
+    extra?: React.ReactNode;
+    value?: string;
+    defaultValue?: string;
+    type?: FieldType;
+    rows?: number;
+    autoSize?: boolean | FieldAutosizeConfig;
+    formatter?: (value: string) => string;
+    formatTrigger?: FieldFormatTrigger;
+    showWordLimit?: FieldShowWordLimit;
+    onOverlimit?: (value: string) => void;
+    onChangeText?: (value: string) => void;
+    onClear?: () => void;
+    onClick?: () => void;
+    onClickInput?: () => void;
+    onClickLeftIcon?: () => void;
+    onClickRightIcon?: () => void;
+    border?: boolean;
+    center?: boolean;
+    clickable?: boolean;
+    isLink?: boolean;
+    arrowDirection?: CellArrowDirection;
+    size?: CellSize;
+    titleStyle?: StyleProp<TextStyle>;
+    contentStyle?: StyleProp<ViewStyle>;
+    inputStyle?: StyleProp<TextStyle>;
+    labelStyle?: StyleProp<TextStyle>;
+    introStyle?: StyleProp<TextStyle>;
+    errorMessageStyle?: StyleProp<TextStyle>;
+    tokensOverride?: DeepPartial<FieldTokens>;
+    style?: StyleProp<ViewStyle>;
+    androidRipple?: PressableProps['android_ripple'];
+    children?: React.ReactNode;
+}
+export interface FieldInstance {
+    focus: () => void;
+    blur: () => void;
+    clear: () => void;
+    nativeElement: TextInput | null;
+}
+export type FieldGroupProps = CellGroupProps;

package/dist/types/components/flex/types.d.ts

@@ -0,0 +1,37 @@
+import type React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { DeepPartial } from '../../types';
+export type FlexDirection = 'row' | 'row-reverse' | 'column' | 'column-reverse';
+export type FlexWrap = 'nowrap' | 'wrap' | 'wrap-reverse';
+export type FlexAlign = 'start' | 'center' | 'end' | 'baseline' | 'stretch';
+export type FlexJustify = 'start' | 'end' | 'center' | 'around' | 'between';
+export interface FlexTokens {
+    defaults: {
+        direction: FlexDirection;
+        wrap: FlexWrap;
+        gutter: number | [number, number];
+        align: FlexAlign;
+        justify: FlexJustify;
+        columns: number;
+    };
+    layout: {
+        container: ViewStyle;
+    };
+}
+export interface FlexProps {
+    children?: React.ReactNode;
+    direction?: FlexDirection;
+    wrap?: FlexWrap;
+    gutter?: number | [number, number];
+    align?: FlexAlign;
+    justify?: FlexJustify;
+    style?: StyleProp<ViewStyle>;
+    columns?: number;
+    tokensOverride?: DeepPartial<FlexTokens>;
+}
+export interface FlexItemProps {
+    span?: number;
+    flex?: number | string;
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}

package/dist/types/components/form/Form.d.ts

@@ -1,5 +1,11 @@
 import React from 'react';
 import type { FormInstance, FormProps, FormSubscribeProps, NamePath, RegisteredFieldOptions } from './types';
+export declare const normalizeTrigger: (trigger?: string | string[]) => string[];
+export declare const FORM_ALL_FIELDS_KEY = "__form_all__";
+export declare const toNamePath: (name?: NamePath) => (string | number)[];
+export declare const serializeNamePath: (name?: NamePath) => string;
+export declare const getValueByName: (source: unknown, name: NamePath) => unknown;
+export declare const setValueByName: (source: Record<string, unknown>, name: NamePath, value: unknown) => Record<string, unknown>;
 export interface FormContextValue {
     getFieldValue: (name: NamePath) => unknown;
     setFieldValue: (name: NamePath, value: unknown, trigger?: string) => void;

package/dist/types/components/form/types.d.ts

@@ -0,0 +1,68 @@
+import type { ReactNode } from 'react';
+import type { ViewProps } from 'react-native';
+export type FormRuleValidateTrigger = string | string[];
+export type FormRuleValidator = (value: unknown, values: Record<string, unknown>) => void | boolean | string | Promise<void | boolean | string>;
+export type NamePath = string | number | (string | number)[];
+export interface FormItemRule {
+    required?: boolean;
+    message?: string;
+    pattern?: RegExp;
+    len?: number;
+    min?: number;
+    max?: number;
+    whitespace?: boolean;
+    validator?: FormRuleValidator;
+    validateTrigger?: FormRuleValidateTrigger;
+}
+export interface RegisteredFieldOptions {
+    rules?: FormItemRule[];
+    dependencies?: NamePath[];
+    initialValue?: unknown;
+    validateTrigger?: FormRuleValidateTrigger;
+}
+export interface FormInstance {
+    submit: () => Promise<Record<string, unknown> | undefined>;
+    getFieldsValue: () => Record<string, unknown>;
+    setFieldsValue: (values: Record<string, unknown>, options?: {
+        validate?: boolean;
+    }) => void;
+    resetFields: () => void;
+    validateFields: (names?: NamePath[]) => Promise<Record<string, unknown>>;
+    getFieldError: (name: NamePath) => string[];
+}
+export interface FormProps extends ViewProps {
+    initialValues?: Record<string, unknown>;
+    colon?: boolean;
+    labelWidth?: number;
+    showValidateMessage?: boolean;
+    footer?: ReactNode;
+    onValuesChange?: (values: Record<string, unknown>, name: string, value: unknown) => void;
+    onFinish?: (values: Record<string, unknown>) => void;
+    children?: ReactNode;
+}
+export interface FormSubscribeProps {
+    to?: string[];
+    children: (changedValues: Record<string, unknown>, form: FormInstance | null) => ReactNode;
+}
+export interface FormItemProps {
+    name?: NamePath;
+    label?: ReactNode;
+    description?: ReactNode;
+    intro?: ReactNode;
+    tooltip?: ReactNode;
+    rules?: FormItemRule[];
+    dependencies?: NamePath[];
+    valuePropName?: string;
+    trigger?: string;
+    validateTrigger?: FormRuleValidateTrigger;
+    showValidateMessage?: boolean;
+    required?: boolean;
+    noStyle?: boolean;
+    shouldUpdate?: (prev: Record<string, unknown>, next: Record<string, unknown>) => boolean;
+    initialValue?: unknown;
+    children: ReactNode | ((payload: {
+        getFieldValue: (name: NamePath) => unknown;
+        getFieldsValue: () => Record<string, unknown>;
+        form: FormInstance | null;
+    }) => ReactNode);
+}

package/dist/types/components/grid/types.d.ts

@@ -0,0 +1,77 @@
+import type { PressableProps, StyleProp, TextStyle, ViewProps, ViewStyle } from 'react-native';
+import type { BadgeProps } from '../badge';
+import type { DeepPartial } from '../../types';
+export type GridDirection = 'vertical' | 'horizontal';
+export interface GridTokens {
+    defaults: {
+        columnNum: number;
+        gutter: number;
+        border: boolean;
+        center: boolean;
+        square: boolean;
+        direction: GridDirection;
+        reverse: boolean;
+        clickable: boolean;
+        iconSize: number;
+        pressedOpacity: number;
+        textNumberOfLines: number;
+    };
+    layout: {
+        container: ViewStyle;
+        border: ViewStyle;
+        borderTop: ViewStyle;
+        borderBottom: ViewStyle;
+        itemContentBase: ViewStyle;
+        itemVertical: ViewStyle;
+        itemHorizontal: ViewStyle;
+        itemCenter: ViewStyle;
+        itemReverseColumn: ViewStyle;
+        itemReverseRow: ViewStyle;
+        iconWrapper: ViewStyle;
+        text: TextStyle;
+        itemBorderRight: ViewStyle;
+        itemBorderBottom: ViewStyle;
+        itemContentSquare: ViewStyle;
+    };
+    colors: {
+        border: string;
+        text: string;
+        background: string;
+        active: string;
+    };
+    typography: {
+        fontSize: number;
+        fontFamily: string;
+        lineHeight: number;
+        fontWeight: NonNullable<TextStyle['fontWeight']>;
+    };
+    spacing: {
+        paddingHorizontal: number;
+        paddingVertical: number;
+        iconGap: number;
+    };
+}
+export interface GridProps extends ViewProps {
+    children?: React.ReactNode;
+    columnNum?: number;
+    gutter?: number;
+    border?: boolean;
+    center?: boolean;
+    square?: boolean;
+    direction?: GridDirection;
+    reverse?: boolean;
+    clickable?: boolean;
+    iconSize?: number;
+    iconColor?: string;
+    tokensOverride?: DeepPartial<GridTokens>;
+}
+export interface GridItemProps extends PressableProps {
+    children?: React.ReactNode;
+    text?: React.ReactNode;
+    icon?: React.ReactNode | ((size: number, color: string) => React.ReactNode);
+    iconColor?: string;
+    badge?: BadgeProps;
+    dot?: boolean;
+    contentStyle?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+}

package/dist/types/components/image/types.d.ts

@@ -0,0 +1,53 @@
+import type * as React from 'react';
+import type { ImageProps as RNImageProps, ImageSourcePropType, ImageStyle, PressableProps, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { DeepPartial } from '../../types';
+export type ImageFit = 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
+export interface ImageTokens {
+    defaults: {
+        fit: ImageFit;
+        showLoading: boolean;
+        showError: boolean;
+        loadingText: React.ReactNode;
+        errorText: React.ReactNode;
+        iconSize: number;
+        loadingIndicatorBaseSize: number;
+        loadingLabelMarginTop: number;
+        roundRadius: number;
+    };
+    layout: {
+        container: ViewStyle;
+        overlay: ViewStyle;
+        label: TextStyle;
+        iconContainer: ViewStyle;
+        absoluteFill: ImageStyle;
+    };
+    colors: {
+        background: string;
+        text: string;
+        error: string;
+    };
+}
+export interface ImageProps extends Omit<RNImageProps, 'source' | 'width' | 'height'> {
+    src?: string;
+    source?: ImageSourcePropType;
+    width?: number | string;
+    height?: number | string;
+    radius?: number;
+    round?: boolean;
+    fit?: ImageFit;
+    showLoading?: boolean;
+    showError?: boolean;
+    loadingText?: React.ReactNode;
+    loadingIcon?: React.ReactNode;
+    errorIcon?: React.ReactNode;
+    iconSize?: number;
+    loadingSize?: 'small' | 'large' | number;
+    errorText?: React.ReactNode;
+    fallback?: React.ReactNode;
+    onPress?: PressableProps['onPress'];
+    alt?: string;
+    containerStyle?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+    tokensOverride?: DeepPartial<ImageTokens>;
+    'aria-label'?: string;
+}

package/dist/types/components/image-preview/types.d.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+import type { ImageSourcePropType, StyleProp, ViewStyle } from 'react-native';
+import type { PopupCloseIconPosition } from '../popup';
+import type { DeepPartial } from '../../types';
+import type { ImagePreviewTokens } from './tokens';
+export type ImagePreviewCloseReason = 'overlay' | 'close-icon' | 'content' | 'close';
+export type ImagePreviewImage = ImageSourcePropType | string;
+export interface ImagePreviewProps {
+    visible: boolean;
+    images?: ImagePreviewImage[];
+    startPosition?: number;
+    swipeDuration?: number;
+    tokensOverride?: DeepPartial<ImagePreviewTokens>;
+    lazyRender?: boolean;
+    lazyRenderBuffer?: number;
+    showIndex?: boolean;
+    indexRender?: (ctx: {
+        index: number;
+        len: number;
+    }) => React.ReactNode;
+    showIndicators?: boolean;
+    closeable?: boolean;
+    closeIcon?: React.ReactNode;
+    closeIconPosition?: PopupCloseIconPosition;
+    overlay?: boolean;
+    overlayStyle?: StyleProp<ViewStyle>;
+    closeOnBackPress?: boolean;
+    closeOnPopstate?: boolean;
+    zIndex?: number;
+    duration?: number;
+    closeOnlyClickCloseIcon?: boolean;
+    safeAreaInsetTop?: boolean;
+    safeAreaInsetBottom?: boolean;
+    onChange?: (index: number) => void;
+    onClose?: (params: CloseParams) => void;
+    onClosed?: () => void;
+    beforeClose?: (context: CloseContext) => boolean | Promise<boolean>;
+}
+export interface CloseParams {
+    index: number;
+    image?: ImagePreviewImage;
+}
+export interface CloseContext extends CloseParams {
+    reason: ImagePreviewCloseReason;
+}
+export type ImagePreviewRef = {
+    swipeTo: (index: number, animated?: boolean) => void;
+};
+export type ImagePreviewOpenOptions = Omit<ImagePreviewProps, 'visible'>;
+export type ImagePreviewDestroy = () => void;
+export interface ImagePreviewStatic {
+    Host: React.ComponentType<Record<string, unknown>>;
+    open: (options: ImagePreviewOpenOptions) => ImagePreviewDestroy;
+    clear: () => void;
+}

package/dist/types/components/input/types.d.ts

@@ -0,0 +1,42 @@
+import type { StyleProp, TextInput, TextStyle, ViewStyle } from 'react-native';
+import type { DeepPartial } from '../../types';
+import type { FieldTokens } from '../field/tokens';
+import type { FieldClearTrigger, FieldInputAlign, FieldProps, FieldShowWordLimit } from '../field/types';
+export interface InputTokens {
+    defaults: {
+        inputAlign: FieldInputAlign;
+        clearTrigger: FieldClearTrigger;
+        border: boolean;
+    };
+    spacing: {
+        paddingHorizontal: number;
+        paddingVertical: number;
+    };
+    colors: {
+        background: string;
+    };
+}
+export interface InputProps extends Omit<FieldProps, 'tokensOverride'> {
+    align?: FieldInputAlign;
+    clearTrigger?: FieldClearTrigger;
+    onChange?: (value: string) => void;
+    showWordLimit?: FieldShowWordLimit;
+    style?: StyleProp<ViewStyle>;
+    inputStyle?: StyleProp<TextStyle>;
+    fieldTokensOverride?: DeepPartial<FieldTokens>;
+    tokensOverride?: DeepPartial<InputTokens>;
+}
+export interface InputInstance {
+    focus: () => void;
+    blur: () => void;
+    clear: () => void;
+    nativeElement: TextInput | null;
+}
+export interface InputTextAreaAutoSizeConfig {
+    minHeight?: number;
+    maxHeight?: number;
+}
+export type InputTextAreaAutoSize = boolean | InputTextAreaAutoSizeConfig;
+export interface InputTextAreaProps extends Omit<InputProps, 'type' | 'autoSize' | 'autosize'> {
+    autoSize?: InputTextAreaAutoSize;
+}

package/dist/types/components/loading/types.d.ts

@@ -0,0 +1,32 @@
+import type { StyleProp, TextStyle, ViewProps, ViewStyle } from 'react-native';
+import type { DeepPartial } from '../../types';
+export interface LoadingTokens {
+    defaults: {
+        size: number;
+        textSize: number;
+        vertical: boolean;
+    };
+    layout: {
+        container: ViewStyle;
+        text: TextStyle;
+    };
+    colors: {
+        indicator: string;
+        text: string;
+    };
+    spacing: {
+        gap: number;
+    };
+}
+export interface LoadingProps extends ViewProps {
+    ['aria-label']?: string;
+    color?: string;
+    size?: number;
+    textSize?: number;
+    textColor?: string;
+    vertical?: boolean;
+    children?: React.ReactNode;
+    textStyle?: StyleProp<TextStyle>;
+    contentStyle?: StyleProp<ViewStyle>;
+    tokensOverride?: DeepPartial<LoadingTokens>;
+}