@onairos/react-native 3.0.72 → 3.0.74

package/src/types/index.d.ts

@@ -53,6 +53,57 @@ declare module '@onairos/react-native' {
     testMode?: boolean;
   }
 
+  export interface OnairosProps {
+    /** Return link after authentication (used for web-based flows) */
+    returnLink?: string;
+    /** Prefill URL for the authentication process */
+    prefillUrl?: string;
+    /** Application name to display in dialogs */
+    AppName: string;
+    /** Button type - 'normal' or 'pill' */
+    buttonType?: 'normal' | 'pill';
+    /** Data requests for user consent */
+    requestData?: {
+      [key: string]: DataTier;
+    };
+    /** Button width in pixels */
+    buttonWidth?: number;
+    /** Button height in pixels */
+    buttonHeight?: number;
+    /** Whether to show stroke/border around button */
+    hasStroke?: boolean;
+    /** Whether the button is enabled */
+    enabled?: boolean;
+    /** Button form/shape style */
+    buttonForm?: 'default' | 'connect';
+    /** Callback when user rejects or cancels */
+    onRejection?: (error?: string) => void;
+    /** Callback when authentication is resolved */
+    onResolved?: (apiUrl: string, token: string, userData: any) => void;
+    /** Function to check before starting authentication */
+    preCheck?: () => Promise<boolean>;
+    /** Button background color */
+    color?: string;
+    /** Enable debug mode */
+    debug?: boolean;
+    /** Enable dark mode */
+    darkMode?: boolean;
+    /** Preferred platform for authentication */
+    preferredPlatform?: string;
+    /** Enable test mode */
+    testMode?: boolean;
+    /** API Key Configuration (REQUIRED) */
+    apiKey: string;
+    /** Environment setting for API calls */
+    environment?: 'production' | 'staging' | 'development';
+    /** Enable logging for debugging */
+    enableLogging?: boolean;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Number of retry attempts for failed requests */
+    retryAttempts?: number;
+  }
+
   export interface UniversalOnboardingProps {
     visible: boolean;
     onClose: () => void;
@@ -129,12 +180,71 @@ declare module '@onairos/react-native' {
     error?: string;
   }
 
+  // Authentication & PIN Management Types
+  export interface EmailVerificationResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+    existingUser?: boolean;
+    jwtToken?: string;
+    requestId?: string;
+  }
+
+  export interface PinStorageResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+  }
+
+  export interface EmailVerificationStatusResult {
+    success: boolean;
+    isPending?: boolean;
+    message?: string;
+    error?: string;
+  }
+
+  // Component Classes
   export class OnairosButton extends Component<OnairosButtonProps> {}
+  export class Onairos extends Component<OnairosProps> {}
   export class UniversalOnboarding extends Component<UniversalOnboardingProps> {}
   export class PlatformList extends Component<PlatformListProps> {}
   export class PinInput extends Component<PinInputProps> {}
   export class TrainingModal extends Component<TrainingModalProps> {}
   export class OAuthWebView extends Component<OAuthWebViewProps> {}
+
+  // Authentication & PIN Management Functions
+  export function storePinAfterBiometric(
+    username: string,
+    pin: string,
+    jwtToken?: string
+  ): Promise<PinStorageResult>;
+
+  export function getStoredJwtToken(): Promise<string | null>;
+
+  export function clearStoredTokens(): Promise<void>;
+
+  export function requestEmailVerification(
+    email: string,
+    testMode?: boolean
+  ): Promise<EmailVerificationResult>;
+
+  export function verifyEmailCode(
+    email: string,
+    code: string,
+    testMode?: boolean
+  ): Promise<EmailVerificationResult>;
+
+  export function checkEmailVerificationStatus(
+    email: string,
+    testMode?: boolean
+  ): Promise<EmailVerificationStatusResult>;
+
+  // SDK Initialization Functions
+  export function initializeApiKey(config: any): Promise<void>;
+  export const ADMIN_API_KEY: string;
+
+  // Programmatic Flow
+  export function executeOnairosFlow(config: any): Promise<any>;
 }
 
 // Fix for Node.js type conflicts

package/src/types/index.ts

@@ -1,3 +1,6 @@
+import { ViewStyle, TextStyle } from 'react-native';
+import { Component } from 'react';
+
 export interface DataTier {
   type: string;
   descriptions: string;
@@ -5,72 +8,137 @@ export interface DataTier {
 }
 
 export interface OnairosButtonProps {
-  AppName: string;
-  requestData: {
-    [key: string]: {
-      type: string;
-      descriptions: string;
-      reward: string;
-    };
-  };
+  /** Return link after authentication (used for web-based flows) */
   returnLink?: string;
+  /** Prefill URL for the authentication process */
   prefillUrl?: string;
+  /** Application name to display in dialogs */
+  AppName?: string;
+  /** Button type - 'normal' or 'pill' */
   buttonType?: 'normal' | 'pill';
+  /** Data requests for user consent */
+  requestData?: {
+    [key: string]: DataTier;
+  };
+  /** Button width in pixels or percentage */
   buttonWidth?: number | string;
+  /** Button height in pixels */
   buttonHeight?: number;
+  /** Whether to show stroke/border around button */
   hasStroke?: boolean;
+  /** Whether the button is enabled */
   enabled?: boolean;
-  buttonForm?: 'default' | 'login' | 'signup' | 'connect';
-  auto?: boolean; // If true, makes API call automatically and returns result
-  onRejection?: (error?: string) => void;
-  onResolved?: (apiUrl: string, token: string, userData: any) => void; // Required when auto is false
+  /** Button form/shape style */
+  buttonForm?: 'default' | 'rounded' | 'square' | 'connect';
+  /** Callback when user rejects or cancels */
+  onRejection?: (reason?: string) => void;
+  /** Callback when authentication is resolved */
+  onResolved?: (apiUrl: string, accessToken: string, data: any) => void;
+  /** Function to check before starting authentication */
   preCheck?: () => Promise<boolean>;
+  /** Button background color */
   color?: string;
+  /** Whether to apply a slight rotation effect */
   swerv?: boolean;
+  /** Enable debug mode */
   debug?: boolean;
+  /** Preferred platform for authentication */
   preferredPlatform?: string;
+  /** Enable test mode */
   testMode?: boolean;
+  /** Enable dark mode */
   darkMode?: boolean;
-}
-
-export interface TestModeOptions {
-  // Simple 2-flow system
-  existingUser?: boolean; // Flow 1: Email → Code → Data Request → Close (return API URL)
+  /** Enable automatic API calls */
+  auto?: boolean;
+  /** App icon to display */
+  appIcon?: any;
+  /** Flow 2: New User (Email → Code → Platform Connect → PIN → Training → Complete) */
   newUser?: boolean; // Flow 2: Email → Code → Platform Connect → PIN → Training → Complete
-  
-  // Optional tweaks
+  /** Flow 3: Existing User (Email → Code → Data Request → Complete) */
+  existingUser?: boolean; // Flow 3: Existing User (Email → Code → Data Request → Complete)
   fastTraining?: boolean; // Speed up training simulation
-  skipRealConnections?: boolean; // Allow mock platform connections
+}
+
+export interface OnairosProps {
+  /** Return link after authentication (used for web-based flows) */
+  returnLink?: string;
+  /** Prefill URL for the authentication process */
+  prefillUrl?: string;
+  /** Application name to display in dialogs */
+  AppName: string;
+  /** Button type - 'normal' or 'pill' */
+  buttonType?: 'normal' | 'pill';
+  /** Data requests for user consent */
+  requestData?: {
+    [key: string]: DataTier;
+  };
+  /** Button width in pixels */
+  buttonWidth?: number;
+  /** Button height in pixels */
+  buttonHeight?: number;
+  /** Whether to show stroke/border around button */
+  hasStroke?: boolean;
+  /** Whether the button is enabled */
+  enabled?: boolean;
+  /** Button form/shape style */
+  buttonForm?: 'default' | 'connect';
+  /** Callback when user rejects or cancels */
+  onRejection?: (error?: string) => void;
+  /** Callback when authentication is resolved */
+  onResolved?: (apiUrl: string, token: string, userData: any) => void;
+  /** Function to check before starting authentication */
+  preCheck?: () => Promise<boolean>;
+  /** Button background color */
+  color?: string;
+  /** Enable debug mode */
+  debug?: boolean;
+  /** Enable dark mode */
+  darkMode?: boolean;
+  /** Preferred platform for authentication */
+  preferredPlatform?: string;
+  /** Enable test mode */
+  testMode?: boolean;
+  /** API Key Configuration (REQUIRED) */
+  apiKey: string;
+  /** Environment setting for API calls */
+  environment?: 'production' | 'staging' | 'development';
+  /** Enable logging for debugging */
+  enableLogging?: boolean;
+  /** Request timeout in milliseconds */
+  timeout?: number;
+  /** Number of retry attempts for failed requests */
+  retryAttempts?: number;
 }
 
 export interface UniversalOnboardingProps {
   visible: boolean;
   onClose: () => void;
   AppName: string;
+  appIcon?: any;
   requestData?: {
-    [key: string]: {
-      type: string;
-      descriptions: string;
-      reward: string;
-    };
+    [key: string]: DataTier;
   };
   returnLink?: string;
   onComplete: (apiUrl: string, token: string, userData: any) => void;
   preferredPlatform?: string;
   debug?: boolean;
-  test?: boolean | TestModeOptions; // Enhanced test mode with options
+  testMode?: boolean;
   embedd?: boolean;
-}
-
-export interface ConnectionStatus {
-  [key: string]: {
-    userName: string;
-    connected: boolean;
-  };
+  /** Flow 2: New User (Email → Code → Platform Connect → PIN → Training → Complete) */
+  newUser?: boolean; // Flow 2: Email → Code → Platform Connect → PIN → Training → Complete
+  /** Flow 3: Existing User (Email → Code → Data Request → Complete) */
+  existingUser?: boolean; // Flow 3: Existing User (Email → Code → Data Request → Complete)
+  fastTraining?: boolean; // Speed up training simulation
+  /** Inference data for auto mode */
+  inferenceData?: any;
+  /** Auto mode for direct API calls */
+  auto?: boolean;
+  /** Partner integration */
+  partner?: string;
 }
 
 export interface PlatformListProps {
-  connections: ConnectionStatus;
+  connections: { [key: string]: boolean };
   onToggle: (platform: string, connect: boolean) => Promise<void>;
   isLoading: boolean;
   canProceed: boolean;
@@ -82,7 +150,7 @@ export interface PinInputProps {
   minLength?: number;
   requireSpecialChar?: boolean;
   requireNumber?: boolean;
-  onBack?: () => void;
+  initialPin?: string;
 }
 
 export interface TrainingModalProps {
@@ -103,6 +171,27 @@ export interface OAuthWebViewProps {
   onClose: () => void;
 }
 
+export interface CredentialsResult {
+  isValid: boolean;
+  credentials?: {
+    username?: string;
+    userPin?: string;
+    accessToken?: string;
+    pinterest?: { token: string; username: string };
+  };
+}
+
+export interface OverlayProps {
+  visible: boolean;
+  onClose: () => void;
+  credentials: any;
+  onDeleteCredentials: () => void;
+}
+
+export interface ConnectionStatus {
+  [key: string]: boolean;
+}
+
 export interface PlatformConfig {
   name: string;
   icon: string;
@@ -110,40 +199,21 @@ export interface PlatformConfig {
   description?: string;
 }
 
-export interface OnairosCredentials {
-  username: string;
-  accessToken?: string;
-  refreshToken?: string;
-  userPin?: string;
-  platforms?: {
-    instagram?: { token: string; username: string };
-    youtube?: { token: string; username: string };
-    pinterest?: { token: string; username: string };
-    reddit?: { token: string; username: string };
-  };
-  createdAt: number;
-}
-
-export interface OverlayProps {
-  data: {
-    [key: string]: {
-      type: string;
-      descriptions: string;
-      reward: string;
-    };
-  };
-  username: string;
-  modelKey: string;
-  onResolved: (apiUrl: string, accessToken: string, loginDetails: any) => void;
-  appName?: string;
-  darkMode?: boolean;
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
 }
 
-export interface BiometricOptions {
-  title: string;
-  subtitle?: string;
-  description?: string;
-  cancelText?: string;
+export interface PlatformAuthConfig {
+  hasNativeSDK: boolean;
+  nativeSDKPackage?: string;
+  authEndpoint: string;
+  color: string;
+  clientId?: string;
+  redirectUri?: string;
+  scope?: string;
+  responseType?: string;
 }
 
 export interface PinRequirements {
@@ -152,13 +222,17 @@ export interface PinRequirements {
   requireNumber: boolean;
 }
 
-export interface ApiResponse<T> {
-  success: boolean;
-  data?: T;
-  error?: string;
+export interface OnairosConfig {
+  apiKey: string;
+  environment?: 'production' | 'staging' | 'development';
+  enableLogging?: boolean;
+  timeout?: number;
+  retryAttempts?: number;
 }
 
-export interface CredentialsResult {
-  isValid: boolean;
-  credentials?: any;
+export interface TestModeOptions {
+  skipEmailVerification?: boolean;
+  mockApiResponses?: boolean;
+  simulateTraining?: boolean;
+  enableDebugLogs?: boolean;
 } 

package/src/types.ts

@@ -26,6 +26,13 @@ export interface ApiKeyConfig {
   enableLogging?: boolean;
 }
 
+// API key types
+export enum ApiKeyType {
+  DEVELOPER = 'developer',
+  ADMIN = 'admin',
+  INVALID = 'invalid'
+}
+
 export interface ApiKeyValidationResult {
   isValid: boolean;
   error?: string;
@@ -34,6 +41,7 @@ export interface ApiKeyValidationResult {
     remaining: number;
     resetTime: number;
   };
+  keyType?: ApiKeyType;
 }
 
 export interface OnairosConfig {
@@ -44,6 +52,57 @@ export interface OnairosConfig {
   retryAttempts?: number;
 }
 
+export interface OnairosProps {
+  /** Return link after authentication (used for web-based flows) */
+  returnLink?: string;
+  /** Prefill URL for the authentication process */
+  prefillUrl?: string;
+  /** Application name to display in dialogs */
+  AppName: string;
+  /** Button type - 'normal' or 'pill' */
+  buttonType?: 'normal' | 'pill';
+  /** Data requests for user consent */
+  requestData?: {
+    [key: string]: DataTier;
+  };
+  /** Button width in pixels */
+  buttonWidth?: number;
+  /** Button height in pixels */
+  buttonHeight?: number;
+  /** Whether to show stroke/border around button */
+  hasStroke?: boolean;
+  /** Whether the button is enabled */
+  enabled?: boolean;
+  /** Button form/shape style */
+  buttonForm?: 'default' | 'connect';
+  /** Callback when user rejects or cancels */
+  onRejection?: (error?: string) => void;
+  /** Callback when authentication is resolved */
+  onResolved?: (apiUrl: string, token: string, userData: any) => void;
+  /** Function to check before starting authentication */
+  preCheck?: () => Promise<boolean>;
+  /** Button background color */
+  color?: string;
+  /** Enable debug mode */
+  debug?: boolean;
+  /** Enable dark mode */
+  darkMode?: boolean;
+  /** Preferred platform for authentication */
+  preferredPlatform?: string;
+  /** Enable test mode */
+  testMode?: boolean;
+  /** API Key Configuration (REQUIRED) */
+  apiKey: string;
+  /** Environment setting for API calls */
+  environment?: 'production' | 'staging' | 'development';
+  /** Enable logging for debugging */
+  enableLogging?: boolean;
+  /** Request timeout in milliseconds */
+  timeout?: number;
+  /** Number of retry attempts for failed requests */
+  retryAttempts?: number;
+}
+
 export interface UniversalOnboardingProps {
   visible: boolean;
   onClose: (result?: any) => void;

package/src/utils/programmaticFlow.ts

@@ -0,0 +1,113 @@
+/**
+ * Programmatic Onairos Flow
+ * 
+ * This function executes the complete Onairos authentication and onboarding flow
+ * that can be attached to custom buttons or called programmatically.
+ */
+
+import { OnairosButtonProps } from '../types';
+import { initializePlatformAuthService } from '../services/platformAuthService';
+
+/**
+ * Execute the complete Onairos flow programmatically
+ * This is the same logic that the OnairosButton uses internally
+ * 
+ * @param options Configuration options for the flow
+ * @returns Promise that resolves when flow is complete
+ */
+export const executeOnairosFlow = async (options: OnairosButtonProps): Promise<void> => {
+  try {
+    console.log('🚀 Starting Onairos flow programmatically...');
+    
+    // Initialize API key service if not already initialized
+    await initializePlatformAuthService();
+    
+    // Import components dynamically to avoid circular dependencies
+    const { UniversalOnboarding } = await import('../components/UniversalOnboarding');
+    const React = await import('react');
+    
+    // Create a promise that resolves when the flow is complete
+    return new Promise((resolve, reject) => {
+      let modalRef: any = null;
+      
+      const handleComplete = (apiUrl: string, token: string, userData: any) => {
+        console.log('✅ Onairos flow completed successfully');
+        
+        // Clean up modal
+        if (modalRef && modalRef.close) {
+          modalRef.close();
+        }
+        
+        // Call user's onResolved callback
+        if (options.onResolved) {
+          options.onResolved(apiUrl, token, userData);
+        }
+        
+        resolve();
+      };
+      
+      const handleRejection = (error?: string) => {
+        console.log('❌ Onairos flow rejected:', error);
+        
+        // Clean up modal
+        if (modalRef && modalRef.close) {
+          modalRef.close();
+        }
+        
+        // Call user's onRejection callback
+        if (options.onRejection) {
+          options.onRejection(error);
+        }
+        
+        reject(new Error(error || 'Onairos flow was rejected'));
+      };
+      
+      // Create and show the Universal Onboarding modal
+      const modalElement = React.createElement(UniversalOnboarding, {
+        visible: true,
+        onClose: () => handleRejection('User closed the modal'),
+        AppName: options.AppName,
+        requestData: options.requestData,
+        returnLink: options.returnLink,
+        onComplete: handleComplete,
+        preferredPlatform: options.preferredPlatform,
+        debug: options.debug,
+        testMode: options.testMode,
+      });
+      
+      // Store modal reference for cleanup
+      modalRef = modalElement;
+      
+      // Note: In a real implementation, you'd need to render this modal
+      // This is a simplified version - the actual implementation would
+      // need to handle React rendering in the current app context
+      console.log('📱 Onairos modal should be displayed');
+    });
+  } catch (error) {
+    console.error('❌ Failed to execute Onairos flow:', error);
+    throw error;
+  }
+};
+
+/**
+ * Simple wrapper function that matches the OnairosButton click behavior
+ * 
+ * @param options Configuration options for the flow
+ * @returns Promise that resolves when flow is complete
+ */
+export const startOnairosFlow = async (options: OnairosButtonProps): Promise<void> => {
+  // Pre-check if provided
+  if (options.preCheck) {
+    const canProceed = await options.preCheck();
+    if (!canProceed) {
+      console.log('❌ Pre-check failed, not starting Onairos flow');
+      if (options.onRejection) {
+        options.onRejection('Pre-check failed');
+      }
+      return;
+    }
+  }
+  
+  // Execute the flow
+  return executeOnairosFlow(options);
+};