@umituz/react-native-design-system 4.25.99 → 4.25.100

package/dist/onboarding/domain/entities/OnboardingQuestion.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Onboarding Question Entity
+ *
+ * Domain entity representing a personalization question in the onboarding flow
+ */
+/**
+ * Possible answer value types for onboarding questions
+ */
+export type OnboardingAnswerValue = string | string[] | number | undefined;
+/**
+ * Question types for different input methods
+ */
+export type QuestionType = "single_choice" | "multiple_choice" | "text_input" | "rating" | "date" | "image_picker";
+/**
+ * Option for single/multiple choice questions
+ */
+export interface QuestionOption {
+    /**
+     * Unique identifier for the option
+     */
+    id: string;
+    /**
+     * Display label for the option
+     */
+    label: string;
+    /**
+     * Optional icon (emoji or Ionicons name)
+     */
+    icon?: string;
+    /**
+     * Optional image URL
+     */
+    image?: string;
+    /**
+     * Optional value (if different from label)
+     */
+    value?: string;
+    /**
+     * Type of icon: 'emoji' or 'icon' (default: 'icon')
+     */
+    iconType?: 'emoji' | 'icon';
+}
+/**
+ * Validation rules for questions
+ */
+export interface QuestionValidation {
+    /**
+     * Is this question required?
+     */
+    required?: boolean;
+    /**
+     * Minimum value (for rating)
+     */
+    min?: number;
+    /**
+     * Maximum value (for rating)
+     */
+    max?: number;
+    /**
+     * Minimum length (for text input)
+     */
+    minLength?: number;
+    /**
+     * Maximum length (for text input)
+     */
+    maxLength?: number;
+    /**
+     * Minimum selections (for multiple choice)
+     */
+    minSelections?: number;
+    /**
+     * Maximum selections (for multiple choice)
+     */
+    maxSelections?: number;
+    /**
+     * Custom validation function
+     */
+    customValidator?: (value: OnboardingAnswerValue) => boolean | string;
+}
+/**
+ * Onboarding Question
+ * Represents a personalization question in the onboarding flow
+ */
+export interface OnboardingQuestion {
+    /**
+     * Unique identifier for the question
+     */
+    id: string;
+    /**
+     * Question type
+     */
+    type: QuestionType;
+    /**
+     * Question text
+     */
+    question: string;
+    /**
+     * Optional subtitle/description
+     */
+    subtitle?: string;
+    /**
+     * Optional placeholder text (for text input)
+     */
+    placeholder?: string;
+    /**
+     * Options for single/multiple choice questions
+     */
+    options?: QuestionOption[];
+    /**
+     * Validation rules
+     */
+    validation?: QuestionValidation;
+    /**
+     * Default value
+     */
+    defaultValue?: OnboardingAnswerValue;
+    /**
+     * Storage key for saving the answer
+     */
+    storageKey: string;
+    /**
+     * Optional icon for the question
+     */
+    icon?: string;
+    /**
+     * Type of icon: 'emoji' or 'icon' (default: 'icon')
+     */
+    iconType?: 'emoji' | 'icon';
+    /**
+     * Skip this question if condition is met
+     * @param answers - Previous answers
+     * @returns true to skip, false to show
+     */
+    skipIf?: (answers: Record<string, OnboardingAnswerValue>) => boolean;
+}

package/dist/onboarding/domain/entities/OnboardingSlide.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Onboarding Slide Entity
+ *
+ * Domain entity representing a single onboarding slide
+ */
+type VideoSource = string | {
+    uri: string;
+    headers?: Record<string, string>;
+    [key: string]: unknown;
+};
+import type { ImageSourceType } from "../types/ImageSourceType";
+import type { OnboardingQuestion, OnboardingAnswerValue } from "./OnboardingQuestion";
+/**
+ * Slide type - determines the content and behavior
+ */
+export type SlideType = "info" | "question" | "welcome" | "completion";
+/**
+ * Content position - determines where the text content is positioned
+ */
+export type ContentPosition = "center" | "bottom";
+/**
+ * Onboarding Slide
+ * Each slide represents one step in the onboarding flow
+ */
+export interface OnboardingSlide {
+    id: string;
+    type?: SlideType;
+    title: string;
+    description: string;
+    icon?: string;
+    iconType?: 'emoji' | 'icon';
+    hideIcon?: boolean;
+    contentPosition?: ContentPosition;
+    backgroundColor?: string;
+    useCustomBackground?: boolean;
+    image?: ImageSourceType;
+    backgroundImage?: ImageSourceType;
+    backgroundImages?: ImageSourceType[];
+    backgroundImagesLayout?: 'grid' | 'dense' | 'masonry' | 'collage' | 'scattered' | 'tiles' | 'honeycomb';
+    backgroundImagesColumns?: number;
+    backgroundImagesGap?: number;
+    backgroundImagesBorderRadius?: number;
+    backgroundVideo?: VideoSource;
+    overlayOpacity?: number;
+    features?: string[];
+    question?: OnboardingQuestion;
+    skipIf?: (answers: Record<string, OnboardingAnswerValue>) => boolean;
+}
+export {};

package/dist/onboarding/domain/entities/OnboardingUserData.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Onboarding User Data Entity
+ *
+ * Domain entity representing collected user data from onboarding
+ */
+import type { OnboardingAnswerValue } from "./OnboardingQuestion";
+/**
+ * User data collected during onboarding
+ */
+export interface OnboardingUserData {
+    /**
+     * User's answers to questions
+     * Key: question ID, Value: answer
+     */
+    answers: Record<string, OnboardingAnswerValue>;
+    /**
+     * Timestamp when onboarding was completed
+     */
+    completedAt?: string;
+    /**
+     * Was onboarding skipped?
+     */
+    skipped?: boolean;
+    /**
+     * User preferences derived from answers
+     */
+    preferences?: Record<string, unknown>;
+    /**
+     * User profile data
+     */
+    profile?: {
+        name?: string;
+        email?: string;
+        age?: number;
+        gender?: string;
+        [key: string]: string | number | undefined;
+    };
+}

package/dist/onboarding/domain/types/ImageSourceType.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Image Source Type
+ * Domain type for image sources used in onboarding slides.
+ * Compatible with expo-image ImageSource (optional peer dep).
+ */
+export type ImageSourceType = number | string | {
+    uri: string;
+    headers?: Record<string, string>;
+    cacheKey?: string;
+    [key: string]: unknown;
+};

package/dist/onboarding/hooks/useOnboardingFlow.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Onboarding Flow Hook
+ * Manages onboarding completion state with persistence
+ */
+export interface UseOnboardingFlowResult {
+    isOnboardingComplete: boolean;
+    completeOnboarding: () => Promise<void>;
+}
+export declare const useOnboardingFlow: () => UseOnboardingFlowResult;

package/dist/onboarding/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * React Native Onboarding - Public API
+ *
+ * Generic onboarding flow for React Native apps with custom backgrounds,
+ * animations, and customizable slides. Follows SOLID, DRY, KISS principles.
+ *
+ * Architecture:
+ * - Domain: Entities and interfaces (business logic)
+ * - Infrastructure: Storage and hooks (state management)
+ * - Presentation: Components and screens (UI)
+ *
+ * Usage:
+ *   import { OnboardingScreen, OnboardingSlide } from '@umituz/react-native-onboarding';
+ *
+ *   <OnboardingScreen
+ *     slides={[
+ *       {
+ *         id: '1',
+ *         title: 'Welcome',
+ *         description: 'Welcome to the app',
+ *         icon: '🎉',
+ *         backgroundColor: '#3B82F6',
+ *       },
+ *     ]}
+ *   />
+ */
+export type { OnboardingSlide, SlideType } from "./domain/entities/OnboardingSlide";
+export type { OnboardingOptions } from "./domain/entities/OnboardingOptions";
+export type { OnboardingQuestion, QuestionType, QuestionOption, QuestionValidation, } from "./domain/entities/OnboardingQuestion";
+export type { OnboardingUserData } from "./domain/entities/OnboardingUserData";
+export { useOnboardingStore, useOnboarding, } from "./infrastructure/storage/OnboardingStore";
+export type { OnboardingStoreState } from "./infrastructure/storage/OnboardingStoreState";
+export type { OnboardingStoreActions } from "./infrastructure/storage/OnboardingStoreActions";
+export type { OnboardingStoreSelectors } from "./infrastructure/storage/OnboardingStoreSelectors";
+export { useOnboardingNavigation, type UseOnboardingNavigationReturn, } from "./infrastructure/hooks/useOnboardingNavigation";
+export { useOnboardingContainerStyle, type UseOnboardingContainerStyleProps, type UseOnboardingContainerStyleReturn, } from "./presentation/hooks/useOnboardingContainerStyle";
+export { OnboardingScreen, type OnboardingScreenProps } from "./presentation/screens/OnboardingScreen";
+export { OnboardingHeader, type OnboardingHeaderProps } from "./presentation/components/OnboardingHeader";
+export { OnboardingFooter, type OnboardingFooterProps } from "./presentation/components/OnboardingFooter";
+export { OnboardingProvider, type OnboardingProviderProps, type OnboardingTranslations, useOnboardingProvider } from "./presentation/providers/OnboardingProvider";
+export { BackgroundImageCollage, type CollageLayout, type BackgroundImageCollageProps } from "./presentation/components/BackgroundImageCollage";
+export type { OnboardingTheme, OnboardingColors } from "./presentation/types/OnboardingTheme";
+export { ensureArray, safeIncludes, safeFilter } from "./infrastructure/utils/arrayUtils";
+export type { ImageLayoutItem, LayoutConfig } from "./infrastructure/utils/layouts";
+import { OnboardingSlide as OnboardingSlideComponent } from "./presentation/components/OnboardingSlide";
+export { OnboardingSlideComponent };
+export type { OnboardingSlideProps } from "./presentation/components/OnboardingSlide";
+export { QuestionSlide } from "./presentation/components/QuestionSlide";
+export type { QuestionSlideProps } from "./presentation/components/QuestionSlide";
+export { SingleChoiceQuestion } from "./presentation/components/questions/SingleChoiceQuestion";
+export type { SingleChoiceQuestionProps } from "./presentation/components/questions/SingleChoiceQuestion";
+export { MultipleChoiceQuestion } from "./presentation/components/questions/MultipleChoiceQuestion";
+export type { MultipleChoiceQuestionProps } from "./presentation/components/questions/MultipleChoiceQuestion";
+export { TextInputQuestion } from "./presentation/components/questions/TextInputQuestion";
+export type { TextInputQuestionProps } from "./presentation/components/questions/TextInputQuestion";
+export { RatingQuestion } from "./presentation/components/questions/RatingQuestion";
+export type { RatingQuestionProps } from "./presentation/components/questions/RatingQuestion";
+export { OnboardingResetSetting } from "./presentation/components/OnboardingResetSetting";
+export type { OnboardingResetSettingProps } from "./presentation/components/OnboardingResetSetting";
+export { useOnboardingFlow, type UseOnboardingFlowResult } from './hooks/useOnboardingFlow';

package/dist/onboarding/infrastructure/hooks/useOnboardingAnswers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * useOnboardingAnswers Hook
+ *
+ * Manages answer state and operations for onboarding questions
+ * Follows Single Responsibility Principle
+ */
+import type { OnboardingSlide } from "../../domain/entities/OnboardingSlide";
+import type { OnboardingAnswerValue } from "../../domain/entities/OnboardingQuestion";
+export interface UseOnboardingAnswersReturn {
+    currentAnswer: OnboardingAnswerValue;
+    setCurrentAnswer: (answer: OnboardingAnswerValue) => void;
+    loadAnswerForSlide: (slide: OnboardingSlide | undefined) => void;
+    saveCurrentAnswer: (slide: OnboardingSlide | undefined) => Promise<void>;
+}
+/**
+ * Hook for managing onboarding question answers
+ * @param currentSlide - The current slide being displayed
+ * @returns Answer state and operations
+ */
+export declare function useOnboardingAnswers(currentSlide: OnboardingSlide | undefined): UseOnboardingAnswersReturn;

package/dist/onboarding/infrastructure/hooks/useOnboardingNavigation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * useOnboardingNavigation Hook
+ *
+ * Manages navigation state and callbacks for onboarding flow
+ */
+export interface UseOnboardingNavigationReturn {
+    currentIndex: number;
+    goToNext: () => void;
+    goToPrevious: () => void;
+    complete: () => Promise<void>;
+    skip: () => Promise<void>;
+    isLastSlide: boolean;
+    isFirstSlide: boolean;
+}
+/**
+ * Hook for managing onboarding navigation
+ *
+ * @param totalSlides - Total number of slides
+ * @param onComplete - Callback when onboarding completes
+ * @param onSkip - Callback when onboarding is skipped
+ * @returns Navigation state and handlers
+ */
+export declare const useOnboardingNavigation: (totalSlides: number, onComplete?: () => void | Promise<void>, onSkip?: () => void | Promise<void>) => UseOnboardingNavigationReturn;

package/dist/onboarding/infrastructure/services/SlideManager.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Onboarding Slide Service
+ *
+ * Business logic for filtering and processing onboarding slides
+ * Follows Single Responsibility Principle
+ */
+import type { OnboardingSlide } from "../../domain/entities/OnboardingSlide";
+import type { OnboardingUserData } from "../../domain/entities/OnboardingUserData";
+/**
+ * SlideManager
+ */
+export declare class SlideManager {
+    /**
+     * Filter slides based on skipIf conditions
+     * @param slides - All available slides
+     * @param userData - User's onboarding data including answers
+     * @returns Filtered slides that should be shown
+     */
+    static filterSlides(slides: OnboardingSlide[] | undefined, userData: OnboardingUserData): OnboardingSlide[];
+    /**
+     * Get slide at specific index
+     * @param slides - Filtered slides array
+     * @param index - Slide index
+     * @returns Slide at index or undefined
+     */
+    static getSlideAtIndex(slides: OnboardingSlide[], index: number): OnboardingSlide | undefined;
+}

package/dist/onboarding/infrastructure/services/ValidationManager.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Onboarding Validation Service
+ *
+ * Business logic for validating onboarding question answers
+ * Follows Single Responsibility Principle
+ */
+import type { OnboardingQuestion, OnboardingAnswerValue } from "../../domain/entities/OnboardingQuestion";
+/**
+ * ValidationManager
+ */
+export declare class ValidationManager {
+    /**
+     * Validate answer against question validation rules
+     * @param question - The question to validate against
+     * @param answer - The answer to validate
+     * @returns true if valid, false otherwise
+     */
+    static validateAnswer(question: OnboardingQuestion, answer: OnboardingAnswerValue): boolean;
+    /**
+     * Validate multiple choice answer
+     */
+    private static validateMultipleChoice;
+    /**
+     * Validate text input answer
+     */
+    private static validateTextInput;
+    /**
+     * Validate date answer (ISO string from date picker)
+     */
+    private static validateDate;
+    /**
+     * Validate numeric answer (rating)
+     */
+    private static validateNumeric;
+}

package/dist/onboarding/infrastructure/storage/OnboardingStore.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Onboarding Store
+ *
+ * Zustand store for managing onboarding completion state
+ * Uses @storage for persistence
+ */
+import type { OnboardingStoreState } from "./OnboardingStoreState";
+import type { OnboardingUserData } from "../../domain/entities/OnboardingUserData";
+interface OnboardingActions {
+    setCurrentStep: (step: number) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    setState: (state: Partial<OnboardingStoreState>) => void;
+    getState: () => OnboardingStoreState;
+    initialize: (storageKey?: string) => Promise<void>;
+    complete: (storageKey?: string) => Promise<void>;
+    skip: (storageKey?: string) => Promise<void>;
+    reset: (storageKey?: string) => Promise<void>;
+    saveAnswer: (questionId: string, answer: unknown) => Promise<void>;
+    setUserData: (data: OnboardingUserData) => Promise<void>;
+}
+export declare const useOnboardingStore: import("zustand").UseBoundStore<import("zustand").StoreApi<OnboardingStoreState & OnboardingActions>>;
+/**
+ * Hook for accessing onboarding state
+ * Memoized to prevent unnecessary re-renders in consumer components
+ */
+export declare const useOnboarding: () => {
+    isOnboardingComplete: boolean;
+    currentStep: number;
+    loading: boolean;
+    error: string | null;
+    userData: OnboardingUserData;
+    initialize: (storageKey?: string) => Promise<void>;
+    complete: (storageKey?: string) => Promise<void>;
+    skip: (storageKey?: string) => Promise<void>;
+    setCurrentStep: (step: number) => void;
+    reset: (storageKey?: string) => Promise<void>;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    saveAnswer: (questionId: string, answer: unknown) => Promise<void>;
+    setUserData: (data: OnboardingUserData) => Promise<void>;
+    getAnswer: (questionId: string) => import("../../domain/entities/OnboardingQuestion").OnboardingAnswerValue;
+    getUserData: () => OnboardingStoreState["userData"];
+};
+export {};

package/dist/onboarding/infrastructure/storage/OnboardingStoreActions.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Onboarding Store Actions
+ * Single Responsibility: Async store actions interface and factory
+ */
+import type { OnboardingUserData } from "../../domain/entities/OnboardingUserData";
+import type { OnboardingStoreState } from "./OnboardingStoreState";
+export interface OnboardingStoreActions {
+    initialize: (storageKey?: string) => Promise<void>;
+    complete: (storageKey?: string) => Promise<void>;
+    skip: (storageKey?: string) => Promise<void>;
+    reset: (storageKey?: string) => Promise<void>;
+    saveAnswer: (questionId: string, answer: unknown) => Promise<void>;
+    setUserData: (data: OnboardingUserData) => Promise<void>;
+}
+export declare function createOnboardingStoreActions(set: (state: Partial<OnboardingStoreState>) => void, get: () => OnboardingStoreState): OnboardingStoreActions;

package/dist/onboarding/infrastructure/storage/OnboardingStoreSelectors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Onboarding Store Selectors
+ * Single Responsibility: Store state selectors
+ */
+import type { OnboardingAnswerValue } from "../../domain/entities/OnboardingQuestion";
+import type { OnboardingStoreState } from "./OnboardingStoreState";
+export interface OnboardingStoreSelectors {
+    getAnswer: (questionId: string) => OnboardingAnswerValue;
+    getUserData: () => OnboardingStoreState['userData'];
+}
+export declare function createOnboardingStoreSelectors(get: () => OnboardingStoreState): OnboardingStoreSelectors;

package/dist/onboarding/infrastructure/storage/OnboardingStoreState.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Onboarding Store State
+ * Single Responsibility: Store state interface and initial state
+ */
+import type { OnboardingUserData } from "../../domain/entities/OnboardingUserData";
+export interface OnboardingStoreState {
+    isOnboardingComplete: boolean;
+    currentStep: number;
+    loading: boolean;
+    error: string | null;
+    userData: OnboardingUserData;
+}
+export declare const initialOnboardingState: OnboardingStoreState;

package/dist/onboarding/infrastructure/storage/actions/answerActions.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Answer Actions
+ * Single Responsibility: Save and update user answers
+ */
+import type { OnboardingUserData } from "../../../domain/entities/OnboardingUserData";
+import type { OnboardingStoreState } from "../OnboardingStoreState";
+export declare function saveAnswerAction(set: (state: Partial<OnboardingStoreState>) => void, get: () => OnboardingStoreState, questionId: string, answer: unknown): Promise<void>;
+export declare function setUserDataAction(set: (state: Partial<OnboardingStoreState>) => void, data: OnboardingUserData): Promise<void>;

package/dist/onboarding/infrastructure/storage/actions/completeAction.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Complete Action
+ * Single Responsibility: Mark onboarding as completed
+ */
+import type { OnboardingStoreState } from "../OnboardingStoreState";
+export declare function completeAction(set: (state: Partial<OnboardingStoreState>) => void, get: () => OnboardingStoreState, storageKey: string): Promise<void>;

package/dist/onboarding/infrastructure/storage/actions/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Actions Index
+ * Single Responsibility: Export all action functions
+ */
+export { loadCompletionStatus, loadUserData, saveCompletionStatus, saveUserData, removeStorageKeys, handleError, logSuccess, DEFAULT_STORAGE_KEY, USER_DATA_STORAGE_KEY, } from "./storageHelpers";
+export { initializeAction } from "./initializeAction";
+export { completeAction } from "./completeAction";
+export { skipAction } from "./skipAction";
+export { resetAction } from "./resetAction";
+export { saveAnswerAction, setUserDataAction } from "./answerActions";

package/dist/onboarding/infrastructure/storage/actions/initializeAction.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Initialize Action
+ * Single Responsibility: Load initial onboarding state from storage
+ */
+import type { OnboardingStoreState } from "../OnboardingStoreState";
+export declare function initializeAction(set: (state: Partial<OnboardingStoreState>) => void, storageKey: string): Promise<void>;

package/dist/onboarding/infrastructure/storage/actions/resetAction.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reset Action
+ * Single Responsibility: Reset onboarding state
+ */
+import type { OnboardingStoreState } from "../OnboardingStoreState";
+export declare function resetAction(set: (state: Partial<OnboardingStoreState>) => void, storageKey: string): Promise<void>;

package/dist/onboarding/infrastructure/storage/actions/skipAction.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Skip Action
+ * Single Responsibility: Mark onboarding as skipped
+ */
+import type { OnboardingStoreState } from "../OnboardingStoreState";
+export declare function skipAction(set: (state: Partial<OnboardingStoreState>) => void, get: () => OnboardingStoreState, storageKey: string): Promise<void>;

package/dist/onboarding/infrastructure/storage/actions/storageHelpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Storage Helpers
+ * Single Responsibility: Common storage operations and error handling
+ */
+import type { OnboardingUserData } from "../../../domain/entities/OnboardingUserData";
+export declare const DEFAULT_STORAGE_KEY = "@onboarding:completed";
+export declare const USER_DATA_STORAGE_KEY = "@onboarding:user_data";
+export declare function loadCompletionStatus(storageKey: string): Promise<boolean>;
+export declare function loadUserData(defaultData: OnboardingUserData): Promise<OnboardingUserData>;
+export declare function saveCompletionStatus(storageKey: string): Promise<void>;
+export declare function saveUserData(data: OnboardingUserData): Promise<void>;
+export declare function removeStorageKeys(storageKey: string): Promise<void>;
+export declare function handleError(error: unknown, context: string): string;
+export declare function logSuccess(_message: string): void;

package/dist/onboarding/infrastructure/utils/arrayUtils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Array Utilities
+ * Safe array operations for onboarding components
+ */
+/**
+ * Ensures the value is a valid array, returns empty array if not
+ */
+export declare const ensureArray: <T>(value: T[] | undefined | null) => T[];
+/**
+ * Safe includes check that handles undefined/null values
+ */
+export declare const safeIncludes: <T>(array: T[] | undefined | null, item: T) => boolean;
+/**
+ * Safe filter that handles undefined/null values
+ */
+export declare const safeFilter: <T>(array: T[] | undefined | null, predicate: (item: T) => boolean) => T[];

package/dist/onboarding/infrastructure/utils/backgroundUtils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Background Utilities
+ *
+ * Utility functions for background-related operations
+ * Follows Single Responsibility Principle
+ */
+import type { OnboardingSlide } from "../../domain/entities/OnboardingSlide";
+/**
+ * Check if slide should use custom background or overlay
+ * Indicates that we are not using the default theme background.
+ *
+ * @param slide - The slide to check
+ * @param globalUseCustomBackground - Global option from OnboardingOptions
+ * @returns true if custom background/media should be used, false otherwise
+ */
+export declare function shouldUseCustomBackground(slide: OnboardingSlide | undefined, globalUseCustomBackground?: boolean): boolean;

package/dist/onboarding/infrastructure/utils/layouts/collageLayout.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Collage Layout Generator
+ * Random collage with varying sizes
+ */
+import type { ImageLayoutItem, LayoutConfig, ImageSourceType } from "./layoutTypes";
+export declare const generateCollageLayout: (images: ImageSourceType[], config?: LayoutConfig) => ImageLayoutItem[];

package/dist/onboarding/infrastructure/utils/layouts/gridLayouts.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Grid Layout Generators
+ * Standard and dense grid layouts with safe area support
+ */
+import type { ImageLayoutItem, LayoutConfig, ImageSourceType } from "./layoutTypes";
+export declare const generateGridLayout: (images: ImageSourceType[], config?: LayoutConfig) => ImageLayoutItem[];
+export declare const generateDenseGridLayout: (images: ImageSourceType[], config?: LayoutConfig) => ImageLayoutItem[];

package/dist/onboarding/infrastructure/utils/layouts/honeycombLayout.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Honeycomb Layout Generator
+ * Hexagonal pattern layout
+ */
+import type { ImageLayoutItem, LayoutConfig, ImageSourceType } from "./layoutTypes";
+export declare const generateHoneycombLayout: (images: ImageSourceType[], config?: LayoutConfig) => ImageLayoutItem[];

package/dist/onboarding/infrastructure/utils/layouts/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Layout Generators - Barrel Export
+ */
+export type { ImageLayoutItem, ImageLayoutStyle, LayoutConfig, ImageSourceType } from "./layoutTypes";
+export { generateGridLayout, generateDenseGridLayout } from "./gridLayouts";
+export { generateMasonryLayout } from "./masonryLayout";
+export { generateCollageLayout } from "./collageLayout";
+export { generateScatteredLayout } from "./scatteredLayout";
+export { generateTilesLayout } from "./tilesLayout";
+export { generateHoneycombLayout } from "./honeycombLayout";