┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  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();
    }
  }}
/>

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
}