formio-react-native 1.0.0

package/lib/typescript/commonjs/constants/validationMessages.d.ts

@@ -0,0 +1,17 @@
+export declare const VALIDATION_MESSAGES: {
+    readonly REQUIRED: "This field is required";
+    readonly MIN_LENGTH: "Minimum length is {min}";
+    readonly MAX_LENGTH: "Maximum length is {max}";
+    readonly PATTERN: "Invalid format";
+    readonly MIN_VALUE: "Minimum value is {min}";
+    readonly MAX_VALUE: "Maximum value is {max}";
+    readonly INVALID_EMAIL: "Invalid email address";
+    readonly INVALID_URL: "Invalid URL";
+    readonly INVALID_PHONE: "Invalid phone number";
+    readonly INVALID_DATE: "Invalid date";
+    readonly FILE_TYPE_INVALID: "Invalid file type";
+    readonly FILE_SIZE_TOO_LARGE: "File is too large";
+    readonly CUSTOM_ERROR: "This field is invalid";
+};
+export type ValidationMessageKey = keyof typeof VALIDATION_MESSAGES;
+//# sourceMappingURL=validationMessages.d.ts.map

package/lib/typescript/commonjs/context/FormioContext.d.ts

@@ -0,0 +1,151 @@
+import React, { ReactNode } from 'react';
+import { FormioComponent } from '../types';
+import { I18nConfig } from '../i18n/types';
+import { ComponentRegistry } from '../registry';
+export type ComponentRenderer = (component: FormioComponent, props: ComponentRenderProps) => ReactNode;
+export interface ComponentRenderProps {
+    value: any;
+    onChange: (value: any) => void;
+    error?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    formData?: Record<string, any>;
+}
+export interface ComponentOverrides {
+    textfield?: ComponentRenderer;
+    number?: ComponentRenderer;
+    textarea?: ComponentRenderer;
+    email?: ComponentRenderer;
+    phoneNumber?: ComponentRenderer;
+    url?: ComponentRenderer;
+    password?: ComponentRenderer;
+    select?: ComponentRenderer;
+    checkbox?: ComponentRenderer;
+    radio?: ComponentRenderer;
+    selectboxes?: ComponentRenderer;
+    datetime?: ComponentRenderer;
+    date?: ComponentRenderer;
+    time?: ComponentRenderer;
+    day?: ComponentRenderer;
+    file?: ComponentRenderer;
+    panel?: ComponentRenderer;
+    container?: ComponentRenderer;
+    columns?: ComponentRenderer;
+    fieldset?: ComponentRenderer;
+    well?: ComponentRenderer;
+    button?: ComponentRenderer;
+    datagrid?: ComponentRenderer;
+    editgrid?: ComponentRenderer;
+    tree?: ComponentRenderer;
+    wizard?: ComponentRenderer;
+    [customType: string]: ComponentRenderer | undefined;
+}
+export interface FormioTheme {
+    colors?: {
+        primary?: string;
+        secondary?: string;
+        error?: string;
+        success?: string;
+        warning?: string;
+        info?: string;
+        background?: string;
+        surface?: string;
+        text?: string;
+        textSecondary?: string;
+        border?: string;
+        borderFocus?: string;
+        disabled?: string;
+        placeholder?: string;
+    };
+    spacing?: {
+        xs?: number;
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+    };
+    typography?: {
+        fontFamily?: string;
+        fontSize?: {
+            xs?: number;
+            sm?: number;
+            md?: number;
+            lg?: number;
+            xl?: number;
+        };
+        fontWeight?: {
+            light?: string;
+            normal?: string;
+            medium?: string;
+            bold?: string;
+        };
+        lineHeight?: {
+            tight?: number;
+            normal?: number;
+            relaxed?: number;
+        };
+    };
+    borderRadius?: {
+        none?: number;
+        sm?: number;
+        md?: number;
+        lg?: number;
+        full?: number;
+    };
+    shadows?: {
+        sm?: object;
+        md?: object;
+        lg?: object;
+    };
+    components?: {
+        input?: {
+            borderRadius?: number;
+            borderWidth?: number;
+            padding?: number;
+            fontSize?: number;
+            minHeight?: number;
+        };
+        label?: {
+            fontSize?: number;
+            fontWeight?: string;
+            marginBottom?: number;
+            color?: string;
+        };
+        error?: {
+            fontSize?: number;
+            color?: string;
+            marginTop?: number;
+        };
+        button?: {
+            borderRadius?: number;
+            padding?: number;
+            fontSize?: number;
+            fontWeight?: string;
+            minHeight?: number;
+        };
+        container?: {
+            padding?: number;
+            marginBottom?: number;
+            backgroundColor?: string;
+            borderRadius?: number;
+        };
+    };
+}
+export interface FormioContextValue {
+    componentOverrides?: ComponentOverrides;
+    theme?: FormioTheme;
+    registerComponent: (type: string, renderer: ComponentRenderer) => void;
+    getThemeValue: (path: string, fallback?: any) => any;
+    registry?: ComponentRegistry;
+}
+export declare const useFormioContext: () => FormioContextValue;
+export declare const useRegistry: () => ComponentRegistry | undefined;
+interface FormioProviderProps {
+    children: ReactNode;
+    components?: ComponentOverrides;
+    theme?: FormioTheme;
+    i18n?: I18nConfig;
+}
+export declare const FormioProvider: React.FC<FormioProviderProps>;
+export {};
+//# sourceMappingURL=FormioContext.d.ts.map

package/lib/typescript/commonjs/errors/ErrorBoundary.d.ts

@@ -0,0 +1,23 @@
+import React, { ReactNode } from 'react';
+export interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);
+    onError?: (error: Error, info: {
+        componentStack: string;
+    }) => void;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error?: Error;
+}
+export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: {
+        componentStack: string;
+    }): void;
+    handleReset: () => void;
+    render(): ReactNode;
+}
+export {};
+//# sourceMappingURL=ErrorBoundary.d.ts.map

package/lib/typescript/commonjs/errors/FormioError.d.ts

@@ -0,0 +1,28 @@
+export declare class FormioError extends Error {
+    constructor(message: string);
+}
+export declare class InvalidSchemaError extends FormioError {
+    readonly schema?: any;
+    constructor(message: string, schema?: any);
+}
+export declare class MissingComponentError extends FormioError {
+    readonly componentType: string;
+    constructor(componentType: string);
+}
+export declare class ComponentRenderError extends FormioError {
+    readonly componentKey: string;
+    readonly originalError: Error;
+    constructor(message: string, componentKey: string, originalError: Error);
+}
+export declare class ValidationError extends FormioError {
+    readonly field: string;
+    readonly code?: string;
+    constructor(field: string, message: string, code?: string);
+}
+export declare class SubmissionError extends FormioError {
+    readonly errors?: ValidationError[];
+    constructor(message: string, errors?: ValidationError[]);
+}
+export declare function isFormioError(error: unknown): error is FormioError;
+export declare function isValidationError(error: unknown): error is ValidationError;
+//# sourceMappingURL=FormioError.d.ts.map

package/lib/typescript/commonjs/errors/errorUtils.d.ts

@@ -0,0 +1,8 @@
+import { FormioError, ValidationError } from './FormioError';
+export declare function handleError(error: unknown, context?: string): Error;
+export declare function normalizeError(error: unknown): Error;
+export declare function createValidationError(field: string, message: string, code?: string): ValidationError;
+export declare function isError(value: unknown): value is Error;
+export declare function isFormioError(value: unknown): value is FormioError;
+export declare function getErrorMessage(error: unknown): string;
+//# sourceMappingURL=errorUtils.d.ts.map

package/lib/typescript/commonjs/errors/index.d.ts

@@ -0,0 +1,5 @@
+export { FormioError, InvalidSchemaError, MissingComponentError, ComponentRenderError, SubmissionError, isFormioError, isValidationError, } from './FormioError';
+export { ErrorBoundary } from './ErrorBoundary';
+export type { ErrorBoundaryProps } from './ErrorBoundary';
+export { handleError, normalizeError, createValidationError, isError, isFormioError as isFormioErrorUtil, getErrorMessage, } from './errorUtils';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/hooks/useTheme.d.ts

@@ -0,0 +1,10 @@
+export declare const useTheme: () => {
+    theme: import("../context/FormioContext").FormioTheme;
+    getThemeValue: (path: string, fallback?: any) => any;
+    createStyles: (styleFactory: (theme: any) => any) => any;
+    getColor: (colorKey: string, fallback?: string) => any;
+    getSpacing: (spacingKey: string, fallback?: number) => any;
+    getTypography: (typographyPath: string, fallback?: any) => any;
+    getComponent: (componentPath: string, fallback?: any) => any;
+};
+//# sourceMappingURL=useTheme.d.ts.map

package/lib/typescript/commonjs/i18n/I18nContext.d.ts

@@ -0,0 +1,10 @@
+import React, { ReactNode } from 'react';
+import { I18nConfig, I18nContextValue } from './types';
+interface I18nProviderProps {
+    children: ReactNode;
+    config?: I18nConfig;
+}
+export declare const I18nProvider: React.FC<I18nProviderProps>;
+export declare const useI18n: () => I18nContextValue;
+export {};
+//# sourceMappingURL=I18nContext.d.ts.map

package/lib/typescript/commonjs/i18n/locales/ar/index.d.ts

@@ -0,0 +1,3 @@
+export declare const AR_TRANSLATIONS: Record<string, string>;
+export default AR_TRANSLATIONS;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/i18n/locales/fr/index.d.ts

@@ -0,0 +1,3 @@
+export declare const FR_TRANSLATIONS: Record<string, string>;
+export default FR_TRANSLATIONS;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/i18n/messages.d.ts

@@ -0,0 +1,10 @@
+import { VALIDATION_MESSAGES } from '../constants/validationMessages';
+type Params = Record<string, any> | undefined;
+declare function formatMessage(template: string, params?: Params): string;
+export declare function getValidationMessage(key: keyof typeof VALIDATION_MESSAGES, params?: Params, translate?: (k: string, fallback?: string) => string): string;
+declare const _default: {
+    formatMessage: typeof formatMessage;
+    getValidationMessage: typeof getValidationMessage;
+};
+export default _default;
+//# sourceMappingURL=messages.d.ts.map

package/lib/typescript/commonjs/i18n/translations/en.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_EN_TRANSLATIONS: Record<string, string>;
+export declare const DEFAULT_TRANSLATIONS: Record<string, Record<string, string>>;
+export default DEFAULT_TRANSLATIONS;
+//# sourceMappingURL=en.d.ts.map

package/lib/typescript/commonjs/i18n/types.d.ts

@@ -0,0 +1,12 @@
+export interface I18nConfig {
+    language: string;
+    translations: Record<string, Record<string, string>>;
+    rtlLanguages?: string[];
+}
+export interface I18nContextValue {
+    language: string;
+    isRTL: boolean;
+    translate: (key: string, fallback?: string) => string;
+    setLanguage: (language: string) => void;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,35 @@
+export { FormioForm } from './components/FormioForm';
+export { FormioField } from './components/FormioField';
+export { CheckboxField } from './components/CheckboxField';
+export { DatePicker } from './components/DatePicker';
+export { FileUpload } from './components/FileUpload';
+export { ResourceSelect } from './components/ResourceSelect';
+export { DataGrid } from './components/DataGrid';
+export { EditGrid } from './components/EditGrid';
+export { Wizard } from './components/Wizard';
+export { TextfieldRenderer } from './components/renderers/TextfieldRenderer';
+export { EmailRenderer } from './components/renderers/EmailRenderer';
+export { NumberRenderer } from './components/renderers/NumberRenderer';
+export { CheckboxRenderer } from './components/renderers/CheckboxRenderer';
+export { RadioRenderer } from './components/renderers/RadioRenderer';
+export { SelectRenderer } from './components/renderers/SelectRenderer';
+export { SelectboxesRenderer } from './components/renderers/SelectboxesRenderer';
+export { TextAreaRenderer } from './components/renderers/TextAreaRenderer';
+export { PasswordRenderer } from './components/renderers/PasswordRenderer';
+export { URLRenderer } from './components/renderers/URLRenderer';
+export { PhoneNumberRenderer } from './components/renderers/PhoneNumberRenderer';
+export { FallbackRenderer } from './components/renderers/FallbackRenderer';
+export { DEFAULT_RENDERERS } from './components/renderers';
+export { ComponentRegistry, createDefaultRegistry, createRegistryWithComponents } from './registry/ComponentRegistry';
+export type { ComponentRenderer, ComponentRenderProps } from './registry/ComponentRegistry';
+export { validateForm, validateField } from './validation';
+export { FormioProvider, useFormioContext, useRegistry } from './context/FormioContext';
+export { useTheme } from './hooks/useTheme';
+export { useI18n } from './i18n/I18nContext';
+export type { ComponentOverrides, FormioTheme } from './context/FormioContext';
+export type { I18nConfig, I18nContextValue } from './i18n/types';
+export * from './types';
+export * from './utils';
+export * from './constants';
+export * from './errors';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/package.json

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

package/lib/typescript/commonjs/registry/ComponentRegistry.d.ts

@@ -0,0 +1,32 @@
+import { ReactNode } from 'react';
+import { FormioComponent, FormData, ValidationError } from '../types';
+export interface ComponentRenderProps {
+    component: FormioComponent;
+    value: any;
+    onChange: (value: any) => void;
+    error?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    formData?: FormData;
+    validationErrors?: ValidationError[];
+}
+export type ComponentRenderer = (props: ComponentRenderProps) => ReactNode;
+export declare class ComponentRegistry {
+    private renderers;
+    register(type: string, renderer: ComponentRenderer): void;
+    registerBatch(components: Record<string, ComponentRenderer>): void;
+    unregister(type: string): boolean;
+    get(type: string): ComponentRenderer | null;
+    has(type: string): boolean;
+    list(): string[];
+    count(): number;
+    clear(): void;
+    override(type: string, renderer: ComponentRenderer): boolean;
+    getStats(): {
+        totalRegistered: number;
+        types: string[];
+    };
+}
+export declare function createDefaultRegistry(): ComponentRegistry;
+export declare function createRegistryWithComponents(components: Record<string, ComponentRenderer>): ComponentRegistry;
+//# sourceMappingURL=ComponentRegistry.d.ts.map

package/lib/typescript/commonjs/registry/index.d.ts

@@ -0,0 +1,3 @@
+export { ComponentRegistry, createDefaultRegistry, createRegistryWithComponents } from './ComponentRegistry';
+export type { ComponentRenderer, ComponentRenderProps } from './ComponentRegistry';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/types.d.ts

@@ -0,0 +1,142 @@
+export type FormioValue = any;
+export interface Conditional {
+    show?: boolean;
+    when?: string;
+    eq?: any;
+    json?: string;
+}
+export interface ValidateRule {
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    min?: number;
+    max?: number;
+    custom?: string;
+    customMessage?: string;
+}
+export type DataSrc = 'values' | 'json' | 'resource' | 'url';
+export interface DataSource {
+    dataSrc?: DataSrc;
+    values?: Array<{
+        label: string;
+        value: any;
+    }>;
+    json?: any;
+    resource?: string;
+    url?: string;
+}
+export interface FormioComponentBase {
+    type: string;
+    key: string;
+    label?: string;
+    description?: string;
+    placeholder?: string;
+    required?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+    multiple?: boolean;
+    defaultValue?: any;
+    input?: boolean;
+    components?: FormioComponent[];
+    conditional?: Conditional;
+    customConditional?: string;
+    calculateValue?: string;
+    validate?: ValidateRule;
+    data?: DataSource;
+}
+export type FormioComponent = FormioComponentBase & {
+    [key: string]: any;
+};
+export interface DateComponent extends FormioComponent {
+    type: 'date' | 'datetime' | 'time';
+    format?: string;
+    enableTime?: boolean;
+    enableDate?: boolean;
+    minDate?: string;
+    maxDate?: string;
+    widget?: string;
+    validate?: ValidateRule & {
+        min?: string;
+        max?: string;
+    };
+}
+export interface FileComponent extends FormioComponent {
+    type: 'file';
+    storage?: 'base64' | 's3' | 'url' | 'fileSystem';
+    fileTypes?: string[];
+    multiple?: boolean;
+    validate?: ValidateRule & {
+        maxSize?: string;
+    };
+}
+export interface ResourceSelectComponent extends FormioComponent {
+    type: 'select';
+    data?: DataSource & {
+        dataSrc: 'url' | 'resource';
+        url?: string;
+        resource?: string;
+        searchField?: string;
+    };
+    searchEnabled?: boolean;
+    debounce?: number;
+    placeholder?: string;
+}
+export interface DataGridComponent extends FormioComponent {
+    type: 'datagrid';
+    components: FormioComponent[];
+    minLength?: number;
+    maxLength?: number;
+    validate?: ValidateRule;
+}
+export interface EditGridComponent extends FormioComponent {
+    type: 'editgrid';
+    components: FormioComponent[];
+    inlineEdit?: boolean;
+}
+export interface ColumnsComponent extends FormioComponent {
+    type: 'columns';
+    columns: Array<{
+        width?: number;
+        offset?: number;
+        push?: number;
+        pull?: number;
+        components: FormioComponent[];
+    }>;
+}
+export interface WizardPage extends FormioComponent {
+    type: 'panel';
+    components: FormioComponent[];
+}
+export interface WizardComponent extends FormioComponent {
+    type: 'wizard';
+    pages: WizardPage[];
+}
+export interface FormioFormSchema {
+    components: FormioComponent[];
+    display?: string;
+    title?: string;
+}
+export interface FormData {
+    [key: string]: any;
+}
+export interface ValidationError {
+    field: string;
+    message: string;
+}
+export interface RenderOptions {
+    readOnly?: boolean;
+    showAllErrors?: boolean;
+}
+export interface FormProps {
+    form: FormioFormSchema;
+    data?: FormData;
+    options?: RenderOptions;
+    components?: {
+        [type: string]: any;
+    };
+    onSubmit?: (data: FormData) => void;
+    onChange?: (data: FormData) => void;
+    onValidation?: (errors: ValidationError[]) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/commonjs/utils/a11yUtils.d.ts

@@ -0,0 +1,31 @@
+export type AriaRole = 'button' | 'checkbox' | 'radio' | 'textbox' | 'combobox' | 'listbox' | 'option' | 'group' | 'form' | 'alert' | 'alertdialog' | 'dialog' | 'progressbar' | 'status' | 'tab' | 'tablist' | 'tabpanel';
+export interface AriaAttributes {
+    role?: AriaRole;
+    label?: string;
+    hint?: string;
+    disabled?: boolean;
+    required?: boolean;
+    valueText?: string;
+    errorMessage?: string;
+    invalid?: boolean;
+    keyboardHint?: string;
+}
+export declare function getFieldAriaAttributes(label: string | undefined, error: string | undefined, required?: boolean, disabled?: boolean, hint?: string): Record<string, any>;
+export declare function getButtonAriaAttributes(label: string, disabled?: boolean, hint?: string): Record<string, any>;
+export declare function getCheckboxAriaAttributes(label: string, checked: boolean, disabled?: boolean, hint?: string): Record<string, any>;
+export declare function getRadioAriaAttributes(label: string, selected: boolean, disabled?: boolean, hint?: string): Record<string, any>;
+export declare function getSelectAriaAttributes(label: string, selectedValue: string | undefined, disabled?: boolean, error?: string, hint?: string): Record<string, any>;
+export declare function getTextInputAriaAttributes(label: string, value: string | undefined, disabled?: boolean, error?: string, hint?: string, required?: boolean): Record<string, any>;
+export declare function getFormAriaAttributes(title?: string, description?: string): Record<string, any>;
+export declare function getErrorAriaAttributes(message: string): Record<string, any>;
+export declare function getLoadingAriaAttributes(message?: string): Record<string, any>;
+export declare function getModalAriaAttributes(title: string, description?: string): Record<string, any>;
+export declare function getListItemAriaAttributes(label: string, index: number, total: number): Record<string, any>;
+export declare function getTabAriaAttributes(label: string, selected: boolean, index: number): Record<string, any>;
+export declare function combineAriaAttributes(...attributes: Array<Record<string, any>>): Record<string, any>;
+export declare function createAccessibleLabel(label: string, required?: boolean, error?: boolean): string;
+export declare function getKeyboardHint(componentType: string): string;
+export declare function isAccessibilityEnabled(): boolean;
+export declare function announceToScreenReader(message: string): void;
+export declare function getHeadingAriaAttributes(level: 1 | 2 | 3 | 4 | 5 | 6, text: string): Record<string, any>;
+//# sourceMappingURL=a11yUtils.d.ts.map

package/lib/typescript/commonjs/utils/index.d.ts

@@ -0,0 +1,9 @@
+export { safeEval, safeEvalConditional, safeEvalValidation, safeEvalValue } from './safeEval';
+export type { EvalContext, SafeEvalOptions, SafeEvalResult } from './safeEval';
+export declare function isEmpty(val: any): boolean;
+export { Logger, configureLogger, getLoggerConfig, globalLogger } from './logger';
+export type { LoggerConfig } from './logger';
+export { LogLevel } from './logger';
+export { createStyleUtilities, createPlatformStyles } from './styleUtils';
+export type { StyleUtilities } from './styleUtils';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/utils/logger.d.ts

@@ -0,0 +1,25 @@
+export declare enum LogLevel {
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error"
+}
+export interface LoggerConfig {
+    enabled?: boolean;
+    level?: LogLevel;
+    prefix?: boolean;
+    colors?: boolean;
+}
+export declare function configureLogger(config: Partial<LoggerConfig>): void;
+export declare function getLoggerConfig(): LoggerConfig;
+export declare class Logger {
+    private readonly namespace;
+    constructor(namespace: string);
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, error?: Error | any, ...args: any[]): void;
+    private _log;
+}
+export declare const globalLogger: Logger;
+//# sourceMappingURL=logger.d.ts.map

package/lib/typescript/commonjs/utils/rtlUtils.d.ts

@@ -0,0 +1,18 @@
+import { ViewStyle, TextStyle } from 'react-native';
+export declare function getTextAlign(isRTL: boolean): 'left' | 'right' | 'center';
+export declare function getFlexDirection(isRTL: boolean): 'row' | 'row-reverse' | 'column' | 'column-reverse';
+export declare function getTextDirection(isRTL: boolean): 'rtl' | 'ltr';
+export declare function swapMargins(style: ViewStyle | TextStyle, isRTL: boolean): ViewStyle | TextStyle;
+export declare function swapPadding(style: ViewStyle | TextStyle, isRTL: boolean): ViewStyle | TextStyle;
+export declare function swapBorderRadius(style: ViewStyle | TextStyle, isRTL: boolean): ViewStyle | TextStyle;
+export declare function applyRTLStyle(style: ViewStyle | TextStyle, isRTL: boolean): ViewStyle | TextStyle;
+export declare function createRTLStyle(ltrStyle: ViewStyle | TextStyle, rtlStyle?: ViewStyle | TextStyle, isRTL?: boolean): ViewStyle | TextStyle;
+export declare function getIconRotation(isRTL: boolean, defaultRotation?: number): number;
+export declare function getIconFlipTransform(isRTL: boolean): Array<{
+    scaleX: number;
+}>;
+export declare function isSystemRTL(): boolean;
+export declare function getAlignSelf(isRTL: boolean, alignment: 'flex-start' | 'flex-end' | 'center'): 'flex-start' | 'flex-end' | 'center';
+export declare function getJustifyContent(isRTL: boolean, justify: 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around'): string;
+export declare function createRTLAwareStyle(style: ViewStyle | TextStyle, isRTL: boolean): ViewStyle | TextStyle;
+//# sourceMappingURL=rtlUtils.d.ts.map

package/lib/typescript/commonjs/utils/safeEval.d.ts

@@ -0,0 +1,20 @@
+export interface EvalContext {
+    data: Record<string, any>;
+    row?: Record<string, any>;
+    value?: any;
+    util?: Record<string, any>;
+    input?: any;
+    show?: boolean;
+    valid?: boolean;
+}
+export interface SafeEvalOptions {
+    timeout?: number;
+    allowedVariables?: string[];
+    debug?: boolean;
+}
+export type SafeEvalResult = boolean | string | undefined | any;
+export declare function safeEval(code: string, ctx: EvalContext, options?: SafeEvalOptions): SafeEvalResult;
+export declare function safeEvalConditional(code: string, ctx: EvalContext, options?: SafeEvalOptions): boolean;
+export declare function safeEvalValidation(code: string, ctx: EvalContext, options?: SafeEvalOptions): boolean | string;
+export declare function safeEvalValue(code: string, ctx: EvalContext, options?: SafeEvalOptions): any;
+//# sourceMappingURL=safeEval.d.ts.map

package/lib/typescript/commonjs/utils/styleUtils.d.ts

@@ -0,0 +1,13 @@
+import { ViewStyle, TextStyle } from 'react-native';
+import { FormioTheme } from '../context/FormioContext';
+export interface StyleUtilities {
+    getColor: (key: string, fallback?: string) => string | undefined;
+    getSpacing: (key: string, fallback?: number) => number | undefined;
+    getFont: (key: string, fallback?: number) => number | undefined;
+    getComponentValue: (path: string, fallback?: any) => any;
+    createStyles: (callback: (theme: FormioTheme) => any) => any;
+    createRTLStyles: (ltrStyle: ViewStyle | TextStyle, rtlStyle?: ViewStyle | TextStyle) => ViewStyle | TextStyle;
+}
+export declare function createStyleUtilities(theme?: FormioTheme): StyleUtilities;
+export declare function createPlatformStyles(iosStyle: ViewStyle | TextStyle, androidStyle?: ViewStyle | TextStyle): ViewStyle | TextStyle;
+//# sourceMappingURL=styleUtils.d.ts.map

package/lib/typescript/commonjs/validation.d.ts

@@ -0,0 +1,8 @@
+import { FormioComponent, FormData, ValidationError } from './types';
+export declare const validateField: (component: FormioComponent, value: any, fullData?: Record<string, any>, options?: {
+    translate?: (key: string, fallback?: string) => string;
+}) => ValidationError[];
+export declare const validateForm: (components: FormioComponent[], data: FormData, options?: {
+    translate?: (key: string, fallback?: string) => string;
+}) => ValidationError[];
+//# sourceMappingURL=validation.d.ts.map