@teamvortexsoftware/vortex-react-native 0.0.13 → 1.0.1

package/dist/index.d.mts

@@ -0,0 +1,656 @@
+import react__default from 'react';
+import { UnsignedData, WidgetConfiguration } from '@teamvortexsoftware/vortex-types';
+export { EmailGroupMembershipCheckFunction, EmailGroupMembershipCheckResult, UnsignedData } from '@teamvortexsoftware/vortex-types';
+import { EventName } from '@teamvortexsoftware/analytics-client';
+export { EventName, EventNames } from '@teamvortexsoftware/analytics-client';
+import { F as FindFriendsConfig, I as IncomingInvitationsConfig, O as OutgoingInvitationsConfig, a as InviteContactsConfig, S as SearchBoxConfig, b as InvitationSuggestionsConfig, c as IconRendererProps } from './InviteFormCore-D4HkMMo0.mjs';
+export { g as FindFriendsContact, f as IconName, i as IncomingInvitationItem, d as InvitationFormCore, e as InvitationFormCoreProps, h as InvitationItem, k as InviteContactsContact, d as InviteFormCore, j as OutgoingInvitationItem } from './InviteFormCore-D4HkMMo0.mjs';
+export { C as Contact, P as PlatformOperations, V as ViewType, u as useInvitationFormLogic } from './useInvitationFormLogic-Ct73M19B.mjs';
+export { MOCK_CONTACTS, MOCK_GOOGLE_CONTACTS } from './constants/mockData.mjs';
+export { filterContacts } from './utils/contactUtils.mjs';
+
+declare const DEFAULT_ANALYTICS_URL = "https://collector.vortexsoftware.com";
+/**
+ * Analytics event interface for React Native SDK
+ * Based on AnalyticsEvent from analytics-client with additional mobile-specific fields
+ */
+interface VortexAnalyticsEvent {
+    name: EventName;
+    widgetConfigurationId: string;
+    deploymentId: string;
+    environmentId: string;
+    platform: string;
+    segmentation?: Record<string, any>;
+    payload?: Record<string, any>;
+    groups?: Array<{
+        type: string;
+        id: string;
+        name: string;
+    }>;
+    timestamp: number;
+    sessionId?: string;
+    useragent?: string;
+    foreignUserId?: string;
+}
+/**
+ * Simplified analytics event for components that emit minimal events.
+ * These components emit (name + segmentation) and the parent
+ * is responsible for enriching with widgetConfigurationId, deploymentId, etc.
+ */
+interface SimpleAnalyticsEvent {
+    name: EventName;
+    segmentation?: Record<string, any>;
+    payload?: Record<string, any>;
+}
+/**
+ * Group DTO for analytics events
+ */
+interface GroupDTO {
+    type: string;
+    id: string;
+    name: string;
+}
+
+/**
+ * Configuration for Open Graph unfurl metadata.
+ * Used to customize link previews when sharing invitation links.
+ *
+ * @example
+ * ```tsx
+ * <VortexInvite
+ *   componentId="abc123"
+ *   unfurlConfig={{
+ *     title: "Join our team!",
+ *     description: "You've been invited to collaborate",
+ *     image: "https://example.com/preview.png",
+ *     siteName: "My App",
+ *   }}
+ * />
+ * ```
+ */
+interface UnfurlConfig {
+    /** The title for the link preview (og:title) */
+    title?: string;
+    /** The description for the link preview (og:description) */
+    description?: string;
+    /** URL to an image for the link preview (og:image) */
+    image?: string;
+    /** The site name for the link preview (og:site_name) */
+    siteName?: string;
+    /** The type of content (og:type), defaults to "website" */
+    type?: string;
+}
+/**
+ * Converts UnfurlConfig to the metadata format expected by the API.
+ */
+declare function unfurlConfigToMetadata(config: UnfurlConfig): Record<string, string>;
+
+/**
+ * VortexModulesContext
+ *
+ * Internal context for passing optional module configuration AND loader functions
+ * from entry points (VortexInvite/InviteFormWeb) down to child components
+ * without prop drilling.
+ *
+ * This is completely internal to the SDK - end users only need to pass props
+ * to <VortexInvite> and everything works automatically.
+ *
+ * The key insight is that entry points inject the appropriate loader functions:
+ * - Native entry (index.tsx/InviteFormMobile) injects loaders from moduleLoaders.ts
+ * - Web entry (preview.tsx/InviteFormWeb) injects loaders from moduleLoaders.web.ts
+ *
+ * This way, components don't import loaders directly, avoiding Metro/webpack bundler issues.
+ *
+ * Example usage (internal):
+ * ```tsx
+ * // In a child component
+ * const { modules, loaders } = useVortexModules();
+ * const GradientComponent = loaders.loadGradientComponent(modules?.gradient);
+ * ```
+ */
+
+/**
+ * Supported gradient library module names.
+ * Users specify which library they have installed.
+ */
+type GradientModuleName = 'expo-linear-gradient' | 'react-native-linear-gradient';
+/**
+ * Supported haptics library module names.
+ */
+type HapticsModuleName = 'expo-haptics';
+/**
+ * Supported QR code library module names.
+ */
+type QRCodeModuleName = 'react-native-qrcode-svg' | 'react-qr-code';
+/**
+ * Supported clipboard library module names.
+ */
+type ClipboardModuleName = 'expo-clipboard' | '@react-native-clipboard/clipboard';
+/**
+ * Supported sharing library module names.
+ */
+type SharingModuleName = 'expo-sharing';
+/**
+ * Unified modules configuration object.
+ * Users specify which optional native libraries they have installed via a single prop.
+ *
+ * @example
+ * ```tsx
+ * <VortexInvite
+ *   componentId="abc123"
+ *   modules={{
+ *     gradient: 'expo-linear-gradient',
+ *     haptics: 'expo-haptics',
+ *     qrCode: 'react-native-qrcode-svg',
+ *   }}
+ * />
+ * ```
+ */
+interface VortexModules {
+    /**
+     * Gradient library for button backgrounds.
+     * For Expo: 'expo-linear-gradient'
+     * For bare RN: 'react-native-linear-gradient'
+     */
+    gradient?: GradientModuleName;
+    /**
+     * Haptics library for touch feedback.
+     * Currently only 'expo-haptics' is supported.
+     */
+    haptics?: HapticsModuleName;
+    /**
+     * QR code library for QR code display.
+     * For native: 'react-native-qrcode-svg'
+     * For web: 'react-qr-code'
+     */
+    qrCode?: QRCodeModuleName;
+    /**
+     * Clipboard library for copy functionality.
+     * For Expo: 'expo-clipboard'
+     * For bare RN: '@react-native-clipboard/clipboard'
+     */
+    clipboard?: ClipboardModuleName;
+    /**
+     * Sharing library for native share sheet.
+     * Currently only 'expo-sharing' is supported.
+     */
+    sharing?: SharingModuleName;
+}
+
+type VortexActionType = 'invite' | 'share';
+interface VortexActionResult {
+    type: VortexActionType;
+    data: string;
+}
+interface Attributes {
+    [key: string]: {
+        value: string | string[];
+        type: string;
+        role?: string;
+    };
+}
+interface VortexInviteProps {
+    vortexApiUrl?: string;
+    componentId: string;
+    jwt?: string;
+    user?: string | UnsignedData | undefined;
+    googleIosClientId?: string;
+    googleWebClientId?: string;
+    onSuccess?: (result: VortexActionResult) => void;
+    onError?: (error: Error, type: VortexActionType) => void;
+    onClose?: () => void;
+    contentTokens?: Attributes;
+    widgetConfiguration?: any;
+    group?: {
+        name: string;
+        type: string;
+        id?: string;
+        groupId?: string;
+    };
+    groups?: GroupDTO[];
+    scope?: string;
+    scopeType?: string;
+    analyticsBaseURL?: string;
+    onEvent?: (event: VortexAnalyticsEvent) => void;
+    analyticsSegmentation?: Record<string, any>;
+    /**
+     * Configuration for the Find Friends feature.
+     * When provided, enables the Find Friends component to display
+     * contacts with Connect buttons. When Connect is tapped and onConnect
+     * returns true, an invitation is created via the Vortex backend.
+     *
+     * @example
+     * ```tsx
+     * <VortexInvite
+     *   componentId="abc123"
+     *   findFriendsConfig={{
+     *     contacts: [
+     *       { userId: 'user-123', name: 'John Doe', subtitle: '@johndoe' },
+     *       { userId: 'user-456', name: 'Jane Smith', avatarUrl: 'https://...' },
+     *     ],
+     *     onConnect: async (contact) => {
+     *       // Perform any pre-connection validation
+     *       // Return true to create the invitation via Vortex backend
+     *       return true;
+     *     },
+     *     onInvitationCreated: (contact) => {
+     *       // Called after invitation is successfully created
+     *     },
+     *   }}
+     * />
+     * ```
+     */
+    findFriendsConfig?: FindFriendsConfig;
+    /**
+     * Configuration for the Incoming Invitations feature.
+     * When provided, enables the Incoming Invitations component to display
+     * invitations the user has received with Accept/Delete buttons.
+     */
+    incomingInvitationsConfig?: IncomingInvitationsConfig;
+    /**
+     * Configuration for the Outgoing Invitations feature.
+     * When provided, enables the Outgoing Invitations component to display
+     * invitations the user has sent with a Cancel button.
+     */
+    outgoingInvitationsConfig?: OutgoingInvitationsConfig;
+    /**
+     * Configuration for the Invite Contacts feature.
+     * When provided, enables the Invite Contacts component to display
+     * a list of contacts that can be invited via SMS.
+     *
+     * The component shows an "Invite your contacts" link that expands to
+     * a searchable contact list. When the user taps "Invite", an SMS
+     * invitation is created and the SMS app opens with a pre-filled message.
+     *
+     * @example
+     * ```tsx
+     * <VortexInvite
+     *   componentId="abc123"
+     *   inviteContactsConfig={{
+     *     contacts: [
+     *       { id: '1', name: 'John Doe', phoneNumber: '+1234567890' },
+     *       { id: '2', name: 'Jane Smith', phoneNumber: '+0987654321' },
+     *     ],
+     *     onInvite: (contact, shortLink) => {
+     *       console.log(`Invited ${contact.name} with link ${shortLink}`);
+     *     },
+     *   }}
+     * />
+     * ```
+     */
+    inviteContactsConfig?: InviteContactsConfig;
+    /**
+     * Configuration for the Search Box feature.
+     * When provided, enables the Search Box component with a search input,
+     * search button, and results list with Connect buttons.
+     */
+    searchBoxConfig?: SearchBoxConfig;
+    /**
+     * Locale code for internationalization (e.g., "es", "fr", "zh-TW").
+     * If provided and i18n is enabled on the widget, returns localized content.
+     */
+    locale?: string;
+    /**
+     * Configuration for invitation suggestions (People You May Know).
+     * When provided, enables the Invitation Suggestions component to display
+     * suggested contacts with Invite/Dismiss buttons.
+     */
+    invitationSuggestionsConfig?: InvitationSuggestionsConfig;
+    /**
+     * Configuration for Open Graph unfurl metadata.
+     * Used to customize link previews when sharing invitation links.
+     *
+     * @example
+     * ```tsx
+     * <VortexInvite
+     *   componentId="abc123"
+     *   unfurlConfig={{
+     *     title: "Join our team!",
+     *     description: "You've been invited to collaborate",
+     *     image: "https://example.com/preview.png",
+     *   }}
+     * />
+     * ```
+     */
+    unfurlConfig?: UnfurlConfig;
+    /**
+     * Configuration for optional native libraries.
+     * Specify which libraries you have installed in a single object.
+     *
+     * @example
+     * ```tsx
+     * <VortexInvite
+     *   componentId="abc123"
+     *   modules={{
+     *     gradient: 'expo-linear-gradient',
+     *     haptics: 'expo-haptics',
+     *     qrCode: 'react-native-qrcode-svg',
+     *   }}
+     * />
+     * ```
+     */
+    modules?: VortexModules;
+}
+declare function VortexInvite({ componentId, vortexApiUrl, jwt, user, googleIosClientId, googleWebClientId, onSuccess, onError, onClose, contentTokens, widgetConfiguration, group, groups, scope, scopeType, analyticsBaseURL, onEvent, analyticsSegmentation, findFriendsConfig, incomingInvitationsConfig, outgoingInvitationsConfig, inviteContactsConfig, searchBoxConfig, locale, invitationSuggestionsConfig, unfurlConfig, modules, }: VortexInviteProps): react__default.JSX.Element;
+
+interface InvitationFormProps {
+    platform?: 'ios' | 'android';
+    onClose?: () => void;
+    widgetConfiguration?: any;
+    componentId: string;
+    jwt?: string;
+    user?: string | UnsignedData | undefined;
+    vortexApiUrl?: string;
+    group?: {
+        name: string;
+        type: string;
+        id?: string;
+        groupId?: string;
+    };
+    groups?: GroupDTO[];
+    scope?: string;
+    scopeType?: string;
+    googleIosClientId?: string;
+    googleWebClientId?: string;
+    analyticsBaseURL?: string;
+    onEvent?: (event: VortexAnalyticsEvent) => void;
+    analyticsSegmentation?: Record<string, any>;
+    findFriendsConfig?: FindFriendsConfig;
+    incomingInvitationsConfig?: IncomingInvitationsConfig;
+    outgoingInvitationsConfig?: OutgoingInvitationsConfig;
+    invitationSuggestionsConfig?: InvitationSuggestionsConfig;
+    inviteContactsConfig?: InviteContactsConfig;
+    searchBoxConfig?: SearchBoxConfig;
+    locale?: string;
+    unfurlConfig?: UnfurlConfig;
+}
+declare function InviteFormMobile({ platform, onClose, widgetConfiguration: propsWidgetConfiguration, componentId, jwt, user, vortexApiUrl, group, groups, scope, scopeType, googleIosClientId, googleWebClientId, analyticsBaseURL, onEvent, analyticsSegmentation, findFriendsConfig, incomingInvitationsConfig, outgoingInvitationsConfig, inviteContactsConfig, searchBoxConfig, locale, invitationSuggestionsConfig, unfurlConfig, }: InvitationFormProps): react__default.JSX.Element;
+
+interface UsePrefetchWidgetConfigurationOptions {
+    componentId: string;
+    vortexApiUrl: string;
+    jwt?: string;
+    user?: string | UnsignedData;
+    enabled?: boolean;
+}
+/**
+ * Hook to prefetch widget configuration for instant rendering.
+ * This hook fetches the configuration early (e.g., when JWT becomes available)
+ * so the VortexInvite component can render immediately without showing a loading spinner.
+ *
+ * The hook will still refetch in the background when VortexInvite mounts to ensure
+ * the configuration is up-to-date (stale-while-revalidate pattern).
+ *
+ * @example
+ * ```tsx
+ * const { widgetConfiguration } = usePrefetchWidgetConfiguration({
+ *   componentId: 'your-component-id',
+ *   vortexApiUrl: 'https://client-api.vortexsoftware.com',
+ *   jwt,
+ *   enabled: !!jwt, // Only prefetch when JWT is ready
+ * });
+ *
+ * <VortexInvite
+ *   componentId={componentId}
+ *   jwt={jwt}
+ *   widgetConfiguration={widgetConfiguration} // Pass prefetched config
+ *   // ... other props
+ * />
+ * ```
+ */
+declare function usePrefetchWidgetConfiguration({ componentId, vortexApiUrl, jwt, user, enabled, }: UsePrefetchWidgetConfigurationOptions): {
+    widgetConfiguration: WidgetConfiguration | undefined;
+    error: Error | null;
+    isLoading: boolean;
+};
+
+declare const configCache: {
+    /**
+     * Get a cached widget configuration by component ID.
+     * @param componentId - The widget component ID
+     * @returns The cached configuration, or undefined if not found
+     */
+    get: (componentId: string) => WidgetConfiguration | undefined;
+    /**
+     * Store a widget configuration in the cache.
+     * @param componentId - The widget component ID
+     * @param config - The widget configuration to cache
+     */
+    set: (componentId: string, config: WidgetConfiguration) => void;
+    /**
+     * Clear cached configuration(s).
+     * @param componentId - Optional component ID to clear specific config. If omitted, clears all.
+     */
+    clear: (componentId?: string) => void;
+    /**
+     * Check if a configuration exists in the cache.
+     * @param componentId - The widget component ID
+     * @returns True if configuration is cached, false otherwise
+     */
+    has: (componentId: string) => boolean;
+    /**
+     * Get cache statistics for debugging.
+     */
+    stats: () => {
+        size: number;
+        keys: string[];
+    };
+};
+
+/**
+ * Device fingerprint data collected for deferred deep linking.
+ */
+interface DeviceFingerprint {
+    platform: 'ios' | 'android';
+    osVersion: string;
+    deviceModel: string;
+    deviceBrand: string;
+    timezone: string;
+    language: string;
+    screenWidth: number;
+    screenHeight: number;
+    carrierName?: string;
+    totalMemory?: number;
+}
+/**
+ * Response from the match-fingerprint API endpoint.
+ */
+interface MatchFingerprintResponse {
+    matched: boolean;
+    invitationId?: string;
+    deepLink?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Options for retrieving deferred deep links.
+ */
+interface RetrieveDeferredDeepLinkOptions {
+    /** JWT token for authentication */
+    jwt: string;
+    /** Optional base URL override (defaults to production) */
+    baseURL?: string;
+}
+/**
+ * VortexDeferredLinks provides deferred deep linking functionality.
+ *
+ * Deferred deep linking allows you to track invitation attribution even when
+ * the app wasn't installed at the time the invitation link was clicked.
+ *
+ * @example
+ * ```tsx
+ * import { VortexDeferredLinks } from '@teamvortexsoftware/vortex-react-native';
+ *
+ * // On app first launch after install
+ * async function checkDeferredDeepLink(jwt: string) {
+ *   const result = await VortexDeferredLinks.retrieveDeferredDeepLink({ jwt });
+ *   if (result.matched && result.deepLink) {
+ *     // Handle the deferred deep link
+ *     console.log('User came from invitation:', result.invitationId);
+ *     // Navigate to appropriate screen
+ *   }
+ * }
+ * ```
+ */
+declare class VortexDeferredLinks {
+    /**
+     * Collects device fingerprint data for matching.
+     * This data is used to match the device against fingerprints collected
+     * when invitation links were clicked.
+     */
+    static collectDeviceFingerprint(): DeviceFingerprint;
+    /**
+     * Retrieves a deferred deep link by matching the device fingerprint.
+     *
+     * Call this method on first app launch after installation to check if
+     * the user came from an invitation link.
+     *
+     * @param options - Configuration options including JWT and optional base URL
+     * @returns Promise resolving to match result with optional deep link
+     */
+    static retrieveDeferredDeepLink(options: RetrieveDeferredDeepLinkOptions): Promise<MatchFingerprintResponse>;
+}
+
+/**
+ * VortexClient provides API methods for invitation management.
+ *
+ * @example
+ * ```tsx
+ * import { VortexClient } from '@teamvortexsoftware/vortex-react-native';
+ *
+ * const client = new VortexClient({
+ *   jwt: 'your-jwt-token',
+ *   baseURL: 'https://client-api.vortexsoftware.com', // optional
+ * });
+ *
+ * // Revoke an outgoing invitation
+ * await client.revokeInvitation('invitation-id');
+ *
+ * // Accept an incoming invitation
+ * await client.acceptIncomingInvitation('invitation-id');
+ *
+ * // Delete an incoming invitation
+ * await client.deleteIncomingInvitation('invitation-id');
+ * ```
+ */
+interface VortexClientOptions {
+    /** JWT token for authentication */
+    jwt: string;
+    /** Optional base URL override (defaults to production) */
+    baseURL?: string;
+}
+interface InvitationResponse {
+    success: boolean;
+    message?: string;
+    data?: any;
+}
+/** Target of an invitation (e.g., email or SMS recipient) */
+interface InvitationTarget {
+    targetType: string;
+    targetValue: string;
+    targetName?: string;
+    targetAvatarUrl?: string;
+}
+/** Individual incoming invitation from the API */
+interface IncomingInvitation {
+    id: string;
+    targets?: InvitationTarget[];
+    senderIdentifier?: string;
+    senderIdentifierType?: string;
+    avatarUrl?: string;
+    status?: string;
+    createdAt?: string;
+    source?: string;
+    deliveryType?: string;
+    /** Name of the user who created this invitation */
+    creatorName?: string | null;
+    /** Avatar URL of the user who created this invitation */
+    creatorAvatarUrl?: string | null;
+    /** Internal ID of the user who created this invitation */
+    foreignCreatorId?: string | null;
+    /** Optional metadata attached to the invitation */
+    metadata?: Record<string, unknown>;
+}
+declare class VortexClient {
+    private jwt;
+    private baseURL;
+    constructor(options: VortexClientOptions);
+    /**
+     * Updates the JWT token used for authentication.
+     */
+    setJwt(jwt: string): void;
+    /**
+     * Revokes an outgoing invitation that the user has sent.
+     *
+     * @param invitationId - The ID of the invitation to revoke
+     * @returns Promise resolving to the response
+     */
+    revokeInvitation(invitationId: string): Promise<InvitationResponse>;
+    /**
+     * Accepts an incoming invitation that the user has received.
+     *
+     * @param invitationId - The ID of the invitation to accept
+     * @returns Promise resolving to the response
+     */
+    acceptIncomingInvitation(invitationId: string): Promise<InvitationResponse>;
+    /**
+     * Fetches incoming (open) invitations for the current user.
+     *
+     * @returns Promise resolving to the list of incoming invitations
+     */
+    getIncomingInvitations(): Promise<IncomingInvitation[]>;
+    /**
+     * Deletes/declines an incoming invitation that the user has received.
+     *
+     * @param invitationId - The ID of the invitation to delete
+     * @returns Promise resolving to the response
+     */
+    deleteIncomingInvitation(invitationId: string): Promise<InvitationResponse>;
+}
+
+interface VrtxInviteContactsProps {
+    block: any;
+    /** Invite Contacts configuration with contacts list */
+    inviteContactsConfig?: InviteContactsConfig;
+    /** Function to create SMS invitation and get short link */
+    createSmsInvitation?: (phoneNumber: string, contactName?: string) => Promise<string | null>;
+    /** Trigger haptic feedback */
+    triggerHaptic?: (style: 'light' | 'medium' | 'heavy') => Promise<void>;
+    /** Theme colors from widget configuration */
+    theme?: {
+        primaryBackground?: string;
+        primaryForeground?: string;
+        secondaryBackground?: string;
+        secondaryForeground?: string;
+        foreground?: string;
+        border?: string;
+    };
+    /** SMS message template with {{link}} placeholder */
+    smsMessageTemplate?: string;
+}
+declare function VrtxInviteContacts({ block, inviteContactsConfig, createSmsInvitation, triggerHaptic, theme, smsMessageTemplate, }: VrtxInviteContactsProps): react__default.JSX.Element | null;
+
+interface VrtxSearchBoxProps {
+    block: any;
+    /** Search Box configuration with callbacks */
+    searchBoxConfig?: SearchBoxConfig;
+    /** Function to create an invitation with internal ID target type */
+    createUserIdInvitation?: (userId: string, name?: string, avatarUrl?: string, metadata?: Record<string, unknown>) => Promise<void>;
+    /** Trigger haptic feedback */
+    triggerHaptic?: (style: 'light' | 'medium' | 'heavy') => Promise<void>;
+    /** Callback to emit analytics events */
+    onAnalyticsEvent?: (event: SimpleAnalyticsEvent) => void;
+    /** Function to render icons (from InviteFormCore) */
+    renderIcon?: (props: IconRendererProps) => react__default.ReactNode;
+    /** Theme colors from widget configuration */
+    theme?: {
+        primaryBackground?: string;
+        primaryForeground?: string;
+        secondaryBackground?: string;
+        secondaryForeground?: string;
+        foreground?: string;
+        border?: string;
+    };
+}
+declare function VrtxSearchBox({ block, searchBoxConfig, createUserIdInvitation, triggerHaptic, onAnalyticsEvent, renderIcon, theme, }: VrtxSearchBoxProps): react__default.JSX.Element;
+
+export { type Attributes, DEFAULT_ANALYTICS_URL, type DeviceFingerprint, FindFriendsConfig, type GroupDTO, IconRendererProps, IncomingInvitationsConfig, InviteFormMobile as InvitationForm, type InvitationResponse, InvitationSuggestionsConfig, InviteContactsConfig, InviteFormMobile, type MatchFingerprintResponse, OutgoingInvitationsConfig, type RetrieveDeferredDeepLinkOptions, SearchBoxConfig, type SimpleAnalyticsEvent, type UnfurlConfig, type UsePrefetchWidgetConfigurationOptions, type VortexActionResult, type VortexActionType, type VortexAnalyticsEvent, VortexClient, type VortexClientOptions, VortexDeferredLinks, VortexInvite, type VortexInviteProps, type VortexModules, VrtxInviteContacts, type VrtxInviteContactsProps, VrtxSearchBox, type VrtxSearchBoxProps, configCache, unfurlConfigToMetadata, usePrefetchWidgetConfiguration };