@webority-technologies/mobile 0.0.1

package/lib/module/versionCheck/index.js

@@ -0,0 +1,334 @@
+"use strict";
+
+import { getBundleId, getSystemName, getVersion } from 'react-native-device-info';
+import { useEffect, useState } from 'react';
+import { getConfigValue } from "../config/index.js";
+import { Logger } from "../logger/index.js";
+
+// Constants
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 3000; // 3 seconds
+
+const getCountry = () => getConfigValue('country', 'in').toLowerCase();
+// Utility function to parse and coerce version to a valid format
+const parseVersion = version => {
+  Logger.info(`Parsing version: ${version}`);
+  const coercedVersion = version.replace(/[^0-9.]/g, '');
+  const versionParts = coercedVersion.split('.').map(Number);
+  return {
+    major: versionParts[0] || 0,
+    minor: versionParts[1] || 0,
+    patch: versionParts[2] || 0,
+    prerelease: version.includes('-') ? version.split('-')[1] ?? '' : ''
+  };
+};
+
+// Utility function to compare two versions loosely
+const diffLoose = (version1, version2) => {
+  Logger.info(`Comparing versions: ${version1} and ${version2}`);
+  if (version1 === version2) {
+    return null;
+  }
+  const v1 = parseVersion(version1);
+  const v2 = parseVersion(version2);
+  if (v1.major < v2.major) {
+    return 'major';
+  }
+  if (v1.major > v2.major) {
+    return null;
+  }
+  if (v1.minor < v2.minor) {
+    return 'minor';
+  }
+  if (v1.minor > v2.minor) {
+    return null;
+  }
+  if (v1.patch < v2.patch) {
+    return 'patch';
+  }
+  if (v1.patch > v2.patch) {
+    return null;
+  }
+  if (v1.prerelease && !v2.prerelease) {
+    return 'prerelease';
+  }
+  if (!v1.prerelease && v2.prerelease) {
+    return null;
+  }
+  if (v1.prerelease < v2.prerelease) {
+    return 'prerelease';
+  }
+  if (v1.prerelease > v2.prerelease) {
+    return null;
+  }
+  return null;
+};
+
+// Function to compare current version with the latest version
+const versionCompare = (currentVersion, latestVersion) => {
+  Logger.info(`Comparing current version: ${currentVersion} with latest version: ${latestVersion}`);
+  if (!latestVersion) {
+    return {
+      needsUpdate: false,
+      updateType: null,
+      notice: 'Error: could not get latest version'
+    };
+  }
+  try {
+    const updateType = diffLoose(currentVersion, latestVersion);
+    return {
+      needsUpdate: !!updateType,
+      updateType
+    };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    Logger.error(`Error comparing versions: ${message}`);
+    const needsUpdate = currentVersion !== latestVersion && latestVersion > currentVersion;
+    const updateType = needsUpdate ? 'minor' : null;
+    return {
+      needsUpdate,
+      updateType,
+      notice: message.replace(/^Invalid Version:/, 'Not a valid version:')
+    };
+  }
+};
+
+// Function to fetch version details from Google Play Store
+const fetchAndroidVersion = async url => {
+  Logger.info(`Fetching Android version from URL: ${url}`);
+  let response;
+  try {
+    response = await fetch(url, {
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.96 Mobile Safari/537.36',
+        'sec-fetch-site': 'same-origin'
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    Logger.error(`Error fetching data from Google Play Store: ${message}`);
+    throw new Error('Error fetching data from Google Play Store.');
+  }
+  if (!response.ok) {
+    if (response.status === 404) {
+      Logger.error('App with app ID not found in Google Play.');
+      throw new Error(`App with app ID not found in Google Play.`);
+    }
+    Logger.error(`Error fetching data: ${response.statusText}`);
+    throw new Error(response.statusText);
+  }
+  const text = await response.text();
+
+  // Primary regex pattern for current Play Store format
+  let versionMatch = text.match(/\[\[\[['"]((\d+\.)+\d+)['"]\]\],/);
+
+  // Alternate patterns as fallbacks
+  if (!versionMatch) {
+    // Fallback 1: Look for version in "current version" text
+    versionMatch = text.match(/Current Version[^\d]+((\d+\.)+\d+)/i);
+  }
+  if (!versionMatch) {
+    // Fallback 2: Look for itemprop="softwareVersion"
+    versionMatch = text.match(/itemprop="softwareVersion"[^>]*>((\d+\.)+\d+)</i);
+  }
+  if (!versionMatch) {
+    // Fallback 3: Try a more generic pattern for version numbers
+    const allVersions = text.match(/(\d+\.\d+(\.\d+)?)/g);
+    // If we found multiple version-like strings, use the first one
+    versionMatch = allVersions && allVersions.length > 0 ? [null, allVersions[0]] : null;
+  }
+  const version = versionMatch ? versionMatch[1] ?? null : null;
+  if (!version) {
+    Logger.warn('Could not extract version from Play Store. Using fallback method.');
+  }
+  const notesMatch = text.match(/<div itemprop="description">(.*?)<\/div>/);
+  const notes = notesMatch ? notesMatch[1] ?? '' : '';
+  return {
+    version,
+    releasedAt: new Date().toISOString(),
+    notes,
+    url,
+    lastChecked: new Date().toISOString()
+  };
+};
+// Function to fetch version details from Apple App Store
+const fetchIosVersion = async url => {
+  Logger.info(`Fetching iOS version from URL: ${url}`);
+  let response;
+  try {
+    response = await fetch(url);
+  } catch {
+    Logger.error('Error connecting to iTunes.');
+    throw new Error('Error connecting to iTunes.');
+  }
+  const data = await response.json();
+  if (!data || !('results' in data)) {
+    Logger.error('Unknown error connecting to iTunes.');
+    throw new Error('Unknown error connecting to iTunes.');
+  }
+  if (!data.results.length) {
+    Logger.error('App for this bundle ID not found.');
+    throw new Error('App for this bundle ID not found.');
+  }
+  const result = data.results[0];
+  return {
+    version: result.version || null,
+    released: result.currentVersionReleaseDate || result.releaseDate || null,
+    notes: result.releaseNotes || '',
+    url: result.trackViewUrl || result.artistViewUrl || result.sellerUrl || null,
+    country: getCountry(),
+    lastChecked: new Date().toISOString()
+  };
+};
+
+// Function to lookup version based on platform
+const lookupVersion = async (platform, identifier) => {
+  Logger.info(`Looking up version for platform: ${platform}, identifier: ${identifier}`);
+  const country = getCountry();
+  const url = platform === 'ios' ? `https://itunes.apple.com/lookup?bundleId=${identifier}&country=${country}&_=${new Date().valueOf()}` : `https://play.google.com/store/apps/details?id=${identifier}&hl=${country}`;
+  return platform === 'ios' ? fetchIosVersion(url) : fetchAndroidVersion(url);
+};
+
+/**
+ * Check for new version with retry logic
+ */
+const checkForUpdates = async () => {
+  const platform = getSystemName().toLowerCase();
+  const identifier = getBundleId();
+  const currentVersion = getVersion();
+
+  // Implement retry mechanism
+  let retryCount = 0;
+  let lastError = null;
+  while (retryCount <= MAX_RETRIES) {
+    try {
+      Logger.info(`Checking if new version is available (attempt ${retryCount + 1}/${MAX_RETRIES + 1})`);
+      Logger.info(`Platform: ${platform}, identifier: ${identifier}, current version: ${currentVersion}`);
+      const latestVersionInfo = await lookupVersion(platform, identifier);
+      const comparison = versionCompare(currentVersion, latestVersionInfo.version);
+      return {
+        isNewVersionAvailable: comparison.needsUpdate,
+        updateType: comparison.updateType,
+        url: latestVersionInfo.url
+      };
+    } catch (error) {
+      lastError = error;
+      const message = error instanceof Error ? error.message : String(error);
+      Logger.error(`Error checking version (attempt ${retryCount + 1}/${MAX_RETRIES + 1}): ${message}`);
+
+      // If we've reached max retries, throw the last error
+      if (retryCount === MAX_RETRIES) {
+        throw error;
+      }
+
+      // Otherwise, wait and retry
+      retryCount++;
+      Logger.info(`Retrying version check in ${RETRY_DELAY}ms...`);
+      await new Promise(resolve => setTimeout(resolve, RETRY_DELAY));
+    }
+  }
+
+  // This should never be reached due to the throw above, but just in case
+  throw lastError instanceof Error ? lastError : new Error('Failed to check for updates after multiple attempts');
+};
+
+/**
+ * Get fallback store URL based on platform
+ */
+const getFallbackStoreUrl = () => {
+  const platform = getSystemName().toLowerCase();
+  const bundleId = getBundleId();
+  const country = getCountry();
+  return platform === 'ios' ? `https://apps.apple.com/${country}/app/${bundleId}` : `https://play.google.com/store/apps/details?id=${bundleId}&hl=${country}`;
+};
+// Version check functionality
+export const VersionCheck = {
+  isNewVersionAvailable: async () => {
+    return checkForUpdates();
+  },
+  openUpdateUrl: async url => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const {
+      Linking
+    } = require('react-native');
+    try {
+      if (url) {
+        Logger.info(`Opening app store URL: ${url}`);
+        await Linking.openURL(url);
+      } else {
+        const fallbackUrl = getFallbackStoreUrl();
+        Logger.info(`Opening fallback store URL: ${fallbackUrl}`);
+        await Linking.openURL(fallbackUrl);
+      }
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      Logger.error(`Failed to open store URL: ${message}`);
+
+      // Try with fallback URL if the original failed
+      try {
+        if (url) {
+          // Only try fallback if we were using a specific URL before
+          const fallbackUrl = getFallbackStoreUrl();
+          Logger.info(`Trying fallback store URL: ${fallbackUrl}`);
+          await Linking.openURL(fallbackUrl);
+          return true;
+        }
+      } catch (fallbackError) {
+        const fbMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+        Logger.error(`Failed to open fallback URL: ${fbMessage}`);
+      }
+      return false;
+    }
+  },
+  getFallbackStoreUrl
+};
+
+/**
+ * Custom hook to check for required app updates.
+ *
+ * @param isAppReady - Whether the app is ready to perform the check
+ * @param environment - The app environment (defaults to the one in config)
+ */
+export const useVersionCheck = (isAppReady, environment = getConfigValue('environment', 'Development')) => {
+  const [updateInfo, setUpdateInfo] = useState({
+    isUpdateRequired: false,
+    updateUrl: null
+  });
+  useEffect(() => {
+    let isMounted = true;
+    const checkVersion = async () => {
+      try {
+        // All retry logic is handled in the VersionCheck module
+        const {
+          isNewVersionAvailable,
+          url
+        } = await VersionCheck.isNewVersionAvailable();
+        if (isNewVersionAvailable && isMounted) {
+          Logger.info('Update required. URL:', url || 'Not available yet');
+          setUpdateInfo({
+            isUpdateRequired: true,
+            updateUrl: url
+          });
+        } else if (isMounted) {
+          Logger.info('App is up to date');
+        }
+      } catch (error) {
+        Logger.error('Error checking app version:', error);
+      }
+    };
+
+    // Only run version check in Production environment when app is ready
+    if (isAppReady && environment === 'Production') {
+      void checkVersion();
+    }
+    return () => {
+      isMounted = false;
+    };
+  }, [isAppReady, environment]);
+  return updateInfo;
+};
+
+// Export for backward compatibility
+export default VersionCheck;
+//# sourceMappingURL=index.js.map

package/lib/typescript/commonjs/api/publicClient.d.ts

@@ -0,0 +1,11 @@
+import { type AxiosInstance } from 'axios';
+/**
+ * Public Axios Client
+ * - Base URL: Set your public API base URL.
+ * - No Authorization header is attached.
+ * - Includes timeout configuration and error handling.
+ * - Handles specific HTTP status codes.
+ */
+declare const publicClient: AxiosInstance;
+export default publicClient;
+//# sourceMappingURL=publicClient.d.ts.map

package/lib/typescript/commonjs/api/userClient.d.ts

@@ -0,0 +1,18 @@
+import { type AxiosInstance } from 'axios';
+import type { AuthActions } from '../initUserAuth';
+/**
+ * Minimal Redux-store shape required by the user client to dispatch
+ * refresh-token / logout actions.
+ */
+export interface RefreshableStore {
+    dispatch: (action: unknown) => Promise<{
+        error?: {
+            message?: string;
+        };
+    }>;
+}
+declare const userClient: AxiosInstance;
+export declare const injectStore: <S>(_store: S) => void;
+export declare const injectAuthActions: (actions: AuthActions) => void;
+export default userClient;
+//# sourceMappingURL=userClient.d.ts.map

package/lib/typescript/commonjs/auth/authStore.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Token data persisted in the keychain.
+ */
+export interface StoredToken {
+    token: string;
+    expiry: string;
+}
+/**
+ * Store token with expiry.
+ */
+export declare const storeToken: (key: string, token: string, expiry: string) => Promise<void>;
+/**
+ * Retrieve token and check if expired.
+ */
+export declare const getToken: (key: string) => Promise<StoredToken | null>;
+/**
+ * Remove token by key.
+ */
+export declare const removeToken: (key: string) => Promise<void>;
+//# sourceMappingURL=authStore.d.ts.map

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

@@ -0,0 +1,5 @@
+export { storeToken, getToken, removeToken } from './authStore';
+export type { StoredToken } from './authStore';
+export { decodeJWT, isJWTExpired, getJWTExpiry } from './jwt';
+export type { JwtClaims } from './jwt';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/auth/jwt.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Standard claims plus arbitrary keys.
+ * `sub`, `exp`, `iat`, `nbf` follow RFC 7519 conventions.
+ */
+export interface JwtClaims {
+    sub?: string;
+    exp?: number;
+    iat?: number;
+    nbf?: number;
+    iss?: string;
+    aud?: string | string[];
+    [key: string]: unknown;
+}
+/**
+ * Decode a JWT's payload claims. Does **not** verify the signature.
+ *
+ * @returns claims object on success, `null` if the token is malformed.
+ */
+export declare const decodeJWT: <T extends JwtClaims = JwtClaims>(token: string) => T | null;
+/**
+ * Returns true when the token is expired (or unparseable / missing `exp`).
+ *
+ * @param token JWT string
+ * @param leewaySeconds amount of clock-skew tolerance to apply (default 30s)
+ */
+export declare const isJWTExpired: (token: string, leewaySeconds?: number) => boolean;
+/**
+ * Returns the token's expiry as a Date, or `null` when no `exp` claim exists.
+ */
+export declare const getJWTExpiry: (token: string) => Date | null;
+//# sourceMappingURL=jwt.d.ts.map

package/lib/typescript/commonjs/components/Accordion/Accordion.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+export type AccordionVariant = 'plain' | 'card';
+export interface AccordionProps {
+    title: string;
+    children: React.ReactNode;
+    id?: string;
+    expanded?: boolean;
+    defaultExpanded?: boolean;
+    onChange?: (expanded: boolean) => void;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    variant?: AccordionVariant;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    headerStyle?: StyleProp<ViewStyle>;
+    contentStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+export interface AccordionGroupProps {
+    children: React.ReactNode;
+    allowMultiple?: boolean;
+    defaultExpandedKeys?: string[];
+    expandedKeys?: string[];
+    onChange?: (keys: string[]) => void;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const AccordionGroup: React.FC<AccordionGroupProps>;
+declare const Accordion: React.FC<AccordionProps>;
+export { Accordion, AccordionGroup };
+export default Accordion;
+//# sourceMappingURL=Accordion.d.ts.map

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

@@ -0,0 +1,3 @@
+export { Accordion, AccordionGroup, default } from './Accordion';
+export type { AccordionProps, AccordionGroupProps, AccordionVariant } from './Accordion';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/Avatar/Avatar.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import { View } from 'react-native';
+import type { ImageSourcePropType, StyleProp, TextStyle, ViewStyle } from 'react-native';
+export type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+export type AvatarShape = 'circle' | 'square' | 'rounded';
+export type AvatarStatus = 'online' | 'offline' | 'busy' | 'away' | null;
+export type AvatarStatusPosition = 'topRight' | 'bottomRight';
+export interface AvatarProps {
+    source?: ImageSourcePropType;
+    name?: string;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    status?: AvatarStatus;
+    statusPosition?: AvatarStatusPosition;
+    backgroundColor?: string;
+    color?: string;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<View>>;
+export type AvatarGroupSpacing = 'tight' | 'normal' | 'loose';
+export type AvatarGroupOverflowVariant = 'count' | 'plus';
+export interface AvatarGroupProps {
+    children: React.ReactElement<AvatarProps>[];
+    max?: number;
+    size?: AvatarSize;
+    spacing?: AvatarGroupSpacing;
+    overflowVariant?: AvatarGroupOverflowVariant;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const AvatarGroup: React.FC<AvatarGroupProps>;
+type AvatarComponent = typeof Avatar & {
+    Group: typeof AvatarGroup;
+};
+declare const AvatarWithGroup: AvatarComponent;
+export { Avatar, AvatarGroup };
+export default AvatarWithGroup;
+//# sourceMappingURL=Avatar.d.ts.map

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

@@ -0,0 +1,3 @@
+export { Avatar, AvatarGroup, default } from './Avatar';
+export type { AvatarProps, AvatarSize, AvatarShape, AvatarStatus, AvatarStatusPosition, AvatarGroupProps, AvatarGroupSpacing, AvatarGroupOverflowVariant } from './Avatar';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/Badge/Badge.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { View } from 'react-native';
+import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+export type BadgeVariant = 'standard' | 'dot';
+export type BadgeTone = 'primary' | 'success' | 'warning' | 'error' | 'neutral' | 'info';
+export type BadgeSize = 'sm' | 'md';
+export type BadgeAnchor = 'topRight' | 'topLeft' | 'bottomRight' | 'bottomLeft';
+export interface BadgeProps {
+    value?: number | string;
+    max?: number;
+    variant?: BadgeVariant;
+    tone?: BadgeTone;
+    size?: BadgeSize;
+    invisible?: boolean;
+    children?: React.ReactNode;
+    anchor?: BadgeAnchor;
+    pulse?: boolean;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    badgeStyle?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<View>>;
+export { Badge };
+export default Badge;
+//# sourceMappingURL=Badge.d.ts.map

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

@@ -0,0 +1,3 @@
+export { Badge, default } from './Badge';
+export type { BadgeProps, BadgeVariant, BadgeTone, BadgeSize, BadgeAnchor } from './Badge';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/Banner/Banner.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { View } from 'react-native';
+import type { StyleProp, ViewStyle } from 'react-native';
+export type BannerVariant = 'info' | 'success' | 'warning' | 'error' | 'neutral';
+export interface BannerAction {
+    label: string;
+    onPress: () => void;
+    tone?: 'primary' | 'neutral';
+}
+export interface BannerProps {
+    title?: string;
+    message: string | React.ReactNode;
+    variant?: BannerVariant;
+    icon?: React.ReactNode | false;
+    actions?: BannerAction[];
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    visible?: boolean;
+    animateMount?: boolean;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+declare const Banner: React.ForwardRefExoticComponent<BannerProps & React.RefAttributes<View>>;
+export { Banner };
+export default Banner;
+//# sourceMappingURL=Banner.d.ts.map

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

@@ -0,0 +1,3 @@
+export { Banner, default } from './Banner';
+export type { BannerProps, BannerVariant, BannerAction } from './Banner';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/BottomNavigation/BottomNavigation.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import { View } from 'react-native';
+import type { StyleProp, TextStyle, ViewStyle } from 'react-native';
+import type { HapticType } from '../../utils';
+export type BottomNavigationVariant = 'pill' | 'underline';
+export type TabBadge = number | string | boolean | null;
+export interface TabIconProps {
+    color: string;
+    size: number;
+    focused: boolean;
+}
+export interface TabConfig {
+    key: string;
+    label: string;
+    icon: (props: TabIconProps) => React.ReactNode;
+    activeIcon?: (props: TabIconProps) => React.ReactNode;
+    badge?: TabBadge;
+}
+export interface BottomNavigationProps {
+    tabs: TabConfig[];
+    activeTab: string;
+    onTabPress: (tabKey: string) => void;
+    haptic?: HapticType | false;
+    showLabels?: boolean;
+    variant?: BottomNavigationVariant;
+    style?: StyleProp<ViewStyle>;
+    indicatorStyle?: StyleProp<ViewStyle>;
+    labelStyle?: StyleProp<TextStyle>;
+    testID?: string;
+}
+declare const BottomNavigation: React.ForwardRefExoticComponent<BottomNavigationProps & React.RefAttributes<View>>;
+export { BottomNavigation };
+export default BottomNavigation;
+//# sourceMappingURL=BottomNavigation.d.ts.map

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

@@ -0,0 +1,3 @@
+export { BottomNavigation, default } from './BottomNavigation';
+export type { BottomNavigationProps, BottomNavigationVariant, TabConfig, TabIconProps, TabBadge } from './BottomNavigation';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/components/BottomSheet/BottomSheet.d.ts

@@ -0,0 +1,45 @@
+/**
+ * BottomSheet — Reanimated 3 + Gesture Handler 2 implementation.
+ *
+ * A polished, theme-aware bottom sheet with multi-snap-point support,
+ * UI-thread driven pan gestures, and native-driver spring animations.
+ *
+ * USAGE:
+ *
+ * const ref = useRef<BottomSheetRef>(null);
+ * <BottomSheet ref={ref} snapPoints={[200, '50%', '90%']}>
+ *   <YourContent />
+ * </BottomSheet>
+ *
+ * ref.current?.expand();   // open at first snap point (or `index` prop)
+ * ref.current?.expand(2);  // open at specific index
+ * ref.current?.collapse(); // animate to smallest snap point
+ * ref.current?.close();    // dismiss
+ */
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+export type SnapPoint = number | `${number}%`;
+export interface BottomSheetProps {
+    snapPoints: SnapPoint[];
+    index?: number;
+    onChange?: (index: number) => void;
+    onAnimate?: (from: number, to: number) => void;
+    enablePanDownToClose?: boolean;
+    enableBackdropPress?: boolean;
+    backdropOpacity?: number;
+    handleIndicatorStyle?: StyleProp<ViewStyle>;
+    containerStyle?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+    accessibilityLabel?: string;
+    accessibilityViewIsModal?: boolean;
+    testID?: string;
+}
+export interface BottomSheetRef {
+    expand: (index?: number) => void;
+    collapse: () => void;
+    close: () => void;
+}
+declare const BottomSheet: React.ForwardRefExoticComponent<BottomSheetProps & React.RefAttributes<BottomSheetRef>>;
+export { BottomSheet };
+export default BottomSheet;
+//# sourceMappingURL=BottomSheet.d.ts.map

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

@@ -0,0 +1,3 @@
+export { BottomSheet, default } from './BottomSheet';
+export type { BottomSheetProps, BottomSheetRef, SnapPoint } from './BottomSheet';
+//# sourceMappingURL=index.d.ts.map