let package = Package(
    name: "my-package",
    products: [
        .library(name: "MyProduct", targets: ["MyTarget"]),
    ],
    dependencies: [
        .package(url: "https://source.skip.dev/skip-kit.git", from: "1.0.0"),
    ],
    targets: [
        .target(name: "MyTarget", dependencies: [
            .product(name: "SkipKit", package: "skip-kit")
        ])
    ]
)

// Create a cache that can store up to 100 bytes of Data instances
// and will evict everything when the app is put in the background
let cache = Cache<UUID, Data>(evictOnBackground: true, limit: 100, cost: \.count)

cache.putValue(Data(count: 1), for: UUID()) // total cost = 1
cache.putValue(Data(count: 99), for: UUID()) // total cost = 100
cache.putValue(Data(count: 1), for: UUID()) // total cost = 101, so cache will evict older entries

import SkipKit

let info = AppInfo.current

// Version and identity
print("App Name: \(info.displayName ?? "Unknown")")
print("App ID: \(info.appIdentifier ?? "Unknown")")
print("Version: \(info.version ?? "Unknown")")
print("Build: \(info.buildNumber ?? "Unknown")")
print("Full: \(info.versionWithBuild)")  // e.g. "1.2.3 (42)"

// Build configuration
if info.isDebug {
    print("Running in debug mode")
}

if info.isTestFlight {
    print("Installed from TestFlight")
}

// Platform
print("OS: \(info.osName) \(info.osVersion)")  // e.g. "iOS 17.4.1" or "Android 34"
print("Device: \(info.deviceModel)")             // e.g. "iPhone15,2" or "Pixel 7"

Text("Version \(AppInfo.current.versionWithBuild)")
// Displays: "Version 1.2.3 (42)"

if AppInfo.current.isDebug {
    // Show debug tools, logging, etc.
} else {
    // Production behavior
}

let keys = AppInfo.current.infoDictionaryKeys
if let minOS = AppInfo.current.infoDictionaryValue(forKey: "MinimumOSVersion") as? String {
    print("Requires iOS \(minOS)")
}

let schemes = AppInfo.current.urlSchemes
// e.g. ["myapp"] from CFBundleURLTypes

import SkipKit

let device = DeviceInfo.current

print("Screen: \(device.screenWidth) x \(device.screenHeight) points")
print("Scale: \(device.screenScale)x")

switch DeviceInfo.current.deviceType {
case .phone:  print("Phone")
case .tablet: print("Tablet")
case .desktop: print("Desktop")
case .tv:     print("TV")
case .watch:  print("Watch")
case .unknown: print("Unknown")
}

// Convenience checks
if DeviceInfo.current.isTablet {
    // Use tablet layout
}

print("Manufacturer: \(DeviceInfo.current.manufacturer)")  // "Apple" or "Google", "Samsung", etc.
print("Model: \(DeviceInfo.current.modelName)")              // "iPhone15,2" or "Pixel 7"

if let level = DeviceInfo.current.batteryLevel {
    print("Battery: \(Int(level * 100))%")
}

switch DeviceInfo.current.batteryState {
case .charging: print("Charging")
case .full:     print("Full")
case .unplugged: print("On battery")
case .unknown:  print("Unknown")
}

let status = DeviceInfo.current.networkStatus
switch status {
case .wifi:     print("Connected via Wi-Fi")
case .cellular: print("Connected via cellular")
case .ethernet: print("Connected via Ethernet")
case .other:    print("Connected (other)")
case .offline:  print("No connection")
}

// Convenience checks
if DeviceInfo.current.isOnline {
    // Proceed with network request
}
if DeviceInfo.current.isOnWifi {
    // Safe for large downloads
}

struct ConnectivityView: View {
    @State var status: NetworkStatus = .offline

    var body: some View {
        VStack {
            Text("Network: \(status.rawValue)")
            Circle()
                .fill(status == .offline ? Color.red : Color.green)
                .frame(width: 20, height: 20)
        }
        .task {
            for await newStatus in DeviceInfo.current.monitorNetwork() {
                status = newStatus
            }
        }
    }
}

func waitForConnectivity() async -> NetworkStatus {
    for await status in DeviceInfo.current.monitorNetwork() {
        if status != .offline {
            return status
        }
    }
    return .offline
}

let monitorTask = Task {
    for await status in DeviceInfo.current.monitorNetwork() {
        print("Status changed: \(status.rawValue)")
    }
}

// Later, stop monitoring:
monitorTask.cancel()

print("Locale: \(DeviceInfo.current.localeIdentifier)")      // e.g. "en_US"
print("Language: \(DeviceInfo.current.languageCode ?? "")")   // e.g. "en"
print("Time zone: \(DeviceInfo.current.timeZoneIdentifier)")  // e.g. "America/New_York"

import SkipKit
import SkipDevice

let locationProvider = LocationProvider()

if await PermissionManager.requestPermission(.ACCESS_FINE_LOCATION) == true {
    let location = try await locationProvider.fetchCurrentLocation()
}

static func queryLocationPermission(precise: Bool, always: Bool) -> PermissionAuthorization
static func requestLocationPermission(precise: Bool, always: Bool) async -> PermissionAuthorization

static func queryPostNotificationPermission() async -> PermissionAuthorization
static func requestPostNotificationPermission(alert: Bool = true, sound: Bool = true, badge: Bool = true) async throws -> PermissionAuthorization

static func queryCameraPermission() -> PermissionAuthorization
static func requestCameraPermission() async -> PermissionAuthorization

static func queryRecordAudioPermission() -> PermissionAuthorization
static func requestRecordAudioPermission() async -> PermissionAuthorization

static func queryContactsPermission(readWrite: Bool) -> PermissionAuthorization
static func requestContactsPermission(readWrite: Bool) async throws -> PermissionAuthorization

static func queryCalendarPermission(readWrite: Bool) -> PermissionAuthorization
static func requestCalendarPermission(readWrite: Bool) async throws -> PermissionAuthorization

static func queryReminderPermission(readWrite: Bool) -> PermissionAuthorization
static func requestReminderPermission(readWrite: Bool) async throws -> PermissionAuthorization

static func queryPhotoLibraryPermission(readWrite: Bool) -> PermissionAuthorization
static func requestPhotoLibraryPermission(readWrite: Bool) async -> PermissionAuthorization

let granted = await PermissionManager.requestPermission("android.permission.SEND_SMS")

import SkipKit

/// A button that enables the selection of media from the library or the taking of a photo.
///
/// The selected/captured image will be communicated through the `selectedImageURL` binding,
/// which can be observed with `onChange` to perform an action when the media URL is acquired.
struct MediaButton : View {
    let type: MediaPickerType // either .camera or .library
    @Binding var selectedImageURL: URL?
    @State private var showPicker = false

    var body: some View {
        Button(type == .camera ? "Take Photo" : "Select Media") {
            showPicker = true // activate the media picker
        }
        .withMediaPicker(type: .camera, isPresented: $showPicker, selectedImageURL: $selectedImageURL)
    }
}

Button("Pick Document") {
    presentPreview = true
}
.buttonStyle(.borderedProminent)
.withDocumentPicker(isPresented: $presentPreview, allowedContentTypes: [.image, .pdf], selectedDocumentURL: $selectedDocument, selectedFilename: $filename, selectedFileMimeType: $mimeType)

.withDocumentPicker(
    isPresented: $showPicker,
    allowedContentTypes: [.epub],
    selectedDocumentURL: $pickedURL,
    selectedFilename: $pickedName,
    selectedFileMimeType: $pickedType
)
.onChange(of: pickedURL) { oldURL, newURL in
    guard let url = newURL else { return }
    pickedURL = nil
    Task {
        #if !SKIP
        // Re-acquire security-scoped access for the picked file.
        // Without this, file operations like copy or read will fail
        // with a "you don't have permission to view it" error.
        let accessing = url.startAccessingSecurityScopedResource()
        defer { if accessing { url.stopAccessingSecurityScopedResource() } }
        #endif
        await importFile(from: url)
    }
}

import SkipKit

if MailComposer.canSendMail() {
    // Show compose button
} else {
    // Email not available
}

struct EmailView: View {
    @State var showComposer = false

    var body: some View {
        Button("Send Feedback") {
            showComposer = true
        }
        .withMailComposer(
            isPresented: $showComposer,
            options: MailComposerOptions(
                recipients: ["support@example.com"],
                subject: "App Feedback",
                body: "I'd like to share the following feedback..."
            ),
            onComplete: { result in
                switch result {
                case .sent: print("Email sent!")
                case .saved: print("Draft saved")
                case .cancelled: print("Cancelled")
                case .failed: print("Failed to send")
                case .unknown: print("Unknown result")
                }
            }
        )
    }
}

MailComposerOptions(
    recipients: ["user@example.com"],
    subject: "Welcome!",
    body: "<h1>Welcome</h1><p>Thank you for signing up.</p>",
    isHTML: true
)

let pdfURL = Bundle.main.url(forResource: "report", withExtension: "pdf")!

MailComposerOptions(
    recipients: ["team@example.com"],
    subject: "Monthly Report",
    body: "Please find the report attached.",
    attachments: [
        MailAttachment(url: pdfURL, mimeType: "application/pdf", filename: "report.pdf")
    ]
)

attachments: [
    MailAttachment(url: pdfURL, mimeType: "application/pdf", filename: "report.pdf"),
    MailAttachment(url: imageURL, mimeType: "image/png", filename: "chart.png")
]

MailComposerOptions(
    recipients: ["primary@example.com"],
    ccRecipients: ["manager@example.com", "team@example.com"],
    bccRecipients: ["archive@example.com"],
    subject: "Project Update"
)

import SwiftUI
import SkipKit

struct MyView: View {
    @State var showPage = false

    var body: some View {
        Button("Open Documentation") {
            showPage = true
        }
        .openWebBrowser(
            isPresented: $showPage,
            url: "https://skip.dev/docs",
            mode: .embeddedBrowser(params: nil)
        )
    }
}

Button("Open in Safari / Chrome") {
    showPage = true
}
.openWebBrowser(
    isPresented: $showPage,
    url: "https://skip.dev",
    mode: .launchBrowser
)

Button("Open with Navigation Style") {
    showPage = true
}
.openWebBrowser(
    isPresented: $showPage,
    url: "https://skip.dev",
    mode: .embeddedBrowser(params: EmbeddedParams(
        presentationMode: .navigation
    ))
)

Button("Open with Actions") {
    showPage = true
}
.openWebBrowser(
    isPresented: $showPage,
    url: "https://skip.dev",
    mode: .embeddedBrowser(params: EmbeddedParams(
        customActions: [
            WebBrowserAction(label: "Copy Link") { url in
                // handle the action with the current page URL
            },
            WebBrowserAction(label: "Bookmark") { url in
                // save the URL
            }
        ]
    ))
)

/// Controls how the embedded browser is presented.
public enum WebBrowserPresentationMode {
    /// Present as a vertically-sliding modal sheet (default).
    case sheet
    /// Present as a horizontally-sliding navigation push.
    case navigation
}

/// The mode for opening a web page.
public enum WebBrowserMode {
    /// Open the URL in the system's default browser application.
    case launchBrowser
    /// Open the URL in an embedded browser within the app.
    case embeddedBrowser(params: EmbeddedParams?)
}

/// Configuration for the embedded browser.
public struct EmbeddedParams {
    public var presentationMode: WebBrowserPresentationMode
    public var customActions: [WebBrowserAction]
}

/// A custom action available on a web page.
public struct WebBrowserAction {
    public let label: String
    public let handler: (URL) -> Void
}

/// View modifier to open a web page.
extension View {
    public func openWebBrowser(
        isPresented: Binding<Bool>,
        url: String,
        mode: WebBrowserMode
    ) -> some View
}

import SkipKit

// Light tap for picking up a draggable element
HapticFeedback.play(.pick)

// Quick double-tick when snapping to a grid
HapticFeedback.play(.snap)

// Solid tap when placing an element
HapticFeedback.play(.place)

// Confirmation feedback
HapticFeedback.play(.success)

// Bouncy celebration for clearing a line or completing a task
HapticFeedback.play(.celebrate)

// Bigger celebration with escalating intensity
HapticFeedback.play(.bigCelebrate)

// Warning for an invalid action
HapticFeedback.play(.warning)

// Error feedback with three descending taps
HapticFeedback.play(.error)

// Heavy impact for collisions
HapticFeedback.play(.impact)

// A 2x combo: two quick taps + light thud
HapticFeedback.play(.combo(streak: 2))

// A 5x combo: five escalating taps + heavy thud
HapticFeedback.play(.combo(streak: 5))

// Bouncing pattern with 4 taps of decreasing intensity
HapticFeedback.play(.bounce(count: 4, startIntensity: 0.9))

// A custom "power-up" pattern: rising buzz, pause, two sharp taps
let powerUp = HapticPattern([
    HapticEvent(.rise, intensity: 0.6),
    HapticEvent(.rise, intensity: 1.0, delay: 0.1),
    HapticEvent(.tap, intensity: 1.0, delay: 0.15),
    HapticEvent(.tap, intensity: 0.8, delay: 0.06),
])

HapticFeedback.play(powerUp)