@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
public struct CloudKitSchemaService {
    let containerIdentifier: String
    let tokenManager: ManagementTokenProvider
    let environment: Environment
    
    // MARK: - Schema Export/Import
    
    /// Export schema definition from CloudKit
    func exportSchema() async throws -> CloudKitSchema
    
    /// Export schema and save to file
    func exportSchema(to url: URL) async throws
    
    /// Import schema definition to CloudKit
    func importSchema(_ schema: CloudKitSchema) async throws
    
    /// Import schema from file
    func importSchema(from url: URL) async throws
    
    // MARK: - Schema Reset
    
    /// Reset development schema to match production
    func resetDevelopmentSchema() async throws
    
    // MARK: - Schema Inspection
    
    /// Get current schema definition
    func getSchema() async throws -> CloudKitSchema
    
    /// Compare schemas between environments
    func compareSchemas(
        source: Environment,
        target: Environment
    ) async throws -> SchemaDiff
    
    // MARK: - Record Type Management
    
    /// Create or update a record type
    func saveRecordType(_ recordType: RecordTypeDefinition) async throws
    
    /// Delete a record type
    func deleteRecordType(_ typeName: String) async throws
    
    /// List all record types
    func listRecordTypes() async throws -> [RecordTypeDefinition]
}

/// Complete CloudKit schema definition
public struct CloudKitSchema: Codable {
    public let recordTypes: [RecordTypeDefinition]
    public let securityRoles: [SecurityRole]
    public let subscriptions: [SubscriptionDefinition]?
    public let indexes: [IndexDefinition]?
    
    // File format support (.ckdb compatibility)
    public func write(to url: URL) throws
    public static func read(from url: URL) throws -> CloudKitSchema
}

/// Record type definition
public struct RecordTypeDefinition: Codable {
    public let name: String
    public let fields: [FieldDefinition]
    public let indexes: [IndexDefinition]
}

/// Field definition
public struct FieldDefinition: Codable {
    public let name: String
    public let type: FieldType
    public let isList: Bool
    public let isRequired: Bool
    public let isIndexed: Bool
    public let isUnique: Bool
}

public enum FieldType: String, Codable {
    case string = "STRING"
    case int64 = "INT64"
    case double = "DOUBLE"
    case date = "TIMESTAMP"
    case bytes = "BYTES"
    case reference = "REFERENCE"
    case asset = "ASSET"
    case location = "LOCATION"
    case stringList = "STRING_LIST"
    case int64List = "INT64_LIST"
    case doubleList = "DOUBLE_LIST"
    case dateList = "TIMESTAMP_LIST"
    case referenceList = "REFERENCE_LIST"
    case assetList = "ASSET_LIST"
}

/// Index definition
public struct IndexDefinition: Codable {
    public let fieldName: String
    public let indexType: IndexType
}

public enum IndexType: String, Codable {
    case queryable = "QUERYABLE"
    case sortable = "SORTABLE"
    case unique = "UNIQUE"
}

/// Schema difference report
public struct SchemaDiff {
    public let addedRecordTypes: [String]
    public let removedRecordTypes: [String]
    public let modifiedRecordTypes: [RecordTypeChange]
}

public struct RecordTypeChange {
    public let name: String
    public let addedFields: [String]
    public let removedFields: [String]
    public let modifiedFields: [FieldChange]
}

/// Management token provider (separate from runtime auth)
public protocol ManagementTokenProvider {
    func getManagementToken() async throws -> String
}

/// Simple implementation
public struct StaticManagementToken: ManagementTokenProvider {
    let token: String
    
    public func getManagementToken() async throws -> String {
        return token
    }
}

/// Keychain-backed implementation
public struct KeychainManagementToken: ManagementTokenProvider {
    let keychainKey: String
    
    public func getManagementToken() async throws -> String {
        // Read from keychain
    }
}

let schemaService = try CloudKitSchemaService(
    containerIdentifier: "iCloud.com.example.app",
    tokenManager: StaticManagementToken(token: managementToken),
    environment: .development
)

// Export production schema
let productionService = try CloudKitSchemaService(
    containerIdentifier: "iCloud.com.example.app",
    tokenManager: StaticManagementToken(token: managementToken),
    environment: .production
)

let schema = try await productionService.exportSchema()
try schema.write(to: URL(fileURLWithPath: "schema.json"))

// Import to development
try await schemaService.importSchema(from: URL(fileURLWithPath: "schema.json"))

// In integration tests
let schemaService = try CloudKitSchemaService(
    containerIdentifier: containerID,
    tokenManager: EnvironmentManagementToken(),
    environment: .development
)

// Reset to clean state
try await schemaService.resetDevelopmentSchema()

// Import test schema
let testSchema = try CloudKitSchema.read(from: testSchemaURL)
try await schemaService.importSchema(testSchema)

// Run tests...

// Compare development vs production
let diff = try await schemaService.compareSchemas(
    source: .development,
    target: .production
)

if !diff.addedRecordTypes.isEmpty {
    print("New record types in development: \(diff.addedRecordTypes)")
}

// Define schema in Swift
let feedType = RecordTypeDefinition(
    name: "PublicFeed",
    fields: [
        FieldDefinition(name: "feedURL", type: .string, isIndexed: true),
        FieldDefinition(name: "title", type: .string),
        FieldDefinition(name: "lastAttempted", type: .date, isIndexed: true),
        FieldDefinition(name: "usageCount", type: .int64)
    ],
    indexes: [
        IndexDefinition(fieldName: "feedURL", indexType: .queryable),
        IndexDefinition(fieldName: "lastAttempted", indexType: .sortable)
    ]
)

try await schemaService.saveRecordType(feedType)