### Configure Storage Types with Macros

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

Demonstrates how to use the @Storage macro and @Attribute property wrapper to define storage locations, including standard UserDefaults and App Group suites.

```swift
import SwiftStorage

@Storage
final class MultiDestinationSettings {
	var localSetting: Bool

	@Attribute(type: .localWith(suite: "group.com.example.myapp"), key: "SharedValue")
	var sharedSetting: Int

	@Attribute(type: .localWith(suite: nil), key: "CustomKey")
	var customSetting: String

	init() {
		self.localSetting = false
		self.sharedSetting = 0
		self.customSetting = ""
	}
}
```

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

### Direct StorageManager Usage

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

Explains how to interact directly with the StorageManager class for manual read/write operations, including handling Codable objects and custom suites.

```swift
import SwiftStorage

let manager = StorageManager(type: .local, key: "MyCustomKey")
manager.set(value: "Hello, World!")
let stringValue: String = manager.get(defaultValue: "default")

struct UserProfile: Codable {
	var id: Int
	var name: String
}

let profileManager = StorageManager(type: .local, key: "UserProfile")
profileManager.set(value: UserProfile(id: 1, name: "John"))
let profile: UserProfile = profileManager.get(defaultValue: UserProfile(id: 0, name: ""))
```

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

### Define a Persistent Model with SwiftStorage

Source: https://github.com/kc-2001ms/swiftstorage/blob/main/README.md

Demonstrates how to define a data model using the @Storage macro. This automatically handles the persistence of properties to UserDefaults.

```swift
import SwiftStorage

@Storage
final class SwiftStorageModel {
    var storedValue: Bool
    
    init() {
        self.storedValue = false
    }
}
```

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

### Integrate SwiftStorage Model in SwiftUI

Source: https://github.com/kc-2001ms/swiftstorage/blob/main/README.md

Shows how to instantiate and use a @Storage-enabled model within a SwiftUI view, allowing for reactive UI updates and automatic data saving.

```swift
import SwiftUI

struct SwiftStorageView: View {
    @State private var swiftStorage = SwiftStorageModel()
    
    var body: some View {
        NavigationStack {
            Form {
                Toggle("Bool", isOn: $swiftStorage.storedValue)
            }
        }
    }
}
```

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

### StorageManager Class

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

Direct interface for reading and writing data to storage.

```APIDOC
## StorageManager

### Description
Provides manual control over storage operations. Useful for advanced use cases where property wrappers are not applicable.

### Methods
- set(value: T): Persists a value to the defined key.
- get(defaultValue: T) -> T: Retrieves a value, returning the provided default if the key is missing.

### Example
```swift
let manager = StorageManager(type: .local, key: "MyKey")
manager.set(value: "Hello")
let val: String = manager.get(defaultValue: "Default")
```
```

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

### Storable Protocol

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

Explains which data types are supported for automatic persistence.

```APIDOC
## Storable Protocol

### Description
Defines types that can be automatically persisted. Includes primitive types, collections, and Codable objects.

### Supported Types
- Primitives: String, Int, Double, Float, Bool
- Foundation: Data, Date
- Collections: Array<Storable>, Dictionary<String, Storable>
- Custom: Any type conforming to Codable

### Example
```swift
@Storage
final class DataStore {
    var tags: [String]
    var scores: [String: Int]
}
```
```

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

### Configure Persistence Exclusion

Source: https://github.com/kc-2001ms/swiftstorage/blob/main/README.md

Illustrates how to prevent specific properties from being saved by using the @Transient macro or by declaring properties as constants.

```swift
import SwiftStorage

@Storage
final class SwiftStorageModel {
    var storedValue: Bool
    
    @Transient
    var temporaryValue: String
    
    let constantValue: String
    
    init() {
        self.storedValue = false
        self.temporaryValue = ""
        self.constantValue = ""
    }
}
```

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

### SwiftUI Preferences with SwiftStorage

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

This Swift code defines a data model 'AppPreferences' using SwiftStorage's @Storage macro for automatic persistence. It includes standard properties, a custom key for launch count, App Group sharing for widget data, and transient properties. A SwiftUI View 'PreferencesView' is provided to interact with these preferences, demonstrating how to bind UI elements to the persisted properties and update them.

```swift
import SwiftUI
import SwiftStorage

@Storage
final class AppPreferences {
    // Standard persisted properties
    var darkMode: Bool
    var accentColorIndex: Int
    var userName: String
    var notificationsEnabled: Bool

    // Custom key for backward compatibility
    @Attribute(key: "app_launch_count")
    var launchCount: Int

    // Shared with widget via App Group
    @Attribute(type: .localWith(suite: "group.com.myapp"), key: "WidgetData")
    var widgetMessage: String

    // Transient - not persisted
    @Transient
    var isOnboarding: Bool

    @ObservationIgnored
    var internalState: String

    init() {
        self.darkMode = false
        self.accentColorIndex = 0
        self.userName = ""
        self.notificationsEnabled = true
        self.launchCount = 0
        self.widgetMessage = "Welcome!"
        self.isOnboarding = true
        self.internalState = ""
    }
}

struct PreferencesView: View {
    @State private var preferences = AppPreferences()

    let accentColors = ["Blue", "Purple", "Green", "Orange"]

    var body: some View {
        NavigationStack {
            Form {
                Section("Appearance") {
                    Toggle("Dark Mode", isOn: $preferences.darkMode)
                    Picker("Accent Color", selection: $preferences.accentColorIndex) {
                        ForEach(0..<accentColors.count, id: \.self) {
                            index in
                            Text(accentColors[index]).tag(index)
                        }
                    }
                }

                Section("Profile") {
                    TextField("Name", text: $preferences.userName)
                    Toggle("Notifications", isOn: $preferences.notificationsEnabled)
                }

                Section("Widget") {
                    TextField("Widget Message", text: $preferences.widgetMessage)
                    Text("This value is shared with your widget")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }

                Section("Stats") {
                    LabeledContent("Launch Count", value: "\(preferences.launchCount)")
                }
            }
            .navigationTitle("Preferences")
            .onAppear {
                preferences.launchCount += 1
            }
        }
    }
}

```

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

### @Storage Macro

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

The @Storage macro enables automatic persistence and observation for all mutable properties within a class, integrating seamlessly with SwiftUI.

```APIDOC
## @Storage Macro

### Description
Applies automatic persistence and observation to all mutable properties in a class. It generates keys based on the class and property names and sets up the Observation framework.

### Usage
Apply the `@Storage` attribute to a class definition.

### Request Example
```swift
@Storage
final class UserSettings {
    var isDarkModeEnabled: Bool
    var fontSize: Int
    
    init() {
        self.isDarkModeEnabled = false
        self.fontSize = 14
    }
}
```
```

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

### @Attribute Macro

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

The @Attribute macro allows for custom storage keys and specific UserDefaults suite configurations.

```APIDOC
## @Attribute Macro

### Description
Provides granular control over how a property is stored, including custom keys and support for App Group suites.

### Parameters
- **key** (String) - Optional - Custom identifier for the UserDefaults key.
- **type** (StorageType) - Optional - Defines the storage suite (e.g., .local, .localWith(suite: String)).

### Request Example
```swift
@Storage
final class AppSettings {
    @Attribute(key: "user_preferred_language")
    var preferredLanguage: String

    @Attribute(type: .localWith(suite: "group.com.myapp.shared"), key: "SharedCounter")
    var sharedCounter: Int
}
```
```

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

### StorageType and Attribute Configuration

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

Defines how data is persisted using StorageType and the @Attribute property wrapper.

```APIDOC
## StorageType Configuration

### Description
Defines the storage destination for persisted properties. Supports standard UserDefaults or custom suites for App Group data sharing.

### Usage
- .local: Uses UserDefaults.standard
- .localWith(suite: String?): Uses a specific UserDefaults suite

### Example
```swift
@Attribute(type: .localWith(suite: "group.com.example.myapp"), key: "SharedValue")
var sharedSetting: Int
```
```

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

### Implement Storable Types

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

Shows the usage of built-in Storable types and collections within a @Storage class. These types are automatically serialized and persisted by the library.

```swift
import SwiftStorage

@Storage
final class DataStore {
	var name: String
	var count: Int
	var tags: [String]
	var scores: [String: Int]

	init() {
		self.name = ""
		self.count = 0
		self.tags = []
		self.scores = [:]
	}
}

let store = DataStore()
store.tags = ["swift", "ios", "storage"]
store.scores = ["level1": 100, "level2": 250]
```

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

### Swift: @Storage Macro for Automatic UserDefaults Persistence

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

The @Storage macro automatically persists all mutable properties of a class to UserDefaults. It also integrates with the Observation framework for reactive updates in SwiftUI. Properties are automatically made observable and keys are generated based on class and property names.

```swift
import SwiftStorage

@Storage
final class UserSettings {
    var isDarkModeEnabled: Bool
    var fontSize: Int
    var username: String
    var lastLoginDate: Date

    init() {
        self.isDarkModeEnabled = false
        self.fontSize = 14
        self.username = ""
        self.lastLoginDate = Date.now
    }
}

// Usage in SwiftUI - values automatically persist across app launches
struct SettingsView: View {
    @State private var settings = UserSettings()

    var body: some View {
        Form {
            Toggle("Dark Mode", isOn: $settings.isDarkModeEnabled)
            Stepper("Font Size: \(settings.fontSize)", value: $settings.fontSize, in: 8...24)
            TextField("Username", text: $settings.username)
            DatePicker("Last Login", selection: $settings.lastLoginDate)
        }
    }
}
```

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

### Swift: @Attribute Macro for Custom Storage Keys and Suites

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

The @Attribute macro allows customization of the UserDefaults key and storage suite for individual properties. Use it to specify a custom key or to store data in a shared App Group suite for inter-app communication (e.g., between an app and its extensions).

```swift
import SwiftStorage

@Storage
final class AppSettings {
    // Uses default key: "AppSettings.theme"
    var theme: String

    // Uses custom key "user_preferred_language" instead of "AppSettings.preferredLanguage"
    @Attribute(key: "user_preferred_language")
    var preferredLanguage: String

    // Stored in shared App Group suite for extension access
    @Attribute(type: .localWith(suite: "group.com.myapp.shared"), key: "SharedCounter")
    var sharedCounter: Int

    // Standard UserDefaults with custom key
    @Attribute(type: .local, key: "NotificationPreference")
    var notificationsEnabled: Bool

    init() {
        self.theme = "system"
        self.preferredLanguage = "en"
        self.sharedCounter = 0
        self.notificationsEnabled = true
    }
}

// Access shared data from app extension
// Both main app and widget can read/write sharedCounter
let settings = AppSettings()
settings.sharedCounter += 1  // Saved to App Group UserDefaults
```

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

### @Transient Macro

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

The @Transient macro marks specific properties to be excluded from persistence, keeping them in memory only.

```APIDOC
## @Transient Macro

### Description
Excludes a property from being saved to UserDefaults. Useful for temporary state or computed values that should reset on app launch.

### Usage
Apply the `@Transient` attribute to specific properties within a `@Storage` class.

### Request Example
```swift
@Storage
final class SessionManager {
    var savedUsername: String
    
    @Transient
    var currentSessionToken: String
    
    init() {
        self.savedUsername = ""
        self.currentSessionToken = ""
    }
}
```
```

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

### Swift: @Transient Macro to Exclude Properties from Persistence

Source: https://context7.com/kc-2001ms/swiftstorage/llms.txt

The @Transient macro marks properties that should not be saved to UserDefaults. These properties remain as regular instance variables but their values will reset to their initial state upon application launch. This is useful for temporary state or computed values.

```swift
import SwiftStorage

@Storage
final class SessionManager {
    var savedUsername: String           // Persisted to UserDefaults
    var rememberMe: Bool               // Persisted to UserDefaults

    @Transient
    var currentSessionToken: String    // NOT persisted - resets on app launch

    @Transient
    var isAuthenticated: Bool          // NOT persisted - temporary state

    init() {
        self.savedUsername = ""
        self.rememberMe = false
        self.currentSessionToken = ""
        self.isAuthenticated = false
    }
}

// currentSessionToken and isAuthenticated will reset to initial values on each app launch
// savedUsername and rememberMe will persist across launches
let session = SessionManager()
session.savedUsername = "john@example.com"  // Saved to UserDefaults
session.currentSessionToken = "abc123"       // Only in memory, not saved
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.