### Standard Link Session Example

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MANIFEST.txt

Demonstrates the standard account linking flow using Plaid Link. Refer to README.md for Quick Start, API-REFERENCE.md for createPlaidLinkSession(), CONFIGURATION.md for LinkTokenConfiguration, and USAGE-EXAMPLES.md for error handling.

```javascript
import React from 'react';
import { PlaidLink } from 'react-native-plaid-link-sdk';

const App = () => {
  const [linkSuccess, setLinkSuccess] = React.useState(false);

  return (
    <PlaidLink
      token={/* Your public_token */}
      onSuccess={async (public_token, metadata) => {
        // Send public_token to your backend to exchange for access_token
        console.log('Success:', public_token, metadata);
        setLinkSuccess(true);
      }}
      onExit={(exit_code, metadata) => {
        console.log('Exit:', exit_code, metadata);
      }}
    />
  );
};

export default App;
```

--------------------------------

### Install React Native Plaid Link SDK (Bare React Native)

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/README.md

Install the SDK and necessary dependencies for bare React Native projects. Includes iOS pod installation.

```bash
npm install react-native-plaid-link-sdk
npx pod-install  # iOS only
```

--------------------------------

### Sync FinanceKit with Full Configuration

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Example of calling `syncFinanceKit` with all available configuration options: token, requestAuthorizationIfNeeded, and syncBehavior.

```typescript
await syncFinanceKit({
  token: linkToken,
  requestAuthorizationIfNeeded: true,
  syncBehavior: FinanceKitSyncBehavior.LIVE,
});
```

--------------------------------

### Install React Native Plaid Link SDK and Expo

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/V13_MIGRATION_GUIDE.md

Install the SDK and Expo for bare React Native apps. Ensure Expo Modules are installed and configured first.

```sh
npm install react-native-plaid-link-sdk expo
npx pod-install
```

--------------------------------

### Plaid Headless Session Start Method

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MODULES.md

Represents a Plaid Headless session and its method to start the session.

```typescript
PlaidHeadlessSession
└── start: () => Promise<void>
```

--------------------------------

### Install Plaid React Native SDK for Bare React Native Projects

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/README.md

Install the SDK and its dependencies for Bare React Native projects. This includes installing the 'expo' package and running pod install.

```sh
npm install react-native-plaid-link-sdk
npx pod-install
```

--------------------------------

### Sync FinanceKit in Simulated Mode

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Example of calling `syncFinanceKit` for sandbox testing using `FinanceKitSyncBehavior.SIMULATED`.

```typescript
import { syncFinanceKit, FinanceKitSyncBehavior } from 'react-native-plaid-link-sdk';

await syncFinanceKit({
  token: linkToken,
  syncBehavior: FinanceKitSyncBehavior.SIMULATED,
});
```

--------------------------------

### Sync FinanceKit with Default Configuration

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Example of calling `syncFinanceKit` with only the required `token`. Uses default settings for authorization and sync behavior.

```typescript
import { syncFinanceKit } from 'react-native-plaid-link-sdk';

await syncFinanceKit({
  token: linkToken,
});
```

--------------------------------

### Install Plaid React Native SDK for Expo Projects

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/README.md

Use this command to install the SDK in your Expo project. Ensure you are running the app in a development build or custom native runtime, as Expo Go does not support custom native modules.

```sh
npm install react-native-plaid-link-sdk
```

--------------------------------

### Example Plaid Layer Session Creation and Usage

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Demonstrates creating a Plaid Layer session, handling success and exit callbacks, and responding to Layer events to open the session. It also shows how to submit user information after the session is ready.

```typescript
let session: PlaidLayerSession;

session = await createPlaidLayerSession({
  token: linkToken,
  onSuccess: (success) => {
    console.log('Layer verification complete');
    exchangePublicToken(success.publicToken);
  },
  onExit: (exit) => {
    console.log('User exited Layer');
  },
  onEvent: (event) => {
    if (event.eventName === LinkEventName.LAYER_READY) {
      // Layer is ready, can now call session.open()
      session.open();
    } else if (event.eventName === LinkEventName.LAYER_NOT_AVAILABLE) {
      // Layer not available for this institution
      console.error('Layer not available');
    }
  },
});

// Submit user information
await session.submit({
  phoneNumber: '+14155550015',
  dateOfBirth: '1985-03-15',
});
```

--------------------------------

### Server-Side Integration

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MANIFEST.txt

Guides on public token exchange flow for server-side integration.

```APIDOC
## Server-Side Integration (Public Token Exchange)

### Description
Details the public token exchange flow for server-side integration.

### Method
(Not specified, refers to server-side API calls)

### Endpoint
(Not applicable for client-side SDK documentation)

### Parameters
(Not specified for client-side SDK)

### Request Example
(See USAGE-EXAMPLES.md for Server-Side Integration)

### Response
(Not specified for client-side SDK)

### Response Example
(Not specified)
```

--------------------------------

### Sync FinanceKit with Error Handling

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Example demonstrating how to handle potential errors when calling `syncFinanceKit`, including a platform check for iOS.

```typescript
import { Platform } from 'react-native';

if (Platform.OS !== 'ios') {
  console.error('FinanceKit is iOS only');
  return;
}

try {
  await syncFinanceKit({
    token: linkToken,
    requestAuthorizationIfNeeded: true,
  });
  console.log('FinanceKit sync successful');
} catch (error) {
  console.error('FinanceKit sync failed:', error.message);
  // Handle error appropriately
}
```

--------------------------------

### Headless Session Example

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MANIFEST.txt

Facilitates a programmatic payment flow using a Headless Session. This approach offers more control over the user interface.

```javascript
import React from 'react';
import { PlaidLink } from 'react-native-plaid-link-sdk';

const App = () => {
  const [linkSuccess, setLinkSuccess] = React.useState(false);

  return (
    <PlaidLink
      token={/* Your Headless token */}
      onSuccess={async (public_token, metadata) => {
        console.log('Headless Success:', public_token, metadata);
        setLinkSuccess(true);
      }}
      onExit={(exit_code, metadata) => {
        console.log('Headless Exit:', exit_code, metadata);
      }}
    />
  );
};

export default App;
```

--------------------------------

### Create Plaid Layer Session with User Data (TypeScript)

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/USAGE-EXAMPLES.md

This example demonstrates how to create a Plaid Layer session and submit user data for wealth verification. It includes handling link tokens, phone numbers, and dates of birth. Use this when initiating a wealth verification flow.

```typescript
import {
  useState,
  useRef,
} from 'react';
import {
  View,
  Button,
  Text,
  TextInput,
  SafeAreaView,
} from 'react-native';
import {
  createPlaidLayerSession,
  PlaidLayerSession,
  LinkEventName,
} from 'react-native-plaid-link-sdk';

export function LayerSessionExample() {
  const [token, setToken] = useState('');
  const [phoneNumber, setPhoneNumber] = useState('+1415555001');
  const [dateOfBirth, setDateOfBirth] = useState('1985-03-15');
  const [status, setStatus] = useState('idle');
  const sessionRef = useRef<PlaidLayerSession | null>(null);

  const createSession = async () => {
    setStatus('creating');

    try {
      sessionRef.current = await createPlaidLayerSession({
        token: token.trim(),
        onSuccess: (success) => {
          console.log('✓ Layer verification complete');
          console.log('Public Token:', success.publicToken);
          exchangePublicToken(success.publicToken);
        },
        onExit: (exit) => {
          console.log('User exited Layer');
        },
        onEvent: (event) => {
          if (event.eventName === LinkEventName.LAYER_READY) {
            setStatus('ready');
            console.log('Layer is ready to open');
          } else if (event.eventName === LinkEventName.LAYER_NOT_AVAILABLE) {
            setStatus('error');
            console.error('Layer not available for this institution');
          }
        },
      });
    } catch (err) {
      console.error('Failed to create Layer session:', err);
      setStatus('error');
    }
  };

  const submitUserData = async () => {
    if (!sessionRef.current) return;

    try {
      await sessionRef.current.submit({
        phoneNumber: phoneNumber.trim() || undefined,
        dateOfBirth: dateOfBirth.trim() || undefined,
      });
      console.log('✓ User data submitted');
    } catch (err) {
      console.error('Failed to submit data:', err);
    }
  };

  const openLayer = async () => {
    try {
      await sessionRef.current?.open();
      console.log('Layer opened');
    } catch (err) {
      console.error('Failed to open Layer:', err);
    }
  };

  return (
    <SafeAreaView style={{ flex: 1, padding: 16 }}>
      <Text style={{ fontSize: 18, fontWeight: 'bold', marginBottom: 16 }}>
        Plaid Layer Verification
      </Text>

      <View style={{ marginBottom: 16 }}>
        <Text style={{ marginBottom: 8 }}>Link Token:</Text>
        <TextInput
          value={token}
          onChangeText={setToken}
          placeholder="Enter link token"
          style={{
            borderWidth: 1,
            borderColor: '#ccc',
            padding: 8,
            borderRadius: 4,
            marginBottom: 16,
          }}
        />

        <Text style={{ marginBottom: 8 }}>Phone Number (E.164):</Text>
        <TextInput
          value={phoneNumber}
          onChangeText={setPhoneNumber}
          placeholder="+1415555001"
          keyboardType="phone-pad"
          style={{
            borderWidth: 1,
            borderColor: '#ccc',
            padding: 8,
            borderRadius: 4,
            marginBottom: 16,
          }}
        />

        <Text style={{ marginBottom: 8 }}>Date of Birth (YYYY-MM-DD):</Text>
        <TextInput
          value={dateOfBirth}
          onChangeText={setDateOfBirth}
          placeholder="1985-03-15"
          style={{
            borderWidth: 1,
            borderColor: '#ccc',
            padding: 8,
            borderRadius: 4,
            marginBottom: 16,
          }}
        />
      </View>

      <Button
        title="Create Layer Session"
        onPress={createSession}
        disabled={status !== 'idle'}
      />

      {status === 'creating' && (
        <Text style={{ marginTop: 16, color: '#666' }}>Creating session...</Text>
      )}

      {status === 'ready' && (
        <>
          <Button
            title="Submit User Data"
            onPress={submitUserData}
            color="#007AFF"
          />
          <Button title="Open Layer" onPress={openLayer} color="#34C759" />
        </>
      )}
    </SafeAreaView>
  );
}
```

--------------------------------

### Layer Session Example

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MANIFEST.txt

Enables wealth verification using user data through a Layer Session. This flow is detailed in the API Reference and Configuration guides.

```javascript
import React from 'react';
import { PlaidLink } from 'react-native-plaid-link-sdk';

const App = () => {
  const [linkSuccess, setLinkSuccess] = React.useState(false);

  return (
    <PlaidLink
      token={/* Your Layer token */}
      onSuccess={async (public_token, metadata) => {
        console.log('Layer Success:', public_token, metadata);
        setLinkSuccess(true);
      }}
      onExit={(exit_code, metadata) => {
        console.log('Layer Exit:', exit_code, metadata);
      }}
    />
  );
};

export default App;
```

--------------------------------

### Error Handling Example

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MANIFEST.txt

Demonstrates complete error handling patterns for Plaid Link sessions. Refer to ERRORS.md for a comprehensive list of error codes and solutions.

```javascript
import React from 'react';
import { PlaidLink } from 'react-native-plaid-link-sdk';

const App = () => {
  const [linkSuccess, setLinkSuccess] = React.useState(false);

  return (
    <PlaidLink
      token={/* Your error handling token */}
      onSuccess={async (public_token, metadata) => {
        console.log('Error Handling Success:', public_token, metadata);
        setLinkSuccess(true);
      }}
      onExit={(exit_code, metadata) => {
        console.error('Error Handling Exit:', exit_code, metadata);
        // Implement resolution strategies based on exit_code
      }}
    />
  );
};

export default App;
```

--------------------------------

### Create Plaid Headless Session

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MODULES.md

Use this function for headless payment flows. It returns a PlaidHeadlessSession object with a start() method.

```typescript
createPlaidHeadlessSession(config: LinkTokenConfiguration) => Promise<PlaidHeadlessSession>
```

--------------------------------

### Event Tracking Example

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MANIFEST.txt

Implements analytics and progress tracking for Plaid Link sessions. This involves handling various event types documented in the API.

```javascript
import React from 'react';
import { PlaidLink } from 'react-native-plaid-link-sdk';

const App = () => {
  const [linkSuccess, setLinkSuccess] = React.useState(false);

  return (
    <PlaidLink
      token={/* Your event tracking token */}
      onSuccess={async (public_token, metadata) => {
        console.log('Event Tracking Success:', public_token, metadata);
        setLinkSuccess(true);
      }}
      onEvent={(eventName, metadata) => {
        console.log('Event:', eventName, metadata);
        // Track events for analytics
      }}
      onExit={(exit_code, metadata) => {
        console.log('Event Tracking Exit:', exit_code, metadata);
      }}
    />
  );
};

export default App;
```

--------------------------------

### Submit with Custom Parameters

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Example of submitting phone number, date of birth, and custom key-value parameters for extended Layer verification.

```typescript
await session.submit({
  phoneNumber: '+14155550015',
  dateOfBirth: '1985-03-15',
  params: {
    customField1: 'value1',
    customField2: 'value2',
  },
});
```

--------------------------------

### createPlaidHeadlessSession

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/API-REFERENCE.md

Creates a Plaid Link session for headless payment flows, allowing for external UI handling. It returns a session object with a `start()` method to initiate the payment process.

```APIDOC
## createPlaidHeadlessSession

### Description
Create a Plaid Link session for headless payment flows where the UI is handled externally.

### Signature
```typescript
export async function createPlaidHeadlessSession(config: LinkTokenConfiguration): Promise<PlaidHeadlessSession>
```

### Parameters
#### config
- **config** (LinkTokenConfiguration) - Required - Configuration object for the headless session. Properties are the same as `LinkTokenConfiguration` for standard Link.

### Return Type
`Promise<PlaidHeadlessSession>`

Returns a promise that resolves to a session object with a `start()` method.

```typescript
interface PlaidHeadlessSession {
  start: () => Promise<void>;
}
```

### Throws
- Error if session creation fails

### Usage Example
```typescript
import { createPlaidHeadlessSession } from 'react-native-plaid-link-sdk';

const session = await createPlaidHeadlessSession({
  token: 'link-sandbox-...', // Must be a payment token
  onSuccess: (success) => {
    console.log('Payment initiated:', success.publicToken);
  },
  onExit: (exit) => {
    console.log('Payment cancelled');
  },
  onEvent: (event) => {
    console.log('Event:', event.eventName);
  },
  onLoad: () => {
    console.log('Headless flow ready');
  },
});

await session.start();
```
```

--------------------------------

### Server-Side Integration Example

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MANIFEST.txt

Illustrates the public token exchange flow, which is typically handled on the server-side. This involves exchanging a public_token for an access_token.

```javascript
import React from 'react';
import { PlaidLink } from 'react-native-plaid-link-sdk';

const App = () => {
  const [linkSuccess, setLinkSuccess] = React.useState(false);

  return (
    <PlaidLink
      token={/* Your server-side integration token */}
      onSuccess={async (public_token, metadata) => {
        console.log('Server-Side Integration Success:', public_token, metadata);
        // Send public_token to your backend
        await fetch('/api/set_access_token', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({ public_token }),
        });
        setLinkSuccess(true);
      }}
      onExit={(exit_code, metadata) => {
        console.log('Server-Side Integration Exit:', exit_code, metadata);
      }}
    />
  );
};

export default App;
```

--------------------------------

### FinanceKit Sync Example

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MANIFEST.txt

Enables synchronization with iOS Apple Card and Cash App data using FinanceKit. This feature is iOS-specific and requires iOS 17.4+.

```javascript
import React from 'react';
import { PlaidLink } from 'react-native-plaid-link-sdk';

const App = () => {
  const [linkSuccess, setLinkSuccess] = React.useState(false);

  return (
    <PlaidLink
      token={/* Your FinanceKit sync token */}
      onSuccess={async (public_token, metadata) => {
        console.log('FinanceKit Sync Success:', public_token, metadata);
        setLinkSuccess(true);
      }}
      onExit={(exit_code, metadata) => {
        console.log('FinanceKit Sync Exit:', exit_code, metadata);
      }}
    />
  );
};

export default App;
```

--------------------------------

### Create and Start Headless Payment Session in React Native

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/USAGE-EXAMPLES.md

Use this snippet to initiate a headless payment flow. It requires a payment link token and handles success, exit, event, and load callbacks. Ensure the provided token is specifically for a headless payment flow.

```typescript
import { useState, useRef } from 'react';
import {
  View,
  Button,
  Text,
  TextInput,
  SafeAreaView,
} from 'react-native';
import {
  createPlaidHeadlessSession,
  PlaidHeadlessSession,
  LinkEventName,
} from 'react-native-plaid-link-sdk';

export function HeadlessSessionExample() {
  const [token, setToken] = useState('');
  const [status, setStatus] = useState<'idle' | 'creating' | 'ready' | 'error'>( 
    'idle'
  );
  const [error, setError] = useState<string | null>(null);
  const sessionRef = useRef<PlaidHeadlessSession | null>(null);

  const createSession = async () => {
    setStatus('creating');
    setError(null);

    try {
      sessionRef.current = await createPlaidHeadlessSession({
        token: token.trim(),
        onSuccess: (success) => {
          console.log('✓ Payment completed successfully');
          console.log('Public Token:', success.publicToken);
          exchangePublicToken(success.publicToken);
        },
        onExit: (exit) => {
          if (exit.error) {
            console.error('Payment error:', exit.error.errorMessage);
            setError(exit.error.errorMessage);
          } else {
            console.log('Payment cancelled by user');
          }
        },
        onEvent: (event) => {
          console.log('Event:', event.eventName);

          if (event.eventName === LinkEventName.ERROR) {
            setError(event.metadata.errorMessage || 'Unknown error');
          }
        },
        onLoad: () => {
          console.log('Headless session ready');
          setStatus('ready');
        },
      });
    } catch (err) {
      setError(err instanceof Error ? err.message : 'Failed to create session');
      setStatus('error');
    }
  };

  const startPayment = async () => {
    try {
      await sessionRef.current?.start();
      console.log('Payment flow started');
    } catch (err) {
      setError(err instanceof Error ? err.message : 'Failed to start');
    }
  };

  return (
    <SafeAreaView style={{ flex: 1, padding: 16 }}>
      <Text style={{ fontSize: 18, fontWeight: 'bold', marginBottom: 16 }}>
        Headless Payment Flow
      </Text>

      <View style={{ marginBottom: 16, backgroundColor: '#fff7ed', padding: 12, borderRadius: 4 }}>
        <Text style={{ color: '#ea580c', fontSize: 14 }}>
          ⚠️ Token must be a payment token that triggers a headless flow
        </Text>
      </View>

      <View style={{ marginBottom: 16 }}>
        <Text style={{ marginBottom: 8 }}>Link Token:</Text>
        <TextInput
          value={token}
          onChangeText={setToken}
          placeholder="Enter payment link token"
          style={{
            borderWidth: 1,
            borderColor: '#ccc',
            padding: 8,
            borderRadius: 4,
          }}
        />
      </View>

      {error && (
        <Text style={{ color: 'red', marginBottom: 16 }}>Error: {error}</Text>
      )}

      {status === 'idle' && (
        <Button
          title="Create Headless Session"
          onPress={createSession}
        />
      )}

      {status === 'creating' && (
        <Text style={{ marginTop: 16, color: '#666' }}>Initializing...</Text>
      )}

      {status === 'ready' && (
        <Button title="Start Payment" onPress={startPayment} />
      )}

      {status === 'error' && (
        <Button
          title="Retry"
          onPress={createSession}
        />
      )}
    </SafeAreaView>
  );
}

```

--------------------------------

### Create Headless Plaid Session in v13

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/V13_MIGRATION_GUIDE.md

Use `createPlaidHeadlessSession` to initiate a headless Link session. This function requires a generated link token and provides callbacks for success, exit, event, and load events. The session must then be started using `session.start()`.

```typescript
import { createPlaidHeadlessSession } from "react-native-plaid-link-sdk";

const session = await createPlaidHeadlessSession({
  token: "#GENERATED_LINK_TOKEN#",
  onSuccess: (success) => {
    console.log("Success", success);
  },
  onExit: (exit) => {
    console.log("Exit", exit);
  },
  onEvent: (event) => {
    console.log("Event", event);
  },
  onLoad: () => {
    console.log("Headless session loaded");
  },
});

await session.start();
```

--------------------------------

### PlaidEmbeddedSearchView Usage Example

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/API-REFERENCE.md

Demonstrates how to integrate the PlaidEmbeddedSearchView component into a React Native application. It shows how to pass necessary props like token, onSuccess, onExit, onEvent, and onLoad callbacks.

```typescript
import { PlaidEmbeddedSearchView, LinkSuccess } from 'react-native-plaid-link-sdk';
import { View, StyleSheet } from 'react-native';

function MyComponent() {
  return (
    <View style={styles.container}>
      <PlaidEmbeddedSearchView
        token="link-sandbox-..."
        style={styles.embeddedView}
        onLoad={() => {
          console.log('Embedded view loaded');
        }}
        onSuccess={(success: LinkSuccess) => {
          console.log('Account linked via embedded view:', success.publicToken);
        }}
        onExit={(exit) => {
          console.log('User exited embedded view');
        }}
        onEvent={(event) => {
          console.log('Event:', event.eventName);
        }}
      />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
  },
  embeddedView: {
    height: 400,
  },
});
```

--------------------------------

### Full Plaid Link Session Configuration with onLoad

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Illustrates a comprehensive configuration for creating a Plaid Link session, including handling success, exit, events, and utilizing the onLoad callback to manage UI states after the Link UI is ready.

```typescript
const session = await createPlaidLinkSession({
  token: linkToken,
  onSuccess: (success) => {
    // Exchange public token for access token
    exchangePublicToken(success.publicToken);
  },
  onExit: (exit) => {
    if (exit.error) {
      handleError(exit.error);
    } else {
      handleNormalExit(exit.metadata);
    }
  },
  onEvent: (event) => {
    // Track user progress
    analytics.track('link_event', {
      eventName: event.eventName,
      viewName: event.metadata.viewName,
    });
  },
  onLoad: () => {
    // Dismiss loading spinner, enable button
    setIsReady(true);
  },
});
```

--------------------------------

### Minimal Plaid Link Session Configuration

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Demonstrates the minimum required configuration to create a Plaid Link session. Ensure you provide the link token and essential callbacks for success, exit, and events.

```typescript
const session = await createPlaidLinkSession({
  token: linkToken,
  onSuccess: (success) => {
    console.log('Linked:', success.publicToken);
  },
  onExit: (exit) => {
    console.log('Exited');
  },
  onEvent: (event) => {
    // Track events if needed
  },
});
```

--------------------------------

### Submit with Phone Number Only

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Example of submitting only the phone number for Layer verification.

```typescript
await session.submit({
  phoneNumber: '+14155550015',
});
```

--------------------------------

### Submit with Phone Number and Date of Birth

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Example of submitting both phone number and date of birth for Layer verification.

```typescript
await session.submit({
  phoneNumber: '+14155550015',
  dateOfBirth: '1985-03-15',
});
```

--------------------------------

### Accessing SDK Version

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/API-REFERENCE.md

Demonstrates how to import the SDK and access its version property. Most developers should use session-based APIs instead of direct native module access.

```typescript
import ReactNativePlaidLinkSdk from 'react-native-plaid-link-sdk';

console.log('SDK Version:', ReactNativePlaidLinkSdk.sdkVersion);
```

--------------------------------

### Verify Wealth with Layer

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/README.md

Sets up a Plaid Layer session for wealth verification. It listens for the LAYER_READY event to open the Layer interface and then submits user-provided information like phone number and date of birth.

```typescript
let layerSession;

layerSession = await createPlaidLayerSession({
  token: linkToken,
  onSuccess: (success) => {
    console.log('Verification complete:', success.publicToken);
  },
  onEvent: (event) => {
    if (event.eventName === LinkEventName.LAYER_READY) {
      // Layer is ready, can now show it to user
      layerSession.open();
    }
  },
});

// User fills in their information
await layerSession.submit({
  phoneNumber: '+1415555001',
  dateOfBirth: '1985-03-15',
});
```

--------------------------------

### Open Plaid Link Session

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

The `PlaidLinkSession.open()` method is used to initiate the Plaid Link flow. It can present Link in either fullscreen or default modal mode.

```APIDOC
## open(fullScreen?: boolean)

### Description
Initiates the Plaid Link flow. Can present Link in fullscreen or default modal mode.

### Method
`open`

### Parameters
#### Path Parameters
- **fullScreen** (boolean) - Optional - If true, present Link in fullscreen mode. If false, use default modal presentation. Defaults to false.

### Request Example
**Default Presentation (Modal):**
```typescript
const session = await createPlaidLinkSession({
  token: linkToken,
  onSuccess: handleSuccess,
  onExit: handleExit,
  onEvent: handleEvent,
});

await session.open(); // or session.open(false)
```

**Fullscreen Presentation:**
```typescript
await session.open(true);
```

### Response
#### Success Response
This method returns a Promise that resolves when the Link flow is completed or exited.

#### Response Example
```typescript
// Promise resolves with no specific value upon completion or exit.
```
```

--------------------------------

### Embedded Search View Example

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MANIFEST.txt

Integrates an in-app institution search experience using the Embedded Search View. This component is configured via PlaidEmbeddedSearchViewProps.

```javascript
import React from 'react';
import { PlaidLink } from 'react-native-plaid-link-sdk';

const App = () => {
  const [linkSuccess, setLinkSuccess] = React.useState(false);

  return (
    <PlaidLink
      token={/* Your Embedded Search token */}
      onSuccess={async (public_token, metadata) => {
        console.log('Embedded Search Success:', public_token, metadata);
        setLinkSuccess(true);
      }}
      onExit={(exit_code, metadata) => {
        console.log('Embedded Search Exit:', exit_code, metadata);
      }}
    />
  );
};

export default App;
```

--------------------------------

### Import Session Functions

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MODULES.md

Import functions for creating Plaid Link, Plaid Layer, and Plaid Headless sessions, as well as for syncing with FinanceKit.

```typescript
// Session Functions
import {
  createPlaidLinkSession,
  createPlaidLayerSession,
  createPlaidHeadlessSession,
  syncFinanceKit,
} from 'react-native-plaid-link-sdk';
```

--------------------------------

### FinanceKit Sync Behavior Options

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MODULES.md

Enumerates the synchronization behavior options for FinanceKit, including live and simulated modes.

```typescript
FinanceKitSyncBehavior
├── LIVE: 0
└── SIMULATED: 1
```

--------------------------------

### Configure FinanceKit Sync Behavior

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Choose between simulated and live sync behavior for FinanceKit based on the environment. Use SIMULATED for development and testing, and LIVE for production.

```typescript
const syncBehavior = __DEV__ 
  ? FinanceKitSyncBehavior.SIMULATED
  : FinanceKitSyncBehavior.LIVE;

await syncFinanceKit({
  token: linkToken,
  syncBehavior,
});
```

--------------------------------

### Plaid Link Session and Open Method

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MODULES.md

Represents a Plaid Link session and its method to open the link flow, optionally in full screen.

```typescript
PlaidLinkSession
└── open: (fullScreen?: boolean) => Promise<void>
```

--------------------------------

### Upgrade React Native Plaid Link SDK to v13

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/V13_MIGRATION_GUIDE.md

Upgrade only the Plaid Link SDK package to v13 for existing Expo apps or those with Expo Modules installed. Always run pod-install after.

```sh
npm install react-native-plaid-link-sdk@^13
npx pod-install
```

--------------------------------

### Create Plaid Link Session

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/API-REFERENCE.md

Use this function to initiate a standard Plaid Link session for account linking. It requires a link token and provides callbacks for success, exit, events, and load status.

```typescript
export async function createPlaidLinkSession(
  config: LinkTokenConfiguration
): Promise<PlaidLinkSession>

interface PlaidLinkSession {
  open: (fullScreen?: boolean) => Promise<void>;
}
```

```typescript
import { createPlaidLinkSession, LinkSuccess, LinkExit } from 'react-native-plaid-link-sdk';

const session = await createPlaidLinkSession({
  token: 'link-sandbox-...',
  onSuccess: (success: LinkSuccess) => {
    console.log('Public token:', success.publicToken);
    console.log('Linked accounts:', success.metadata.accounts);
  },
  onExit: (exit: LinkExit) => {
    if (exit.error) {
      console.error('Error:', exit.error.errorMessage);
    }
  },
  onEvent: (event) => {
    console.log('Event:', event.eventName);
  },
  onLoad: () => {
    console.log('Link ready to open');
  },
});

await session.open(false); // false = default presentation, true = fullscreen
```

--------------------------------

### Session Creation Functions

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/INDEX.md

These functions initiate different Plaid linking flows. They require a token and provide callbacks for success, exit, event, and optional load events.

```APIDOC
## createPlaidLinkSession

### Description
Initiates the standard account linking flow.

### Signature
```typescript
createPlaidLinkSession({
  token: string,
  onSuccess: (success: LinkSuccess) => void,
  onExit: (exit: LinkExit) => void,
  onEvent: (event: LinkEvent) => void,
  onLoad?: () => void,
}): Promise<PlaidLinkSession>
```

## createPlaidLayerSession

### Description
Initiates the wealth verification flow.

### Signature
```typescript
createPlaidLayerSession({
  token: string,
  onSuccess: (success: LinkSuccess) => void,
  onExit?: (exit: LinkExit) => void,
  onEvent?: (event: LinkEvent) => void,
}): Promise<PlaidLayerSession>
```

## createPlaidHeadlessSession

### Description
Initiates the headless payments flow.

### Signature
```typescript
createPlaidHeadlessSession({
  token: string,
  onSuccess: (success: LinkSuccess) => void,
  onExit: (exit: LinkExit) => void,
  onEvent: (event: LinkEvent) => void,
  onLoad?: () => void,
}): Promise<PlaidHeadlessSession>
```

## syncFinanceKit

### Description
Synchronizes data with iOS FinanceKit.

### Signature
```typescript
syncFinanceKit({
  token: string,
  requestAuthorizationIfNeeded?: boolean,
  syncBehavior?: FinanceKitSyncBehavior,
}): Promise<void>
```
```

--------------------------------

### Import createPlaidLinkSession

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/V13_MIGRATION_GUIDE.md

The public import path for the SDK remains the same. Use this to import the necessary function for creating Plaid Link sessions.

```typescript
import { createPlaidLinkSession } from "react-native-plaid-link-sdk";
```

--------------------------------

### Standard Link Session

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MANIFEST.txt

Initiates the standard account linking flow for users.

```APIDOC
## createPlaidLinkSession

### Description
Initiates the standard account linking flow for users.

### Method
(Not specified, likely a function call in the SDK)

### Endpoint
(Not applicable for SDK functions)

### Parameters
#### Path Parameters
(Not applicable)

#### Query Parameters
(Not applicable)

#### Request Body
(Not applicable)

### Request Example
(See USAGE-EXAMPLES.md for Standard Link Session)

### Response
#### Success Response (200)
(Not specified, likely a callback with public token)

#### Response Example
(Not specified)
```

--------------------------------

### Exchange Public Token for Access Token (Client & Server)

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/USAGE-EXAMPLES.md

The client-side code handles the initial token exchange request to your server. The server-side code (Node.js example) receives the public token, uses the Plaid client to exchange it for an access token and item ID, and then stores these securely. Ensure your server is configured to handle POST requests to the '/exchange-token' endpoint.

```typescript
// Client-side
async function handleSuccess(success: LinkSuccess) {
  const { publicToken } = success;

  try {
    const response = await fetch('https://yourserver.com/exchange-token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ publicToken }),
    });

    if (!response.ok) throw new Error('Exchange failed');

    const { accessToken, itemId } = await response.json();

    // Store securely
    await SecureStore.setItemAsync('plaid_access_token', accessToken);
    await SecureStore.setItemAsync('plaid_item_id', itemId);

    console.log('✓ Ready to use Plaid API');
  } catch (error) {
    console.error('Failed to exchange token:', error);
  }
}
```

```typescript
// Server-side (Node.js example)
app.post('/exchange-token', async (req, res) => {
  try {
    const { publicToken } = req.body;

    const response = await plaidClient.itemPublicTokenExchange({
      public_token: publicToken,
    });

    const { access_token, item_id } = response.data;

    // Store in your database
    await saveUserToken(userId, {
      accessToken: access_token,
      itemId: item_id,
    });

    res.json({ accessToken: access_token, itemId: item_id });
  } catch (error) {
    res.status(400).json({ error: error.message });
  }
});
```

--------------------------------

### Create and Open Plaid Link Session

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/USAGE-EXAMPLES.md

Use this snippet to create and manage a Plaid Link session. It handles token creation, success callbacks for account linking, exit callbacks for user interruptions, event logging, and loading states. Ensure you have a valid link token and implement server-side logic to exchange the public token for an access token.

```typescript
import { useState, useRef } from 'react';
import {
  View,
  Button,
  Text,
  SafeAreaView,
} from 'react-native';
import {
  createPlaidLinkSession,
  LinkSuccess,
  LinkExit,
  LinkEvent,
  PlaidLinkSession,
  LinkEventName,
} from 'react-native-plaid-link-sdk';

export function LinkSessionExample() {
  const [token, setToken] = useState('');
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const sessionRef = useRef<PlaidLinkSession | null>(null);

  const createSession = async () => {
    if (!token.trim()) {
      setError('Please enter a link token');
      return;
    }

    setLoading(true);
    setError(null);

    try {
      sessionRef.current = await createPlaidLinkSession({
        token: token.trim(),
        onSuccess: (success: LinkSuccess) => {
          console.log('✓ Account linked successfully');
          console.log('Public Token:', success.publicToken);
          console.log('Accounts:', success.metadata.accounts);
          
          // Exchange public token for access token on your server
          exchangePublicToken(success.publicToken);
        },
        onExit: (exit: LinkExit) => {
          if (exit.error) {
            setError(`Error: ${exit.error.errorMessage}`);
          } else {
            console.log('User exited normally');
          }
        },
        onEvent: (event: LinkEvent) => {
          console.log('Event:', event.eventName);
          
          if (event.eventName === LinkEventName.ERROR) {
            setError(event.metadata.errorMessage || 'Unknown error');
          }
        },
        onLoad: () => {
          console.log('Link is loaded and ready');
          setLoading(false);
        },
      });
    } catch (err) {
      setError(err instanceof Error ? err.message : 'Failed to create session');
      setLoading(false);
    }
  };

  const openLink = async () => {
    try {
      await sessionRef.current?.open(false);
    } catch (err) {
      setError(err instanceof Error ? err.message : 'Failed to open Link');
    }
  };

  return (
    <SafeAreaView style={{ flex: 1, padding: 16 }}>
      <Text style={{ fontSize: 18, fontWeight: 'bold', marginBottom: 16 }}>
        Plaid Link Session
      </Text>

      <View style={{ marginBottom: 16 }}>
        <Text style={{ marginBottom: 8 }}>Link Token:</Text>
        <TextInput
          value={token}
          onChangeText={setToken}
          placeholder="Enter link token"
          style={{
            borderWidth: 1,
            borderColor: '#ccc',
            padding: 8,
            borderRadius: 4,
          }}
        />
      </View>

      {error && (
        <Text style={{ color: 'red', marginBottom: 16 }}>Error: {error}</Text>
      )}

      <Button
        title={loading ? 'Creating...' : 'Create Session'}
        onPress={createSession}
        disabled={loading}
      />

      <Button
        title="Open Link"
        onPress={openLink}
        disabled={!sessionRef.current || loading}
      />
    </SafeAreaView>
  );
}

async function exchangePublicToken(publicToken: string) {
  // Call your backend
  const response = await fetch('https://yourserver.com/exchange-token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ publicToken }),
  });

  const { accessToken } = await response.json();
  console.log('Access Token:', accessToken);

  // Store accessToken securely for future API calls
}

```

--------------------------------

### Create Plaid Link Session

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/INDEX.md

Use this function for standard account linking. It returns a Promise that resolves to a PlaidLinkSession.

```typescript
const session = await createPlaidLinkSession({
  token: string,
  onSuccess: (success: LinkSuccess) => void,
  onExit: (exit: LinkExit) => void,
  onEvent: (event: LinkEvent) => void,
  onLoad?: () => void,
}) // returns Promise<PlaidLinkSession>
```

--------------------------------

### Create Plaid Headless Session

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/API-REFERENCE.md

Use this function to initiate a Plaid Link session when you are handling the UI externally. It requires a payment token and provides callbacks for success, exit, events, and load.

```typescript
export async function createPlaidHeadlessSession(
  config: LinkTokenConfiguration
): Promise<PlaidHeadlessSession>

```

```typescript
interface PlaidHeadlessSession {
  start: () => Promise<void>;
}

```

```typescript
import { createPlaidHeadlessSession } from 'react-native-plaid-link-sdk';

const session = await createPlaidHeadlessSession({
  token: 'link-sandbox-...', // Must be a payment token
  onSuccess: (success) => {
    console.log('Payment initiated:', success.publicToken);
  },
  onExit: (exit) => {
    console.log('Payment cancelled');
  },
  onEvent: (event) => {
    console.log('Event:', event.eventName);
  },
  onLoad: () => {
    console.log('Headless flow ready');
  },
});

await session.start();

```

--------------------------------

### Handle All Plaid Link Callbacks

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/CONFIGURATION.md

Implement all required callbacks: onSuccess for receiving the public token, onExit to handle user exits or errors, and onEvent for logging events. These are crucial for a complete integration.

```typescript
const session = await createPlaidLinkSession({
  token: linkToken,
  onSuccess: (success) => {
    // MUST implement - this is where you get the public token
    handleSuccess(success);
  },
  onExit: (exit) => {
    // MUST implement - handle user exit or errors
    if (exit.error) {
      handleError(exit.error);
    } else {
      handleNormalExit();
    }
  },
  onEvent: (event) => {
    // MUST implement - even if just logging
    logEvent(event);
  },
});
```

--------------------------------

### createPlaidLayerSession

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/API-REFERENCE.md

Creates a Plaid Layer session for wealth account verification flows. It returns a session object with `open()` and `submit()` methods.

```APIDOC
## createPlaidLayerSession

### Description
Create a Plaid Layer session for wealth account verification flows that require user submission of phone number and date of birth.

### Method Signature
```typescript
export async function createPlaidLayerSession(config: LayerTokenConfiguration): Promise<PlaidLayerSession>
```

### Parameters
#### config (LayerTokenConfiguration) - Required
Configuration object for the Layer session.

##### config Properties
- **token** (string) - Required - Link token from Plaid's `/link/token/create` endpoint.
- **onSuccess** (LinkSuccessListener) - Required - Callback invoked when user successfully completes Layer.
- **onExit** (LinkExitListener) - Optional - Callback invoked when user exits Layer.
- **onEvent** (LinkOnEventListener) - Optional - Callback invoked at key points in Layer.

### Return Type
`Promise<PlaidLayerSession>`

Returns a promise that resolves to a session object with `open()` and `submit()` methods.

```typescript
interface PlaidLayerSession {
  open: () => Promise<void>;
  submit: (data: SubmissionData) => Promise<void>;
}

interface SubmissionData {
  phoneNumber?: string;
  dateOfBirth?: string;
  params?: Record<string, string>;
}
```

### Throws
- Error if session creation fails.

### Usage Example
```typescript
import { createPlaidLayerSession, LinkEventName } from 'react-native-plaid-link-sdk';

let session;

session = await createPlaidLayerSession({
  token: 'link-sandbox-...',
  onSuccess: (success) => {
    console.log('Layer success:', success.publicToken);
  },
  onExit: (exit) => {
    console.log('Layer exited');
  },
  onEvent: async (event) => {
    if (event.eventName === LinkEventName.LAYER_READY) {
      await session.open();
    }
  },
});

// Submit user information
await session.submit({
  phoneNumber: '+1415555001',
  dateOfBirth: '1985-03-15',
});
```
```

--------------------------------

### Import Environment and Product Enums

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/MODULES.md

Import enums for specifying Plaid environments, products, and iOS presentation styles.

```typescript
// Enums - Environment & Products
import {
  PlaidEnvironment,
  PlaidProduct,
  LinkIOSPresentationStyle,
} from 'react-native-plaid-link-sdk';
```

--------------------------------

### Create Plaid Headless Session for Payments

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/INDEX.md

Use this function for headless payments. It returns a Promise that resolves to a PlaidHeadlessSession.

```typescript
const session = await createPlaidHeadlessSession({
  token: string,
  onSuccess: (success: LinkSuccess) => void,
  onExit: (exit: LinkExit) => void,
  onEvent: (event: LinkEvent) => void,
  onLoad?: () => void,
}) // returns Promise<PlaidHeadlessSession>
```

--------------------------------

### LinkAccountSubtypeLoan Classes

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/_autodocs/TYPES.md

Provides static instances for loan account subtypes. Covers various loan types like MORTGAGE, AUTO, and STUDENT.

```typescript
class LinkAccountSubtypeLoan {
  static readonly ALL: LinkAccountSubtypeLoan;
  static readonly AUTO: LinkAccountSubtypeLoan;
  static readonly BUSINESS: LinkAccountSubtypeLoan;
  static readonly COMMERCIAL: LinkAccountSubtypeLoan;
  static readonly CONSTRUCTION: LinkAccountSubtypeLoan;
  static readonly CONSUMER: LinkAccountSubtypeLoan;
  static readonly HOME_EQUITY: LinkAccountSubtypeLoan;
  static readonly LINE_OF_CREDIT: LinkAccountSubtypeLoan;
  static readonly LOAN: LinkAccountSubtypeLoan;
  static readonly MORTGAGE: LinkAccountSubtypeLoan;
  static readonly OVERDRAFT: LinkAccountSubtypeLoan;
  static readonly STUDENT: LinkAccountSubtypeLoan;
}
```

--------------------------------

### FinanceKit Sync Migration from v12 to v13

Source: https://github.com/plaid/react-native-plaid-link-sdk/blob/master/V13_MIGRATION_GUIDE.md

The `syncFinanceKit` function in v13 now accepts a configuration object and returns a promise, unlike the v12 version which used positional arguments and a callback. This change simplifies asynchronous handling and configuration. Note that FinanceKit is iOS-only; calling it on Android will result in an error.

```typescript
import { syncFinanceKit } from "react-native-plaid-link-sdk";

syncFinanceKit(
  "#GENERATED_LINK_TOKEN#",
  true,
  false,
  (error) => {
    if (error) {
      console.log("FinanceKit error", error);
      return;
    }

    console.log("FinanceKit sync complete");
  }
);
```

```typescript
import {
  FinanceKitSyncBehavior,
  syncFinanceKit,
} from "react-native-plaid-link-sdk";

try {
  await syncFinanceKit({
    token: "#GENERATED_LINK_TOKEN#",
    requestAuthorizationIfNeeded: true,
    syncBehavior: FinanceKitSyncBehavior.LIVE,
  });

  console.log("FinanceKit sync complete");
} catch (error) {
  console.log("FinanceKit error", error);
}
```