┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  Your Mobile    │     │    Sequence     │     │    Sequence     │
│      App        │────▶│      API        │◀────│   Dashboard     │
└─────────────────┘     └─────────────────┘     └─────────────────┘
        │                       │
        │  1. Fetch config      │
        │◀──────────────────────│
        │                       │
        │  2. Render screens    │
        │  3. Collect data      │
        │  4. Track events      │
        │──────────────────────▶│
        │                       │

// Available transitions
type ScreenTransition =
  | 'none'           // No animation
  | 'fade'           // Opacity fade
  | 'slide-left'     // Slide from right to left
  | 'slide-right'    // Slide from left to right
  | 'slide-up'       // Slide from bottom
  | 'slide-down'     // Slide from top
  | 'fade-slide-left'  // Fade + slide left
  | 'fade-slide-right' // Fade + slide right
  | 'scale';         // Scale up from center

// When onboarding completes, you receive:
{
  "user_name": "John Doe",           // From input block with id="user_name"
  "interests": ["fitness", "music"], // From checklist block with id="interests"
  "experience_level": 3,             // From slider block with id="experience_level"
}

// Handle in your onComplete callback:
<OnboardingModal
  onComplete={(collectedData) => {
    // Save to your backend
    saveUserPreferences(collectedData);

    // Or use locally
    if (collectedData.interests?.includes('fitness')) {
      showFitnessContent();
    }
  }}
/>

{
  "type": "input",
  "content": {
    "fieldName": "user_name",     // This creates the variable
    "label": "What's your name?",
    "placeholder": "Enter your name",
    "inputType": "text"
  }
}

// In any text block, button, or feature card:
"Welcome back, {user_name}!"

// The variable gets replaced with the actual value:
"Welcome back, Alex!"

// Basic multiplication
"That's {hours_per_day * 365} hours per year!"
// With hours_per_day = 2 → "That's 730 hours per year!"

// Division
"You'll save {minutes_saved * 365 / 60} hours annually"
// With minutes_saved = 30 → "You'll save 182.5 hours annually"

// Complex expressions
"{daily_calories * 7} weekly calories"
"{monthly_savings * 12} saved per year"

// Without formatting
"You've taken {total_steps} steps"
// Shows: "You've taken 2458 steps"

// With | number formatting
"You've taken {total_steps | number} steps"
// Shows: "You've taken 2,458 steps"

// Response
{
  "submissions": [
    {
      "id": "sub_123",
      "flow_id": "flow_abc",
      "user_id": "user_456",
      "session_id": "session_789",
      "data": {
        "name": "Alex",
        "email": "alex@example.com",
        "goals": ["fitness", "nutrition"]
      },
      "last_screen_id": "screen_3",
      "last_screen_index": 3,
      "completed_at": "2024-01-15T10:30:00Z",
      "created_at": "2024-01-15T10:25:00Z"
    }
  ],
  "total": 1
}

CREATE TABLE IF NOT EXISTS public.onboarding_submissions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  app_id UUID NOT NULL REFERENCES public.apps(id) ON DELETE CASCADE,
  flow_id UUID NOT NULL REFERENCES public.flows(id) ON DELETE CASCADE,
  user_id TEXT NOT NULL,
  device_id TEXT,
  session_id TEXT NOT NULL,
  data JSONB NOT NULL DEFAULT '{}',
  last_screen_id TEXT,
  last_screen_index INT,
  completed_at TIMESTAMPTZ,
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Indexes
CREATE INDEX idx_onboarding_submissions_app_user
  ON public.onboarding_submissions(app_id, user_id);
CREATE INDEX idx_onboarding_submissions_flow
  ON public.onboarding_submissions(flow_id);
CREATE INDEX idx_onboarding_submissions_session
  ON public.onboarding_submissions(session_id);

POST /api/v1/auth/apple
Content-Type: application/json
x-api-key: your-api-key

{
  "identity_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
  "user_identifier": "001234.abcd1234efgh5678.1234",
  "email": "user@example.com",        // Optional (only on first sign-in)
  "given_name": "John",               // Optional (only on first sign-in)
  "family_name": "Doe"                // Optional (only on first sign-in)
}

{
  "is_new_user": true,   // false for returning users
  "user_id": "uuid-of-user-record"
}

POST /api/v1/auth/google
Content-Type: application/json
x-api-key: your-api-key

{
  "id_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
  "email": "user@gmail.com",          // Optional
  "given_name": "John",               // Optional
  "family_name": "Doe"                // Optional
}

{
  "is_new_user": true,   // false for returning users
  "user_id": "uuid-of-user-record"
}

POST /api/v1/auth/email
Content-Type: application/json
x-api-key: your-api-key

{
  "email": "user@example.com",
  "given_name": "John",               // Optional
  "family_name": "Doe"                // Optional
}

{
  "is_new_user": true,   // false for returning users
  "user_id": "uuid-of-user-record"
}

// After receiving auth credentials...
let result = try await Sequence.shared.verifyAppleAuth(
    identityToken: token,
    userIdentifier: userId,
    email: email,
    givenName: givenName,
    familyName: familyName
)

if result.isNewUser {
    // Continue onboarding flow for new users
    Sequence.shared.sendSuccessResult()
} else {
    // Skip to main app for returning users
    Sequence.shared.markOnboardingCompleted()
    Sequence.shared.sendSuccessResult()
}

<!-- Notifications -->
<key>NSUserNotificationsUsageDescription</key>
<string>We'll send you reminders and updates about your progress.</string>

<!-- Location -->
<key>NSLocationWhenInUseUsageDescription</key>
<string>We use your location to show nearby content.</string>

<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>We use your location to send you relevant notifications.</string>

<!-- Camera -->
<key>NSCameraUsageDescription</key>
<string>We need camera access to let you take photos.</string>

<!-- Photos -->
<key>NSPhotoLibraryUsageDescription</key>
<string>We need access to your photos to let you choose a profile picture.</string>

<!-- Tracking (iOS 14+) -->
<key>NSUserTrackingUsageDescription</key>
<string>We use this to provide personalized ads and improve your experience.</string>

// The button uses this action identifier:
system.review

// Or create manually:
{
  "type": "custom",
  "identifier": "system.review",
  "awaitResult": true,
  "onSuccess": { "type": "next" }
}

extension AppDelegate: SequenceDelegate {

    func sequence(_ sequence: Sequence,
                  didReceiveCustomAction identifier: String,
                  awaitingResult: Bool) -> Bool {

        switch identifier {
        case "myapp.connectFitness":
            // Present your fitness app connection UI
            connectToFitnessApp { success in
                if success {
                    Sequence.shared.sendSuccessResult()
                } else {
                    Sequence.shared.sendFailureResult(error: "Connection failed")
                }
            }
            return true

        case "myapp.skipForNow":
            // Just advance without doing anything
            Sequence.shared.sendSuccessResult()
            return true

        default:
            return false // Not handled, let SDK handle or show error
        }
    }
}

// Success with optional data
Sequence.shared.sendSuccessResult(data: [
    "userId": "12345",
    "planType": "premium"
])

// Success without data
Sequence.shared.sendSuccessResult()

// Failure with error message
Sequence.shared.sendFailureResult(error: "Network connection failed")

// User cancelled
Sequence.shared.sendCancelledResult()

https://github.com/Musgrav/sequence-swift

import Sequence

@main
struct MyApp: App {
    init() {
        Sequence.shared.configure(
            appId: "your-app-id",
            apiKey: "your-api-key"
        )
    }

    var body: some Scene {
        WindowGroup {
            // Your existing app code - unchanged
            ExistingAppWithOldOnboarding()
        }
    }
}

import Foundation

enum OnboardingType: String {
    case legacy
    case sequence
}

class OnboardingTypeManager: ObservableObject {
    @Published var type: OnboardingType = .legacy

    init() {
        checkOnboardingType()
    }

    private func checkOnboardingType() {
        // Check if user should see new onboarding
        // Options: remote config, random assignment, user cohort, etc.
        if let assigned = UserDefaults.standard.string(forKey: "onboarding_type"),
           let onboardingType = OnboardingType(rawValue: assigned) {
            self.type = onboardingType
            return
        }

        // Random 50/50 assignment for new users
        let newType: OnboardingType = Bool.random() ? .sequence : .legacy
        UserDefaults.standard.set(newType.rawValue, forKey: "onboarding_type")
        self.type = newType
    }
}

import SwiftUI
import Sequence

struct OnboardingGate<Content: View>: View {
    @StateObject private var typeManager = OnboardingTypeManager()
    @StateObject private var sequence = Sequence.shared
    @State private var showLegacy = true
    let content: () -> Content

    var body: some View {
        Group {
            if typeManager.type == .legacy && showLegacy {
                LegacyOnboarding { data in
                    handleOnboardingData(data)
                    showLegacy = false
                }
            } else if typeManager.type == .sequence && !sequence.isOnboardingCompleted {
                WebViewOnboardingView {
                    // Onboarding completed
                }
            } else {
                content()
            }
        }
    }

    private func handleOnboardingData(_ data: [String: Any]) {
        // Your existing data handling logic
        // Works the same for both onboarding types
        saveUserPreferences(data)
        trackOnboardingComplete(data)
    }
}

// Set up the delegate to handle custom actions
Sequence.shared.delegate = self

// Implement the delegate methods
extension YourViewController: SequenceDelegate {
    func sequence(_ sequence: Sequence, didRequestNativeScreen screenId: String, data: [String: Any]) -> Bool {
        if screenId == "login-screen" {
            // Show your existing login UI
            presentLoginScreen {
                // Continue onboarding after login
                Sequence.shared.track(.screenCompleted, screenId: screenId)
            }
            return true // Indicates you're handling this screen
        }
        return false
    }

    func sequence(_ sequence: Sequence, didTriggerCustomAction action: String, screenId: String) {
        switch action {
        case "request-notifications":
            requestNotificationPermission()
        case "connect-social":
            showSocialConnect()
        default:
            break
        }
    }
}

// Final clean implementation
@main
struct MyApp: App {
    init() {
        Sequence.shared.configure(
            appId: "your-app-id",
            apiKey: "your-api-key"
        )
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

struct ContentView: View {
    @StateObject private var sequence = Sequence.shared

    var body: some View {
        Group {
            if sequence.isOnboardingCompleted {
                MainAppView()
            } else {
                WebViewOnboardingView {
                    // Onboarding completed
                }
            }
        }
    }
}

import Sequence

// Clear completion status to re-show onboarding
Sequence.shared.reset()

// Or reset just the onboarding state
Sequence.shared.resetOnboarding()

import Sequence

// Core singleton
Sequence.shared

// Configuration
Sequence.shared.configure(appId: String, apiKey: String, baseURL: String?)

// User identification
Sequence.shared.identify(userId: String)
Sequence.shared.reset()

// Event tracking
Sequence.shared.track(_ eventType: EventType, screenId: String?, properties: [String: Any]?)

// Onboarding state
Sequence.shared.isOnboardingCompleted
Sequence.shared.resetOnboarding()

import Sequence

class AuthManager {
    // Identify user after login
    func handleLogin(userId: String) {
        Sequence.shared.identify(userId: userId)
    }

    // Track custom event
    func handleButtonPress() {
        Sequence.shared.track(.buttonTapped, screenId: "welcome-screen", properties: [
            "button_label": "Get Started"
        ])
    }

    // Reset on logout
    func handleLogout() {
        Sequence.shared.reset()
    }
}

import Sequence

// Configure in your App init
Sequence.shared.configure(
    appId: "your-app-id",
    apiKey: "your-api-key",
    baseURL: "https://screensequence.com"
)

import SwiftUI
import Sequence

struct MyView: View {
    @StateObject private var sequence = Sequence.shared

    var body: some View {
        VStack {
            // Observe configuration state
            if sequence.isConfigured {
                Text("SDK is configured")
            }

            // Observe loading state
            if sequence.isLoading {
                ProgressView()
            }

            // Observe onboarding completion
            if sequence.isOnboardingCompleted {
                MainAppView()
            } else {
                OnboardingView { }
            }

            // Access screens
            Text("\(sequence.screens.count) screens in this flow")

            // Access experiment info
            if let experiment = sequence.experimentInfo {
                Text("Variant: \(experiment.variantName)")
            }
        }
    }
}

import SwiftUI
import Sequence

struct ContentView: View {
    @StateObject private var sequence = Sequence.shared

    var body: some View {
        Group {
            if sequence.isOnboardingCompleted {
                MainAppView()
            } else {
                WebViewOnboardingView(
                    onComplete: {
                        print("Onboarding completed!")
                    },
                    onDataCollected: { data in
                        print("User data:", data)
                        saveToBackend(data)
                    }
                )
            }
        }
    }
}

import Sequence

class MyAppDelegate: SequenceDelegate {
    // Handle custom native screens
    func sequence(_ sequence: Sequence, didRequestNativeScreen screenId: String, data: [String: Any]) -> Bool {
        if screenId == "auth-screen" {
            showAuthFlow()
            return true // We're handling this
        }
        return false // Let Sequence handle it
    }

    // Handle custom button actions
    func sequence(_ sequence: Sequence, didTriggerCustomAction action: String, screenId: String) {
        if action == "open-settings" {
            if let url = URL(string: UIApplication.openSettingsURLString) {
                UIApplication.shared.open(url)
            }
        }
    }
}

// Set the delegate
Sequence.shared.delegate = MyAppDelegate()

// Onboarding configuration from API
struct OnboardingConfig: Codable {
    let version: Int
    let screens: [Screen]
    let progressIndicator: FlowProgressIndicator?
    let transitions: [ScreenTransitionConfig]?
    let experiment: ExperimentInfo?
}

// Individual screen
struct Screen: Codable, Identifiable {
    let id: String
    let appId: String
    let flowId: String?
    let name: String
    let type: ScreenType
    let order: Int
    let content: ScreenContent
    let transition: ScreenTransition?
    let createdAt: String
    let updatedAt: String
}

enum ScreenType: String, Codable {
    case welcome
    case feature
    case carousel
    case permission
    case celebration
    case native
    case filler
}

// Event types for tracking
enum EventType {
    case screenViewed
    case screenFirstViewed
    case screenCompleted
    case screenSkipped
    case screenDroppedOff
    case buttonTapped
    case onboardingStarted
    case onboardingCompleted
    case experimentVariantAssigned
}

enum BlockType: String, Codable {
    case text
    case image
    case button
    case input
    case checklist
    case slider
    case progress
    case spacer
    case divider
    case icon
    case featureCard = "feature-card"
}

// Experiment info
struct ExperimentInfo: Codable {
    let id: String
    let variantId: String
    let variantName: String
}