CloudKit tvOS xcode26.4 b2

#CloudKit.framework

diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAcceptSharesOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAcceptSharesOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAcceptSharesOperation.h	2025-11-09 04:37:40
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAcceptSharesOperation.h	2026-02-13 10:47:07
@@ -13,32 +13,114 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An operation that confirms a user's participation in a share.
+///
+/// Use this operation to accept participation in one or more shares. You create the operation with an array of share metadatas, which CloudKit provides to your app when the user taps or clicks a share's ``CKShare/url``. The method CloudKit calls varies by platform and app configuration. For more information, see ``CKShare/Metadata``. You can also fetch a share's metadata using ``CKFetchShareMetadataOperation``.
+///
+/// If there are several metadatas, group them by their ``CKShare/Metadata/containerIdentifier`` and create an operation for each container. Then add the operation to each container's operation queue to run it. The operation executes its callbacks on a private serial queue.
+///
+/// The operation calls ``perShareCompletionBlock`` once for each metadata you provide. CloudKit returns the metadata and its related share, or an error if it can't accept the share. CloudKit also batches per-metadata errors. If the operation completes with errors, it returns a ``CKError/partialFailure`` error. The error stores individual errors in its <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary. Use the ``CKPartialErrorsByItemIDKey`` key to extract them.
+///
+/// After CloudKit applies all record changes, the operation calls ``acceptSharesCompletionBlock``. When the closure executes, the server may continue processing residual tasks of the operation, such as creating the record zone in the user's private database.
+///
+/// The following example demonstrates how to accept a share that CloudKit provides to your window scene delegate. It shows how to create the operation, configure it, and execute it in the correct container:
+///
+/// ```swift
+/// func windowScene(_ windowScene: UIWindowScene,
+///     userDidAcceptCloudKitShareWith cloudKitShareMetadata: CKShare.Metadata) {
+///
+///     // Accept the share. If successful, schedule a fetch of the
+///     // share's root record.
+///     acceptShare(metadata: cloudKitShareMetadata) { [weak self] result in
+///         switch result {
+///         case .success(let recordID):
+///             self?.fetchRootRecordAndNotifyObservers(recordID)
+///         case .failure(let error):
+///             // Handle the error...
+///         }
+///     }
+/// }
+///
+/// func acceptShare(metadata: CKShare.Metadata,
+///     completion: @escaping (Result<CKRecord.ID, any Error>) -> Void) {
+///
+///     // Create a reference to the share's container so the operation
+///     // executes in the correct context.
+///     let container = CKContainer(identifier: metadata.containerIdentifier)
+///
+///     // Create the operation using the metadata the caller provides.
+///     let operation = CKAcceptSharesOperation(shareMetadatas: [metadata])
+///
+///     var rootRecordID: CKRecord.ID!
+///     // If CloudKit accepts the share, cache the root record's ID.
+///     // The completion closure handles any errors.
+///     operation.perShareCompletionBlock = { metadata, share, error in
+///         if let _ = share, error == nil {
+///             rootRecordID = hierarchicalRootRecordID
+///         }
+///     }
+///
+///     // If the operation fails, return the error to the caller.
+///     // Otherwise, return the record ID of the share's root record.
+///     operation.acceptSharesCompletionBlock = { error in
+///         if let error = error {
+///             completion(.failure(error))
+///         } else {
+///             completion(.success(rootRecordID))
+///         }
+///     }
+///
+///     // Set an appropriate QoS and add the operation to the
+///     // container's queue to execute it.
+///     operation.qualityOfService = .utility
+///     container.add(operation)
+/// }
+/// ```
 API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
 @interface CKAcceptSharesOperation : CKOperation
 
+/// Creates an operation for accepting shares.
+///
+/// You can use this operation only once.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for accepting the specified shares.
+///
+/// - Parameters:
+///   - shareMetadatas: The share metadatas to accept. If you specify `nil`, you must assign a value to the ``CKAcceptSharesOperation/shareMetadatas`` property before you execute the operation.
+///
+/// After initializing the operation, assign a handler to the ``CKAcceptSharesOperation/acceptSharesCompletionBlock`` property to process the results.
 - (instancetype)initWithShareMetadatas:(NSArray<CKShareMetadata *> *)shareMetadatas;
 
+/// The share metadatas to process.
+///
+/// Use this property to view or change the metadata of the shares you want to process. If you intend to specify or change the value of this property, do so before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) NSArray<CKShareMetadata *> *shareMetadatas;
 
-/*! @abstract Called once for each share metadata that the server processed
- *
- *  @discussion If error is nil then the share was successfully accepted.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The block to execute as CloudKit processes individual shares.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - The share metadata to process.
+/// - The share, or `nil` if CloudKit can't process the share metadata.
+/// - If CloudKit can't process the share metadata, this parameter provides information about the failure; otherwise, it's `nil`.
+///
+/// The operation executes this closure once for each element in the ``CKAcceptSharesOperation/shareMetadatas`` property. Each time the closure executes, it executes serially with respect to the other closures of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perShareCompletionBlock)(CKShareMetadata *shareMetadata, CKShare * _Nullable acceptedShare, NSError * _Nullable error)
 CK_SWIFT_DEPRECATED("Use perShareResultBlock instead", macos(10.12, 12.0), ios(10.0, 15.0), tvos(10.0, 15.0), watchos(3.0, 8.0));
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  If the error is @c CKErrorPartialFailure, the error's userInfo dictionary contains a dictionary of shareURLs to errors keyed off of @c CKPartialErrorsByItemIDKey.  These errors are repeats of those sent back in previous @c perShareCompletionBlock invocations
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when the operation finishes.
+///
+/// The closure returns no value and takes the following parameter:
+/// - An error that contains information about a problem, or `nil` if CloudKit successfully processes the shares.
+///
+/// The operation executes this closure only once. The closure executes on a background queue, so any tasks that require access to the main queue must dispatch accordingly.
+///
+/// The closure reports an error of type ``CKError/Code/partialFailure`` when it can't process some of the shares. The `userInfo` dictionary of the error contains a ``CKPartialErrorsByItemIDKey`` key that has a dictionary as its value. The keys of the dictionary are share URLs that CloudKit can't process, and the corresponding values are errors that contain information about the failures.
+///
+/// Set this property's value before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^acceptSharesCompletionBlock)(NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use acceptSharesResultBlock instead", macos(10.12, 12.0), ios(10.0, 15.0), tvos(10.0, 15.0), watchos(3.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAllowedSharingOptions.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAllowedSharingOptions.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAllowedSharingOptions.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAllowedSharingOptions.h	2026-02-13 10:47:07
@@ -11,49 +11,63 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An object that controls participant access options.
 typedef NS_OPTIONS(NSUInteger, CKSharingParticipantAccessOption) {
-    /*! If specified, the system sharing UI will allow the user to share publicly i.e. anyone with the link has access. */
+    /// The permission option the system uses to control whether a user can share publicly.
     CKSharingParticipantAccessOptionAnyoneWithLink = 1 << 0,
 
-    /*! If specified, the system sharing UI will allow the user to share privately to specified recipients. */
+    /// The permission option the system uses to control whether a user can share privately.
     CKSharingParticipantAccessOptionSpecifiedRecipientsOnly = 1 << 1,
 
-    /*! Allow the user to configure the share with either access option. */
+    /// The permission option the system uses to control whether a user can share publicly or privately.
     CKSharingParticipantAccessOptionAny = CKSharingParticipantAccessOptionAnyoneWithLink | CKSharingParticipantAccessOptionSpecifiedRecipientsOnly,
 } API_AVAILABLE(macos(13.0), ios(16.0)) API_UNAVAILABLE(tvos, watchos);
 
+/// An object that controls participant permission options.
 typedef NS_OPTIONS(NSUInteger, CKSharingParticipantPermissionOption) {
-    /*! If specified, the system sharing UI will allow the user to grant participants read-only permissions. */
+    /// The permission option the system uses to control whether a user can grant read-only access.
     CKSharingParticipantPermissionOptionReadOnly = 1 << 0,
 
-    /*! If specified, the system sharing UI will allow the user to grant participants read/write permissions. */
+    /// The permission option the system uses to control whether a user can grant write access.
     CKSharingParticipantPermissionOptionReadWrite = 1 << 1,
 
-    /*! Allow the user to configure added share participants with either permission option. */
+    /// The permission option the system uses to control whether a user can grant read-only or write access.
     CKSharingParticipantPermissionOptionAny = CKSharingParticipantPermissionOptionReadOnly | CKSharingParticipantPermissionOptionReadWrite,
 } API_AVAILABLE(macos(13.0), ios(16.0)) API_UNAVAILABLE(tvos, watchos);
 
+/// An object that controls participant access and permission options.
+///
+/// Register an instance of this class with an <doc://com.apple.documentation/documentation/foundation/nsitemprovider> or when preparing a ``CKShareTransferRepresentation/ExportedShare`` before your app invokes the share sheet. The share sheet uses the registered `CKAllowedSharingOptions` object to let the user choose between the allowed options when sharing.
 API_AVAILABLE(macos(13.0), ios(16.0))
 API_UNAVAILABLE(tvos, watchos)
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 // NS_SWIFT_SENDABLE on macos(13.3), macCatalyst(16.4), ios(16.4))
 @interface CKAllowedSharingOptions : NSObject <NSSecureCoding, NSCopying>
+
+/// Creates and initializes an allowed sharing options object.
+///
+/// - Parameters:
+///   - allowedParticipantPermissionOptions: The ``CKSharingParticipantPermissionOption`` setting.
+///   - allowedParticipantAccessOptions: The ``CKSharingParticipantAccessOption`` setting.
 - (instancetype)initWithAllowedParticipantPermissionOptions:(CKSharingParticipantPermissionOption)allowedParticipantPermissionOptions allowedParticipantAccessOptions:(CKSharingParticipantAccessOption)allowedParticipantAccessOptions;
 
+/// The permission option the system uses to control whether a user can grant read-only or write access.
 @property (assign) CKSharingParticipantPermissionOption allowedParticipantPermissionOptions;
+
+/// The permission option the system uses to control whether a user can share publicly or privately.
 @property (assign) CKSharingParticipantAccessOption allowedParticipantAccessOptions;
 
-/// Default value is `NO`. If set, the system sharing UI will allow the user to choose whether added participants can invite others to the share.
-/// Shares with ``CloudKit/CKShareParticipantRole/CKShareParticipantRoleAdministrator`` participants will be returned as read-only to devices running OS versions prior to this role being introduced.
-/// Administrator participants on these read-only shares will be returned as ``CloudKit/CKShareParticipantRole/CKShareParticipantRolePrivateUser``.
+/// Default value is NO. If set, the system sharing UI allows the user to choose whether added participants can invite others to the share.
+/// CloudKit returns shares with ``CKShare/ParticipantRole/administrator-enum.case`` participants as read-only to devices running OS versions prior to this role being introduced.
+/// CloudKit returns administrator participants on such read-only shares as ``CKShare/ParticipantRole/privateUser-enum.case``.
 @property (assign) BOOL allowsParticipantsToInviteOthers API_AVAILABLE(macos(26.0), ios(26.0), visionos(26.0)) API_UNAVAILABLE(tvos, watchos);
-/*!
- Standard allowed options are most permissive i.e. @c allowedParticipantPermissionOptions = @c CKSharingParticipantPermissionOptionAny
- and @c allowedParticipantAccessOptions = @c CKSharingParticipantAccessOptionAny
- */
+
+/// An object set to the most permissive sharing options.
+///
+/// The `standardOptions` has ``CKAllowedSharingOptions/allowedParticipantPermissionOptions`` set to ``CKSharingParticipantPermissionOption/any`` and ``CKAllowedSharingOptions/allowedParticipantAccessOptions`` set to ``CKSharingParticipantAccessOption/any``.
 @property (class, readonly, strong, nonatomic) CKAllowedSharingOptions *standardOptions;
 
-/// Default value is `NO`. If set, the system sharing UI will allow the user to configure whether access requests are enabled on the share.
+/// Default value is NO. If set, the system sharing UI allows the user to configure whether participants can request access to the share.
 @property (assign) BOOL allowsAccessRequests API_AVAILABLE(macos(26.0), ios(26.0), visionos(26.0)) API_UNAVAILABLE(tvos, watchos);
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAsset.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAsset.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAsset.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKAsset.h	2026-02-13 10:44:53
@@ -9,6 +9,19 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An external file that belongs to a record.
+///
+/// Use assets to incorporate external files into your app's records, such as photos, videos, and binary files. Alternatively, use assets when a field's value is more than a few kilobytes in size. To associate an instance of ``CKAsset`` with a record, assign it to one of its fields.
+///
+/// - Note: CloudKit stores only an asset's data. If you require its filename, or any other file-system metadata, use one or more separate fields on the record to store it.
+///
+/// CloudKit stores an asset's data separately from a record that references it, but maintains an association with that record. When you save a record that has an asset, CloudKit saves both the record and the asset to the server. Similarly, when you fetch the record, the server returns the record and the asset.
+///
+/// When you fetch a record that contains an asset, CloudKit stores the asset's data in a staging area accessible to your app. Use the asset's ``fileURL`` property to access its staged location. The system regularly deletes files in the staging area to reclaim disk space. To avoid this behavior, move the data into your app's container as soon as you fetch it.
+///
+/// If you don't require the asset when retrieving records, use the operation's `desiredKeys` property to exclude the field. For more information, see ``CKFetchRecordsOperation``, ``CKQueryOperation``, and ``CKFetchRecordZoneChangesOperation``.
+///
+/// If you no longer require an asset that's on the server, you don't delete it. Instead, orphan the asset by setting any fields that contain the asset to `nil` and then saving the record. CloudKit periodically deletes orphaned assets from the server.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 // This class should not be subclassed. If it is, Sendable may no longer apply.
 // NS_SWIFT_SENDABLE on macos(14.0), ios(17.0), tvos(17.0), watchos(10.0)
@@ -17,10 +30,25 @@
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
-/*! Initialize an asset to be saved with the content at the given file URL */
+/// Creates an asset that references a file.
+///
+/// - Parameters:
+///   - fileURL: The URL of the file that you want to store in CloudKit. You must provide a file URL, and it must not be `nil`.
+///
+/// - Returns: An asset object that represents the specified file.
+///
+/// Use this method to initialize new file-based assets that you want to transfer to iCloud. After saving an asset to the server, CloudKit doesn't delete the file at the specified URL. If you no longer need the file, you must delete it yourself. When you subsequently download a record that contains an asset, CloudKit downloads its own copy of the asset data to the local device and provides you with a URL to that file.
+///
+/// You can assign only one record to the asset that this method returns. If you want multiple records to point to the same file, you must create separate assets for each one.
+///
+/// - Important: CloudKit saves only the contents of the file and doesn't save the filename or any file-related metadata. To preserve the filename or any file-related metadata, save that data separately in the record.
 - (instancetype)initWithFileURL:(NSURL *)fileURL;
 
-/*! Local file URL where fetched records are cached and saved records originate from. */
+/// The URL for accessing the asset.
+///
+/// After you create an asset, use the URL in this property to access the asset's contents. The URL in this property is different from the one you specify when creating the asset.
+///
+/// - Note: If a modify operation fails with a ``CKError/serverRecordChanged`` error, CloudKit doesn't download assets for the copy of the server's record that's accessible using the error's ``CKError/serverRecord`` property. In this scenario, ``CKAsset/fileURL`` is `nil` for all of that record's asset fields.
 @property (nullable, readonly, copy) NSURL *fileURL;
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKContainer.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKContainer.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKContainer.h	2025-11-12 05:59:06
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKContainer.h	2026-02-13 10:50:37
@@ -15,20 +15,53 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-/*! Stand-in for the current user's ID; most often used in RecordZoneID->ownerName */
+/// A constant that provides the current user's default name.
 CK_EXTERN NSString * const CKCurrentUserDefaultName API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
+/// A constant that provides the default owner's name.
 CK_EXTERN NSString * const CKOwnerDefaultName API_DEPRECATED_WITH_REPLACEMENT("CKCurrentUserDefaultName", macos(10.10, 10.12), ios(8.0, 10.0), tvos(9.0, 10.0), watchos(3.0, 3.0));
 
-/*! @class CKContainer
- *
- *  @abstract A CKContainer, and its CKDatabases, are the main entry points into the CloudKit framework.
- *
- *  @discussion
- *  Several methods in CloudKit accept completion handlers to indicate when they're completed.
- *  All CKOperation subclasses include progress and completion blocks to report significant events in their lifecycles.
- *  Each of these handlers and blocks is invoked on a non-main serial queue.  The receiver is responsible for handling the message on a different queue or thread if it is required.
- */
+/// A conduit to your app's databases.
+///
+/// A container manages all explicit and implicit attempts to access its contents.
+///
+/// Every app has a default container that manages its own content. If you develop a suite of apps, you can access any containers that you have the appropriate entitlements for. Each new container distinguishes between public and private data. CloudKit always stores private data in the appropriate container directory in the user's iCloud account.
+///
+/// - Note: `CKContainer` instances operate with a <doc://com.apple.documentation/documentation/foundation/qualityofservice/userinitiated> quality of service level by default. For information about quality of service, see [Prioritize Work with Quality of Service Classes](https://developer.apple.com/library/archive/documentation/Performance/Conceptual/EnergyGuide-iOS/PrioritizeWorkWithQoS.html#//apple_ref/doc/uid/TP40015243-CH39) in [Energy Efficiency Guide for iOS Apps](https://developer.apple.com/library/archive/documentation/Performance/Conceptual/EnergyGuide-iOS/index.html#//apple_ref/doc/uid/TP40015243) and [Prioritize Work at the Task Level](https://developer.apple.com/library/archive/documentation/Performance/Conceptual/power_efficiency_guidelines_osx/PrioritizeWorkAtTheTaskLevel.html#//apple_ref/doc/uid/TP40013929-CH35) in [Energy Efficiency Guide for Mac Apps](https://developer.apple.com/library/archive/documentation/Performance/Conceptual/power_efficiency_guidelines_osx/index.html#//apple_ref/doc/uid/TP40013929).
+///
+/// ### Interacting with a Container
+///
+/// A container coordinates all interactions between your app and the server. Most of these interactions involve the following tasks:
+///
+/// - Determining whether the user has an iCloud account, which lets you know if you can write data to the user's personal storage.
+/// - With the user's permission, discovering other users who the current user knows, and making the current user's information discoverable.
+/// - Getting the container or one of its databases to use with an operation.
+///
+/// ### Public and Private Databases
+///
+/// Each container provides a public and a private database for storing data. The contents of the public database are accessible to all users of the app, whereas the contents of the private database are, by default, visible only to the current user. Content that is specific to a single user usually belongs in that user's private database, whereas app-related content that you provide (or that users want to share) belongs in the public database.
+///
+/// The public database is always available, regardless of whether the device has an active iCloud account. When there isn't an iCloud account, your app can fetch records from and query the public database, but it can't save changes. Saving records to the public database requires an active iCloud account to identify the owner of those records. Access to the private database always requires an active iCloud account on the device.
+///
+/// - Note: The data in a public database counts toward the iCloud storage quota of the app that owns the container. That data doesn't count toward the storage quota of any single user. Data in the private database counts toward the user's iCloud storage quota.
+///
+/// ### Using iCloud
+///
+/// Whenever possible, design your app to run gracefully with or without an active iCloud account. Even without an active iCloud account, apps can fetch records from the public database and display that information to the user. If your app requires the ability to write to the public database or requires access to the private database, notify the user of the reason and encourage them to enable iCloud. You can even provide a button that takes the user directly to Settings so that they can enable iCloud. To implement such a button, have the button's action open the URL that the <doc://com.apple.documentation/documentation/uikit/uiapplication/opensettingsurlstring> constant provides.
+///
+/// ### User Records and Permissions
+///
+/// When a user accesses a container for the first time, CloudKit assigns them a unique identifier and uses it to create two user records — one in the app's public database and another in that user's private database. By default, these records don't contain any identifying personal information, but you can use the record in the user's private database to store additional, nonsensitive information about that user. Because the public database's user record is accessible to all users of your app, don't use it to store information about the user.
+///
+/// While a user record isn't the same as the user's ``CKUserIdentity``, the identity does provide the identifier of their user record that you can use to fetch that record from either the public database or the user's private database. For more information, see ``CKUserIdentity/userRecordID``.
+///
+/// ### Testing Your Code Using the Development Container
+///
+/// At runtime, CloudKit uses your app's `com.apple.developer.icloud-container-environment` entitlement to discover whether you're using a `Development` or `Production` version of your provisioning profile. When you configure the entitlement for development, CloudKit configures the app's containers to use the development server. The development environment is a safe place to make changes during the development process without disrupting users of your app. You can add new fields to records programmatically, and you can delete or modify fields using iCloud Dashboard.
+///
+/// Before shipping your app, always test your app's behavior in the production environment. The production server generates errors when your app tries to add record types or add new fields to existing record types. Testing in the production environment helps you find and fix the places in your code where you're making those types of changes. You can use CloudKit Dashboard to modify record types in the development environment, and then migrate those changes to the production environment.
+///
+/// - Note: Simulator works only with the development environment. When you're ready to test your app in a production environment, do so from a device.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 // This class should not be subclassed. If it is, Sendable may no longer apply.
 NS_SWIFT_SENDABLE
@@ -37,168 +70,352 @@
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
-/*! @abstract Convenience method that uses the calling process' "iCloud.\(application-identifier)" as the container identifier
- *
- *  @discussion
- *  application-identifier is the calling process' @c application-identifier entitlement on iOS / tvOS / watchOS.
- *  application-identifier is the calling process' @c com.apple.application-identifier entitlement on macOS.
- *  On all OSes, if an @c com.apple.developer.associated-application-identifier entitlement is present, its value will be preferred over the @c application-identifier variants.
- */
+/// Returns the app's default container.
+///
+/// Use this method to retrieve your app's default container. This is the one you typically use to store your app's data. If you want the container for a different app, create a container using the ``CKContainer/init(identifier:)`` method.
+///
+/// During development, the container uses the development environment. When you release your app, the container uses the production environment.
 + (CKContainer *)defaultContainer;
 
-/*! @abstract Obtain a CKContainer for the given containerIdentifier
- *
- *  @discussion If the application is in production mode (aka, @c com.apple.developer.icloud-container-environment is set to Production in your entitlements plist, and you have no override in @c com.apple.developer.icloud-container-development-container-identifiers), then the production environment is used.
- */
+/// Creates a container for the specified identifier.
+///
+/// - Parameters:
+///   - containerIdentifier: The bundle identifier of the app with the container that you want to access. The bundle identifier must be in the app's `com.apple.developer.icloud-container-identifiers` entitlement. This parameter must not be `nil`.
+///
+/// The specified identifier must correspond to one of the containers in the iCloud capabilities section of your Xcode project. Including the identifier with your app's capabilities adds the corresponding entitlements to your app. To access your app's default container, use the ``CKContainer/default()`` method instead.
 + (CKContainer *)containerWithIdentifier:(NSString *)containerIdentifier;
 
+/// The container's unique identifier.
+///
+/// Use this property's value to distinguish different containers in your app.
 @property (nullable, readonly, copy, nonatomic) NSString *containerIdentifier;
 
+/// Adds an operation to the container's queue.
+///
+/// - Parameters:
+///   - operation: The operation to add to the queue. Make sure you fully configure the operation and have it ready to execute. Don't change the operation's configuration after you queue it.
+///
+/// This method adds the operation to a queue that the container manages. The queue's operations execute on background threads concurrently, and with default priorities. When you add an operation to the queue, its container becomes the current container.
 - (void)addOperation:(CKOperation *)operation;
 
 @end
 
-/*! @discussion
- *  Database properties:
- *  Records in a public database
- *  - By default are world readable, owner writable.
- *  - Can be locked down by Roles, a process done in the Developer Portal, a web interface.  Roles are not present in the client API.
- *  - Are visible to the application developer via the Developer Portal.
- *  - Do not contribute to the owner's iCloud account storage quota.
- *  Records in a private database
- *  - By default are only owner readable and owner writable.
- *  - Are not visible to the application developer via the Developer Portal.
- *  - Are counted towards the owner's iCloud account storage quota.
- *  Records in a shared database
- *  - Are available to share participants based on the permissions of the enclosing CKShare
- *  - Are not visible to the application developer via the Developer Portal.
- *  - Are counted towards the originating owner's iCloud account storage quota.
- */
 @interface CKContainer (Database)
 
+/// The user's private database.
+///
+/// The user's private database is only available if the device has an iCloud account. Only the user can access their private database, by default. They own all of the database's content and can view and modify that content. Data in the private database isn't visible in the developer portal.
+///
+/// Data in the private database counts toward the user's iCloud storage quota.
+///
+/// If there isn't an iCloud account on the user's device, this property still returns a database, but any attempt to use it results in an error. To determine if there is an iCloud account on the device, use the ``CKContainer/accountStatus(completionHandler:)`` method.
 @property (readonly, strong, nonatomic) CKDatabase *privateCloudDatabase;
+
+/// The app's public database.
+///
+/// This database is available regardless of whether the user's device has an iCloud account. The contents of the public database are readable by all users of the app, and users have write access to the records, and other objects, they create. The public database's contents are visible in the developer portal, where you can assign roles to users and restrict access as necessary.
+///
+/// Data in the public database counts toward your app's iCloud storage quota.
 @property (readonly, strong, nonatomic) CKDatabase *publicCloudDatabase;
+
+/// The database that contains shared data.
+///
+/// This database is only available if the device has an iCloud account. Permissions on the database are available only to the user according to the permissions of the enclosing ``CKShare`` instance, which represents the shared record. The current user doesn't own the content in the shared database, and can view and modify that content only if the necessary permissions exist. Data in the shared database isn't visible in the developer portal or to any user who doesn't have access.
+///
+/// Data in the shared database counts toward your app's iCloud storage quota.
+///
+/// If there isn't an iCloud account on the user's device, this property still returns a database, but any attempt to use it results in an error. To determine if there is an iCloud account on the device, use the ``CKContainer/accountStatus(completionHandler:)`` method.
 @property (readonly, strong, nonatomic) CKDatabase *sharedCloudDatabase API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
-/*! @abstract Convenience methods
- *
- *  @return a database that's pointer-equal to one of the above properties@enum 
- */
+/// Returns the database with the specified scope.
+///
+/// - Parameters:
+///   - databaseScope: The database's scope. See ``CKDatabase/Scope`` for the available options.
 - (CKDatabase *)databaseWithDatabaseScope:(CKDatabaseScope)databaseScope API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
 @end
 
-/*! @enum CKAccountStatus
- *  @constant CKAccountStatusCouldNotDetermine An error occurred when getting the account status, consult the corresponding NSError.
- *  @constant CKAccountStatusAvailable The iCloud account credentials are available for this application
- *  @constant CKAccountStatusRestricted Parental Controls / Device Management has denied access to iCloud account credentials
- *  @constant CKAccountStatusNoAccount No iCloud account is logged in on this device
- *  @constant CKAccountStatusTemporarilyUnavailable An iCloud account is logged in but not ready. The user can be asked to verify their
- *  credentials in Settings app.
- */
+/// Constants that indicate the availability of the user's iCloud account.
 typedef NS_ENUM(NSInteger, CKAccountStatus) {
+    /// CloudKit can't determine the status of the user's iCloud account.
     CKAccountStatusCouldNotDetermine                                                                      = 0,
+
+    /// The user's iCloud account is available.
     CKAccountStatusAvailable                                                                              = 1,
+
+    /// The system denies access to the user's iCloud account.
+    ///
+    /// Your app can't access the user's iCloud account due to restrictions that Parental Controls or Mobile Device Management impose.
     CKAccountStatusRestricted                                                                             = 2,
+
+    /// The device doesn't have an iCloud account.
     CKAccountStatusNoAccount                                                                              = 3,
+
+    /// The user's iCloud account is temporarily unavailable.
+    ///
+    /// You receive this account status when the user's iCloud account is available, but isn't ready to support CloudKit operations. Don't delete any cached data and don't enqueue any CloudKit operations after receipt of this account status. Instead, use the <doc://com.apple.documentation/documentation/foundation/nsnotification/name-swift.struct/ckaccountchanged> notification to listen for when the status changes to ``CKAccountStatus/available``.
     CKAccountStatusTemporarilyUnavailable API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) = 4
 } API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0));
 
-/*! @abstract This local notification is posted when there has been any change to the logged in iCloud account.
- *
- *  @discussion On receipt, an updated account status should be obtained by calling @c accountStatusWithCompletionHandler:
- */
+/// A notification that a container posts when the status of an iCloud account changes.
+///
+/// Create an instance of ``CKContainer`` to receive this notification. The container posts the notification using an arbitrary queue. Use the ``CKContainer/accountStatus(completionHandler:)`` method to obtain the account's status.
 CK_EXTERN NSString * const CKAccountChangedNotification API_AVAILABLE(macos(10.11), ios(9.0), watchos(3.0));
 
 @interface CKContainer (AccountStatus)
 
+/// Determines whether the system can access the user's iCloud account.
+///
+/// - Parameters:
+///   - completionHandler: The handler to execute when the call completes.
+///
+/// The closure has no return value and takes the following parameters:
+///
+/// - The status of the user's iCloud account.
+/// - An error that describes the failure, or `nil` if the system successfully determines the status.
+///
+/// This method determines the status of the user's iCloud account asynchronously, passing the results to the closure that you provide. Call this method before accessing the private database to determine whether that database is available. While your app is running, use the <doc://com.apple.documentation/documentation/foundation/nsnotification/name-swift.struct/ckaccountchanged> notification to detect account changes, and call this method again to determine the status of the new account.
 - (void)accountStatusWithCompletionHandler:(void (NS_SWIFT_SENDABLE ^)(CKAccountStatus accountStatus, NSError * _Nullable error))completionHandler;
 
 @end
 
+/// Constants that represent the permissions that a user grants.
 typedef NS_OPTIONS(NSUInteger, CKApplicationPermissions) {
-    /*! Allows the user's record in CloudKit to be discoverable via the user's email address */
+    /// The user is discoverable using their email address.
     CKApplicationPermissionUserDiscoverability API_DEPRECATED("No longer supported. Please see Sharing CloudKit Data with Other iCloud Users.", macos(10.0, 14.0), ios(8.0, 17.0), tvos(9.0, 17.0), watchos(3.0, 10.0)) = 1 << 0,
 } API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0));
 
-/*! @enum CKApplicationPermissionStatus
- *  @constant CKApplicationPermissionStatusInitialState The user has not made a decision for this application permission.
- *  @constant CKApplicationPermissionStatusCouldNotComplete An error occurred when getting or setting the application permission status, consult the corresponding NSError
- *  @constant CKApplicationPermissionStatusDenied The user has denied this application permission
- *  @constant CKApplicationPermissionStatusGranted The user has granted this application permission
- */
+/// Constants that represent the status of a permission.
 typedef NS_ENUM(NSInteger, CKApplicationPermissionStatus) {
+    /// The app is yet to request the permission.
     CKApplicationPermissionStatusInitialState          = 0,
+
+    /// An error that occurs while processing the permission request.
     CKApplicationPermissionStatusCouldNotComplete      = 1,
+
+    /// The user denies the permission.
     CKApplicationPermissionStatusDenied                = 2,
+
+    /// The user grants the permission.
     CKApplicationPermissionStatusGranted               = 3,
 } API_DEPRECATED("No longer supported. Please see Sharing CloudKit Data with Other iCloud Users.", macos(10.10, 14.0), ios(8.0, 17.0), tvos(9.0, 17.0), watchos(3.0, 10.0));
 
+/// A closure that processes the outcome of a permissions request.
+///
+/// When you request or determine the status of a permission, use this closure to process the result. The closure has no return value and takes the following parameters:
+///
+/// - The permission's status. For a list of possible values, see ``CKContainer/ApplicationPermissionStatus``.
+/// - An error if the system can't fulfill the request, or `nil` if it successfully determines the status.
 typedef void (^CKApplicationPermissionBlock)(CKApplicationPermissionStatus applicationPermissionStatus, NSError * _Nullable error) API_DEPRECATED("No longer supported. Please see Sharing CloudKit Data with Other iCloud Users.", macos(10.10, 14.0), ios(8.0, 17.0), tvos(9.0, 17.0), watchos(3.0, 10.0));
 
 @interface CKContainer (ApplicationPermission)
 
+/// Determines the authorization status of the specified permission.
+///
+/// - Parameters:
+///   - applicationPermission: The permission to check. For a list of possible values, see ``CKContainer/ApplicationPermissions``.
+///   - completionHandler: The handler to execute with the outcome.
+///
+/// Use this method to determine the extra capabilities that the user grants to your app. If your app doesn't have a specific permission, calling this method yields ``CKContainer/ApplicationPermissionStatus/initialState``. In response, call the ``CKContainer/requestApplicationPermission:completionHandler:`` method to prompt the user to provide their permission.
 - (void)statusForApplicationPermission:(CKApplicationPermissions)applicationPermission completionHandler:(NS_SWIFT_SENDABLE CKApplicationPermissionBlock)completionHandler NS_SWIFT_ASYNC_NAME(applicationPermissionStatus(for:)) API_DEPRECATED("No longer supported. Please see Sharing CloudKit Data with Other iCloud Users.", macos(10.0, 14.0), ios(8.0, 17.0), tvos(9.0, 17.0), watchos(3.0, 10.0));
+
+/// Prompts the user to authorize the specified permission.
+///
+/// - Parameters:
+///   - applicationPermission: The permission to request. This permission applies only to the current container. For a list of possible values, see ``CKContainer/ApplicationPermissions``.
+///   - completionHandler: The handler to execute with the outcome.
+///
+/// To implement social features in your app, it's possible to correlate a user record with the user's actual name, but your app must get permission from the user to do so. Making a user record discoverable to the contacts of that user involves calling the ``CKContainer/requestApplicationPermission:completionHandler:`` method and asking for the ``CKContainer/ApplicationPermissions/userDiscoverability`` permission. When you call that method, CloudKit asks the user whether the user record can become discoverable. If the user grants the request, that user's contacts can discover that user's true identity when running the app. To discover the contacts of the current user, you use the `discoverAllContactUserInfos(completionHandler:)` method or one of several other methods to get the related user information.
+///
+/// The first time you request a permission on any of the user's devices, the user receives a prompt to grant or deny the request. After the user grants or denies a permission, subsequent requests for the same permission (on the same or separate devices), don't prompt the user again.
+///
+/// This method runs asynchronously, and the system calls your completion handler on an arbitary queue and provides the outcome.
 - (void)requestApplicationPermission:(CKApplicationPermissions)applicationPermission completionHandler:(NS_SWIFT_SENDABLE CKApplicationPermissionBlock)completionHandler API_DEPRECATED("No longer supported. Please see Sharing CloudKit Data with Other iCloud Users.", macos(10.0, 14.0), ios(8.0, 17.0), tvos(9.0, 17.0), watchos(3.0, 10.0));
 
 @end
 
 @interface CKContainer (UserRecords)
 
-/*! @discussion If there is no iCloud account configured, or if access is restricted, a @c CKErrorNotAuthenticated error will be returned.
- *
- *  This work is treated as having @c NSQualityOfServiceUserInitiated quality of service.
- */
+/// Fetches the user record ID of the current user.
+///
+/// - Parameters:
+///   - completionHandler: The handler to execute with the fetch results.
+///
+/// The closure doesn't return a value and takes the following parameters:
+///   - The user record ID, or `nil` if the user disables iCloud or the device doesn't have an iCloud account.
+///   - An error if a problem occurs, or `nil` if CloudKit successfully retrieves the user record ID.
+///
+/// CloudKit returns a ``CKError/Code/notAuthenticated`` error when any of the following conditions are met:
+/// - The device has an iCloud account but the user disables iCloud.
+/// - The device has an iCloud account with restricted access.
+/// - The device doesn't have an iCloud account.
+///
+/// - Note: At startup, fetching the user record ID may take longer while CloudKit makes the initial iCloud account request. After the initial fetch, accessing the ID generally takes less time.
 - (void)fetchUserRecordIDWithCompletionHandler:(void (NS_SWIFT_SENDABLE ^)(CKRecordID * _Nullable recordID, NSError * _Nullable error))completionHandler NS_SWIFT_ASYNC_NAME(userRecordID());
 
-/*! @abstract Fetches all user identities that match an entry in the user's contacts database.
- *
- *  @discussion @c CKDiscoverAllUserIdentitiesOperation is the more configurable, @c CKOperation -based alternative to this methods
- */
+/// Fetches all user identities that match entries in the user's Contacts.
+///
+/// - Parameters:
+///   - completionHandler: The handler to execute with the fetch results.
+///
+/// The closure doesn't return a value and takes the following parameters:
+///
+/// - The user identities that match entries in the user's Contacts.
+/// - An error if a problem occurs, or `nil` if the system successfully completes the request.
+///
+/// This method searches for the users asynchronously and with a low priority. If you want the task to execute with a higher priority, create an instance of ``CKDiscoverAllUserIdentitiesOperation`` and configure it to use the necessary priority.
 - (void)discoverAllIdentitiesWithCompletionHandler:(void (NS_SWIFT_SENDABLE ^)(NSArray<CKUserIdentity *> * _Nullable userIdentities, NSError * _Nullable error))completionHandler NS_SWIFT_ASYNC_NAME(allUserIdentitiesFromContacts()) API_DEPRECATED("No longer supported. Please see Sharing CloudKit Data with Other iCloud Users.", macos(10.12, 14.0), ios(10.0, 17.0), watchos(3.0, 10.0)) API_UNAVAILABLE(tvos);
 
-/*! @abstract Fetches the user identity that corresponds to the given email address.
- *
- *  @discussion Only users who have opted-in to user discoverability will have their identities returned by this method.  If a user with the inputted email exists in iCloud, but has not opted-in to user discoverability, this method completes with a nil @c userInfo.  @c CKDiscoverUserIdentitiesOperation is the more configurable, @c CKOperation -based alternative to this method
- */
+/// Fetches the user identity for the specified email address.
+///
+/// - Parameters:
+///   - email: The user's email address.
+///   - completionHandler: The handler to execute with the fetch results.
+///
+/// This closure doesn't return a value and takes the following parameters:
+///
+/// - The user identity for the email address, or `nil` if CloudKit can't find an identity.
+/// - An error if a problem occurs, or `nil` if CloudKit successfully fetches a user identity.
+///
+/// Use this method to retrieve the identity of a user who the current user knows. The user you're searching for must meet the following criteria:
+/// - The user has run the app.
+/// - The user grants the ``CKContainer/ApplicationPermissions/userDiscoverability`` permission for the container.
+///
+/// This method searches for the user asynchronously and with a low priority. If you want the task to execute the request with a higher priority, create an instance of ``CKDiscoverUserIdentitiesOperation`` and configure it to use the necessary priority.
 - (void)discoverUserIdentityWithEmailAddress:(NSString *)email completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKUserIdentity * _Nullable_result userInfo, NSError * _Nullable error))completionHandler NS_SWIFT_ASYNC_NAME(userIdentity(forEmailAddress:)) API_DEPRECATED("No longer supported. Please see Sharing CloudKit Data with Other iCloud Users.", macos(10.12, 14.0), ios(10.0, 17.0), tvos(10.0, 17.0), watchos(3.0, 10.0));
 
-/*! @abstract Fetches the user identity that corresponds to the given phone number.
- *
- *  @discussion Only users who have opted-in to user discoverability will have their identities returned by this method.  If a user with the inputted phone number exists in iCloud, but has not opted-in to user discoverability, this method completes with a nil @c userInfo.  @c CKDiscoverUserIdentitiesOperation is the more configurable, @c CKOperation -based alternative to this method
- */
+/// Fetches the user identity for the specified phone number.
+///
+/// - Parameters:
+///   - phoneNumber: The user's phone number.
+///   - completionHandler: The handler to execute with the fetch results.
+///
+/// This closure doesn't return a value and takes the following parameters:
+///
+/// - The user identity for the phone number, or `nil` if CloudKit can't find an identity.
+/// - An error if a problem occurs, or `nil` if CloudKit successfully fetches a user identity.
+///
+/// Use this method to retrieve the identity of a user who the current user knows. The user you're searching for must meet the following criteria:
+/// - The user has run the app.
+/// - The user grants the ``CKContainer/ApplicationPermissions/userDiscoverability`` permission for the container.
+///
+/// This method searches for the user asynchronously and with a low priority. If you want the task to execute the request with a higher priority, create an instance of ``CKDiscoverUserIdentitiesOperation`` and configure it to use the necessary priority.
 - (void)discoverUserIdentityWithPhoneNumber:(NSString *)phoneNumber completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKUserIdentity * _Nullable_result userInfo, NSError * _Nullable error))completionHandler NS_SWIFT_ASYNC_NAME(userIdentity(forPhoneNumber:)) API_DEPRECATED("No longer supported. Please see Sharing CloudKit Data with Other iCloud Users.", macos(10.12, 14.0), ios(10.0, 17.0), tvos(10.0, 17.0), watchos(3.0, 10.0));
 
-/*! @abstract Fetches the user identity that corresponds to the given user record id.
- *
- *  @discussion Only users who have opted-in to user discoverability will have their identities returned by this method.  If a user has not opted-in to user discoverability, this method completes with a nil @c userInfo.  @c CKDiscoverUserIdentitiesOperation is the more configurable, @c CKOperation -based alternative to this method
- */
+/// Fetches the user identity for the specified user record ID.
+///
+/// - Parameters:
+///   - userRecordID: The user record's ID.
+///   - completionHandler: The handler to execute with the fetch results.
+///
+/// This closure doesn't return a value and takes the following parameters:
+///
+/// - The user identity for the user record ID, or `nil` if CloudKit can't find an identity.
+/// - An error if a problem occurs, or `nil` if CloudKit successfully fetches a user identity.
+///
+/// Use this method to retrieve the identity of a user who you already have a user record ID for. The user you're searching for must meet the following criteria:
+/// - The user has run the app.
+/// - The user grants the ``CKContainer/ApplicationPermissions/userDiscoverability`` permission for the container.
+///
+/// This method searches for the user asynchronously and with a low priority. If you want the task to execute the request with a higher priority, create an instance of ``CKDiscoverUserIdentitiesOperation`` and configure it to use the necessary priority.
 - (void)discoverUserIdentityWithUserRecordID:(CKRecordID *)userRecordID completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKUserIdentity * _Nullable_result userInfo, NSError * _Nullable error))completionHandler NS_SWIFT_ASYNC_NAME(userIdentity(forUserRecordID:)) API_DEPRECATED("No longer supported. Please see Sharing CloudKit Data with Other iCloud Users.", macos(10.12, 14.0), ios(10.0, 17.0), tvos(10.0, 17.0), watchos(3.0, 10.0));
 
 @end
 
 @interface CKContainer (Sharing)
 
-/*! @abstract Fetches share participants matching the provided info.
- *
- *  @discussion @c CKFetchShareParticipantsOperation is the more configurable, @c CKOperation -based alternative to these methods.
- */
+/// Fetches the share participant with the specified email address.
+///
+/// - Parameters:
+///   - emailAddress: The share participant's email address.
+///   - completionHandler: The handler to execute with the fetch results.
+///
+/// The closure doesn't return a value and takes the following parameters:
+///   - The share participant, or `nil` if CloudKit can't find the participant.
+///   - An error if a problem occurs, or `nil` if CloudKit successfully retrieves the participant.
+///
+/// CloudKit can translate any valid email address into a share participant.  If the email address doesn't correspond to a known iCloud account, then at share-accept-time, CloudKit offers the accepting participant a vetting process. The accepting participant uses this vetting process to link the email address to an iCloud account.
+///
+/// This method searches for the share participant asynchronously and with a low priority. If you want the task to execute with a higher priority, create an instance of ``CKFetchShareParticipantsOperation`` and configure it to use the necessary priority.
 - (void)fetchShareParticipantWithEmailAddress:(NSString *)emailAddress completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKShareParticipant * _Nullable shareParticipant, NSError * _Nullable error))completionHandler API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) NS_SWIFT_ASYNC_NAME(shareParticipant(forEmailAddress:));
+
+/// Fetches the share participant with the specified phone number.
+///
+/// - Parameters:
+///   - phoneNumber: The share participant's phone number.
+///   - completionHandler: The handler to execute with the fetch results.
+///
+/// The closure doesn't return a value and takes the following parameters:
+///   - The share participant, or `nil` if CloudKit can't find the participant.
+///   - An error if a problem occurs, or `nil` if CloudKit successfully retrieves the participant.
+///
+/// CloudKit can translate any valid phone number into a share participant.  If the phone number doesn't correspond to a known iCloud account, then at share-accept-time, CloudKit offers the accepting participant a vetting process. The accepting participant uses this vetting process to link the phone number to an iCloud account.
+///
+/// This method searches for the share participant asynchronously and with a low priority. If you want the task to execute with a higher priority, create an instance of ``CKFetchShareParticipantsOperation`` and configure it to use the necessary priority.
 - (void)fetchShareParticipantWithPhoneNumber:(NSString *)phoneNumber completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKShareParticipant * _Nullable shareParticipant, NSError *_Nullable error))completionHandler API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) NS_SWIFT_ASYNC_NAME(shareParticipant(forPhoneNumber:));
+
+/// Fetches the share participant with the specified user record ID.
+///
+/// - Parameters:
+///   - userRecordID: The share participant's user record ID.
+///   - completionHandler: The handler to execute with the fetch results.
+///
+/// The closure doesn't return a value and takes the following parameters:
+///   - The share participant, or `nil` if CloudKit can't find the participant.
+///   - An error if a problem occurs, or `nil` if CloudKit successfully retrieves the participant.
+///
+/// This method searches for the share participant asynchronously and with a low priority. If you want the task to execute with a higher priority, create an instance of ``CKFetchShareParticipantsOperation`` and configure it to use the necessary priority.
 - (void)fetchShareParticipantWithUserRecordID:(CKRecordID *)userRecordID completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKShareParticipant *_Nullable shareParticipant, NSError *_Nullable error))completionHandler API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) NS_SWIFT_ASYNC_NAME(shareParticipant(forUserRecordID:));
 
+/// Fetches the share metadata for the specified share URL.
+///
+/// - Parameters:
+///   - url: The share URL that CloudKit uses to locate the metadata.
+///   - completionHandler: The handler to execute with the fetch results.
+///
+/// The closure doesn't return a value and takes the following parameters:
+///   - The share metadata, or `nil` if CloudKit can't find the metadata.
+///   - An error if a problem occurs, or `nil` if CloudKit successfully retrieves the metadata.
 - (void)fetchShareMetadataWithURL:(NSURL *)url completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKShareMetadata *_Nullable metadata, NSError * _Nullable error))completionHandler API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) NS_SWIFT_ASYNC_NAME(shareMetadata(for:));
+
+/// Accepts the specified share metadata.
+///
+/// - Parameters:
+///   - metadata: The metadata of the share to accept.
+///   - completionHandler: The handler to execute when the process finishes.
+///
+/// The closure doesn't return a value and takes the following parameters:
+///
+/// - The corresponding share, or `nil` if CloudKit can't accept the metadata.
+/// - An error if a problem occurs, or `nil` if CloudKit successfully accepts the metadata.
 - (void)acceptShareMetadata:(CKShareMetadata *)metadata completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKShare *_Nullable acceptedShare, NSError *_Nullable error))completionHandler API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
 @end
 
 @interface CKContainer (CKLongLivedOperations)
-/*! @discussion Long lived CKOperations returned by this call must be started on an operation queue.
- *  Remember to set the callback blocks before starting the operation.
- *  If an operation has already completed against the server, and is subsequently resumed, that operation will replay all of its callbacks from the start of the operation, but the request will not be re-sent to the server.
- *  If a long lived operation is cancelled or finishes completely it is no longer returned by these calls.
- */
+/// Fetches the IDs of any long-lived operations that are running.
+///
+/// - Parameters:
+///   - completionHandler: The block doesn't return a value and takes the following parameters:
+///
+///     - term `outstandingOperationsByIDs`: The IDs of all of the long-lived operations that are running.
+///     - term `error`: An error if a problem occurs, or `nil` if CloudKit successfully retrieves the IDs.
+///
+/// A long-lived operation is one that continues to run after the user closes the app. When a long-lived operation completes, or your app or the system cancels it, it's no longer active and CloudKit doesn't include its ID in `outstandingOperationsByIDs`. An operation is complete when the system calls its completion handler.
+///
+/// Use the ``CKContainer/fetchLongLivedOperationWithID:completionHandler:`` method to fetch the operation for a specific ID.
 - (void)fetchAllLongLivedOperationIDsWithCompletionHandler:(void (NS_SWIFT_SENDABLE ^)(NSArray<CKOperationID> * _Nullable outstandingOperationIDs, NSError * _Nullable error))completionHandler API_AVAILABLE(macos(10.12), ios(9.3), tvos(9.2), watchos(3.0)) NS_REFINED_FOR_SWIFT_ASYNC(1);
+
+/// Fetches the long-lived operation for the specified operation ID.
+///
+/// - Parameters:
+///   - operationID: The operation's ID.
+///   - completionHandler: The block doesn't return a value and takes the following parameters:
+///
+///     - term `outstandingOperation`: The long-lived operation. If the operation completes, or your app or the system cancels it, this parameter is `nil`.
+///     - term `error`: An error if a problem occurs, or `nil` if CloudKit successfully retrieves the operation.
+///
+/// A long-lived operation is one that continues to run after the user closes your app. When a long-lived operation completes, the system calls its completion block to notify you.
 - (void)fetchLongLivedOperationWithID:(CKOperationID)operationID completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKOperation * _Nullable_result outstandingOperation, NSError * _Nullable error))completionHandler API_AVAILABLE(macos(10.12), ios(9.3), tvos(9.2), watchos(3.0)) NS_REFINED_FOR_SWIFT_ASYNC(2);
 @end
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDatabase.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDatabase.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDatabase.h	2025-11-09 04:22:01
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDatabase.h	2026-02-13 09:49:23
@@ -13,58 +13,280 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// Constants that represent the scope of a database.
 typedef NS_ENUM(NSInteger, CKDatabaseScope) {
+    /// The public database.
+    ///
+    /// Records in a public database:
+    ///
+    /// - By default are world readable, owner writable.
+    /// - Can be locked down by Roles, a process done in the Developer Portal, a web interface.  Roles are not present in the client API.
+    /// - Are visible to the application developer via the Developer Portal.
+    /// - Do not contribute to the owner's iCloud account storage quota.
     CKDatabaseScopePublic = 1,
+
+    /// The private database.
+    ///
+    /// Records in a private database:
+    ///
+    /// - By default are owner readable and owner writable.
+    /// - Are not visible to the application developer via the Developer Portal.
+    /// - Are counted towards the owner's iCloud account storage quota.
     CKDatabaseScopePrivate,
+
+    /// The shared database.
+    ///
+    /// Records in a shared database:
+    ///
+    /// - Are available to share participants based on the permissions of the enclosing ``CKShare``
+    /// - Are not visible to the application developer via the Developer Portal.
+    /// - Are counted towards the originating owner's iCloud account storage quota.
     CKDatabaseScopeShared,
 } API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
+/// An object that represents a collection of record zones and subscriptions.
+///
+/// A database takes requests and operations and applies them to the objects it contains, whether that's record zones, records, or subscriptions. Each of your app's users has access to the three separate databases:
+///
+/// - A public database that's accessible to all users of your app.
+/// - A private database that's accessible only to the user of the current device.
+/// - A shared database that's accessible only to the user of the current device, which contains records that other iCloud users share with them.
+///
+/// The public database is always available, even when the device doesn't have an active iCloud account. In this scenario, your app can fetch specific records and perform searches, but it can't create or modify records. CloudKit requires an iCloud account for writing to the public database so it can identify the authors of any changes. All access to the private and shared databases requires an iCloud account.
+///
+/// You don't create instances of ``CKDatabase``, nor do you subclass it. Instead, you access the required database using one of your app's containers. For more information, see ``CKContainer``.
+///
+/// By default, CloudKit executes the methods in this class with a low-priority quality of service (QoS). To use a higher-priority QoS, perform the following:
+///
+/// 1. Create an instance of ``CKOperation/Configuration`` and set its ``CKOperation/Configuration/qualityOfService`` property to the preferred value.
+/// 2. Call the databaseʼs ``configuredWith(configuration:group:body:)-637p1`` method and provide the configuration and a trailing closure.
+/// 3. In the closure, use the provided database to execute the relevant methods at the preferred QoS.
+///
+/// ```swift
+/// func fetchRecords(
+///     with ids: [CKRecord.ID]
+/// ) async throws -> [CKRecord.ID: Result<CKRecord, any Error>] {
+///
+///     // Get a reference to the user's private database.
+///     let database = CKContainer.default().privateCloudDatabase
+///
+///     // Create a configuration with a higher-priority quality of service.
+///     let config = CKOperation.Configuration()
+///     config.qualityOfService = .userInitiated
+///
+///     // Configure the database and execute the fetch.
+///     return try await database.configuredWith(configuration: config) { db in
+///         try await db.records(for: ids)
+///     }
+/// }
+/// ```
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 // This class should not be subclassed. If it is, Sendable may no longer apply.
 NS_SWIFT_SENDABLE
 @interface CKDatabase : NSObject
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
+
+/// Executes the specified operation in the current database.
+///
+/// - Parameters:
+///   - operation: The operation to execute.
+///
+/// Configure the operation fully before you call this method. Prior to the operation executing, CloudKit sets its ``CKDatabaseOperation/database`` property to the current database. The operation executes at the priority and quality of service (QoS) that you specify using the <doc://com.apple.documentation/documentation/foundation/operation/queuepriority-swift.property> and <doc://com.apple.documentation/documentation/foundation/operation/qualityofservice> properties.
 - (void)addOperation:(CKDatabaseOperation *)operation;
+
+/// The type of database.
+///
+/// For possible values, see ``CKDatabase/Scope``.
 @property (readonly, assign, nonatomic) CKDatabaseScope databaseScope API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 @end
 
-/*! @abstract Convenience APIs
+/*  Convenience APIs
  *
- *  @discussion These calls operate on a single item in the default zone and allow for simple operations.
- *  If you'd like to batch your requests, add dependencies between requests, set priorities, or schedule operations on your own queue, take a look at the corresponding @c CKOperation.
- *  This work is treated as having @c NSQualityOfServiceUserInitiated quality of service.
+ *  These calls operate on a single item in the default zone and allow for simple operations.
+ *  If you'd like to batch your requests, add dependencies between requests, set priorities, or schedule operations on your own queue, take a look at the corresponding CKOperation.
+ *  CloudKit treats this work as having NSQualityOfServiceUserInitiated quality of service.
  */
 @interface CKDatabase (ConvenienceMethods)
 
 #pragma mark - Record Convenience Methods
-/*! @c CKFetchRecordsOperation and @c CKModifyRecordsOperation are the more configurable, @c CKOperation -based alternatives to these methods */
+
+/// Fetches a specific record.
+///
+/// - Parameters:
+///   - recordID: The identifier of the record to fetch.
+///   - completionHandler: The closure to execute with the fetch results.
+///
+/// The completion handler takes the following parameters:
+///
+/// - The requested record, or `nil` if CloudKit can't provide that record.
+/// - An error if a problem occurs, or `nil` if the fetch completes successfully.
+///
+/// For information on a more convenient way to fetch specific records, see ``CKDatabase/records(for:desiredKeys:)``.
 - (void)fetchRecordWithID:(CKRecordID *)recordID completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKRecord * _Nullable record, NSError * _Nullable error))completionHandler NS_SWIFT_ASYNC_NAME(record(for:));
+
+/// Saves a specific record.
+///
+/// - Parameters:
+///   - record: The record to save.
+///   - completionHandler: The closure to execute after CloudKit saves the record.
+///
+/// The completion handler takes the following parameters:
+///
+/// - The saved record (as it appears on the server), or `nil` if there's an error.
+/// - An error if a problem occurs, or `nil` if CloudKit successfully saves the record.
+///
+/// The save succeeds only when the specified record is new, or is a more recent version than the one on the server.
+///
+/// For information on a more convenient way to save records, see ``CKDatabase/modifyRecords(saving:deleting:savePolicy:atomically:)``.
 - (void)saveRecord:(CKRecord *)record completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKRecord * _Nullable record, NSError * _Nullable error))completionHandler;
+
+/// Deletes a specific record.
+///
+/// - Parameters:
+///   - recordID: The identifier of the record to delete.
+///   - completionHandler: The closure to execute after CloudKit deletes the record.
+///
+/// The completion handler takes the following parameters:
+///
+/// - The identifier of the deleted record, or `nil` if there's an error.
+/// - An error if a problem occurs, or `nil` if CloudKit successfully deletes the record.
+///
+/// Deleting a record may cause additional deletions if other records in the database reference the deleted record. CloudKit doesn't provide the identifiers of any additional records it deletes.
+///
+/// For information on a more convenient way to delete records, see ``CKDatabase/modifyRecords(saving:deleting:savePolicy:atomically:)``.
 - (void)deleteRecordWithID:(CKRecordID *)recordID completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKRecordID * _Nullable recordID, NSError * _Nullable error))completionHandler NS_SWIFT_ASYNC_NAME(deleteRecord(withID:));
 
 #pragma mark - Query Convenience Method
-/*! @discussion @c CKQueryOperation is the more configurable, @c CKOperation -based alternative to this method
- *  Queries can potentially return a large number of records, and the server will return those records in batches. This convenience API will only fetch the first batch of results (equivalent to using @c CKQueryOperationMaximumResults).
- *  If you would like to fetch all results, use @c CKQueryOperation and its @c CKQueryCursor instead.
- *  Queries invoked within a @c sharedCloudDatabase must specify a @c zoneID.  Cross-zone queries are not supported in a @c sharedCloudDatabase
- *  Queries that do not specify a @c zoneID will perform a query across all zones in the database.
- */
+
+/// Searches for records matching a predicate in the specified record zone.
+///
+/// - Parameters:
+///   - query: The query that contains the search parameters. For more information, see ``CKQuery``.
+///   - zoneID: The identifier of the record zone to search. If you're searching a shared database, provide a record zone identifier; otherwise, you can specify `nil` to search all record zones in the database.
+///   - completionHandler: The closure to execute with the search results.
+///
+/// The completion handler takes the following parameters:
+/// 
+/// - The records that match the specified query, or `nil` if there's an error.
+/// - An error if a problem occurs, or `nil` if CloudKit completes the search successfully.
+///
+/// For information on a more convenient way to search a database, see ``CKDatabase/records(matching:inZoneWith:desiredKeys:resultsLimit:)``.
 - (void)performQuery:(CKQuery *)query inZoneWithID:(nullable CKRecordZoneID *)zoneID completionHandler:(void (NS_SWIFT_SENDABLE ^)(NSArray<CKRecord *> * _Nullable results, NSError * _Nullable error))completionHandler
 CK_SWIFT_DEPRECATED("renamed to fetch(withQuery:inZoneWith:desiredKeys:resultsLimit:completionHandler:)", macos(10.10, 12.0), ios(8.0, 15.0), tvos(9.0, 15.0), watchos(3.0, 8.0));
 
 #pragma mark - Record Zone Convenience Methods
-/*! @c CKFetchRecordZonesOperation and @c CKModifyRecordZonesOperation are the more configurable, @c CKOperation -based alternatives to these methods */
+
+/// Fetches all record zones from the current database.
+///
+/// - Parameters:
+///   - completionHandler: The closure to execute with the fetch results.
+///
+/// The completion handler takes the following parameters:
+///
+/// - An array of fetched record zones, or `nil` if there's an error. When present, the array contains at least one record zone, the default zone.
+/// - An error if a problem occurs, or `nil` if CloudKit successfully fetches all record zones.
 - (void)fetchAllRecordZonesWithCompletionHandler:(void (NS_SWIFT_SENDABLE ^)(NSArray<CKRecordZone *> * _Nullable zones, NSError * _Nullable error))completionHandler NS_SWIFT_ASYNC_NAME(allRecordZones());
+
+/// Fetches a specific record zone.
+///
+/// - Parameters:
+///   - zoneID: The identifier of the record zone to fetch.
+///   - completionHandler: The closure to execute with the fetch results.
+///
+/// The completion handler takes the following parameters:
+///
+/// - The fetched record zone, or `nil` if there's an error.
+/// - An error if a problem occurs, or `nil` if CloudKit successfully fetches the specified record zone.
+///
+/// For information on a more convenient way to fetch specific record zones, see ``CKDatabase/recordZones(for:)`` in Swift or ``CKFetchRecordZonesOperation`` in Objective-C.
 - (void)fetchRecordZoneWithID:(CKRecordZoneID *)zoneID completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKRecordZone * _Nullable zone, NSError * _Nullable error))completionHandler NS_SWIFT_ASYNC_NAME(recordZone(for:));
+
+/// Saves a specific record zone.
+///
+/// - Parameters:
+///   - zone: The record zone to save.
+///   - completionHandler: The closure to execute after CloudKit saves the record.
+///
+/// The completion handler takes the following parameters:
+///
+/// - The saved record zone (as it appears on the server), or `nil` if there's an error.
+/// - An error if a problem occurs, or `nil` if CloudKit successfully saves the record zone.
+///
+/// For information on a more convenient way to save record zones, see ``CKDatabase/modifyRecordZones(saving:deleting:)``.
 - (void)saveRecordZone:(CKRecordZone *)zone completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKRecordZone * _Nullable zone, NSError * _Nullable error))completionHandler;
+
+/// Deletes a specific record zone.
+///
+/// - Parameters:
+///   - zoneID: The identifier of the record zone to delete.
+///   - completionHandler: The closure to execute after CloudKit deletes the record zone.
+///
+/// - Warning: Deleting a record zone is a permanent action that deletes every record in that zone. You can't restore a deleted record zone.
+///
+/// The completion handler takes the following parameters:
+///
+/// - The identifier of the deleted record zone, or `nil` if there's an error.
+/// - An error if a problem occurs, or `nil` if CloudKit successfully deletes the record zone.
+///
+/// For information on a more convenient way to delete record zones, see ``CKDatabase/modifyRecordZones(saving:deleting:)``.
 - (void)deleteRecordZoneWithID:(CKRecordZoneID *)zoneID completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKRecordZoneID * _Nullable zoneID, NSError * _Nullable error))completionHandler NS_SWIFT_ASYNC_NAME(deleteRecordZone(withID:));
 
 #pragma mark - Subscription Convenience Methods
-/*! @c CKFetchSubscriptionsOperation and @c CKModifySubscriptionsOperation are the more configurable, @c CKOperation -based alternative to these methods */
+
+/// Fetches a specific subscription and delivers it to a completion handler.
+///
+/// - Parameters:
+///   - subscriptionID: The identifier of the subscription to fetch.
+///   - completionHandler: The block to execute with the fetch results.
+///
+/// The completion handler takes the following parameters:
+///
+///   - term `subscription`: The requested subscription, or `nil` if CloudKit can't provide that subscription.
+///   - term `error`: An error if a problem occurs, or `nil` if the fetch completes successfully.
+///
+/// For information on a more configurable way to fetch specific subscriptions, see ``CKFetchSubscriptionsOperation``.
 - (void)fetchSubscriptionWithID:(CKSubscriptionID)subscriptionID completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKSubscription * _Nullable subscription, NSError * _Nullable error))completionHandler API_AVAILABLE(macos(10.10), ios(8.0), tvos(9.0), watchos(6.0)) NS_REFINED_FOR_SWIFT_ASYNC(2);
+
+/// Fetches all subscriptions from the current database.
+///
+/// - Parameters:
+///   - completionHandler: The closure to execute with the fetch results.
+///
+/// The completion handler takes the following parameters:
+///
+/// - The database's subscriptions, or `nil` if CloudKit can't provide the subscriptions.
+/// - An error if a problem occurs, or `nil` if the fetch completes successfully.
+///
+/// For information on a more configurable way to fetch all subscriptions from a specific database, see ``CKFetchSubscriptionsOperation/fetchAllSubscriptionsOperation()``.
 - (void)fetchAllSubscriptionsWithCompletionHandler:(void (NS_SWIFT_SENDABLE ^)(NSArray<CKSubscription *> * _Nullable subscriptions, NSError * _Nullable error))completionHandler API_AVAILABLE(macos(10.10), ios(8.0), tvos(9.0), watchos(6.0)) NS_SWIFT_ASYNC_NAME(allSubscriptions());
+
+/// Saves a specific subscription.
+///
+/// - Parameters:
+///   - subscription: The subscription to save.
+///   - completionHandler: The closure to execute after CloudKit saves the subscription.
+///
+/// The completion handler takes the following parameters:
+///
+/// - The saved subscription (as it appears on the server), or `nil` if there's an error.
+/// - An error if a problem occurs, or `nil` if CloudKit successfully saves the subscription.
+///
+/// For information on a more convenient way to save subscriptions, see ``CKDatabase/modifySubscriptions(saving:deleting:)``.
 - (void)saveSubscription:(CKSubscription *)subscription completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKSubscription * _Nullable subscription, NSError * _Nullable error))completionHandler API_AVAILABLE(macos(10.10), ios(8.0), tvos(9.0), watchos(6.0));
+
+/// Deletes a specific subscription and delivers the deleted subscription's identifier to a completion handler.
+///
+/// - Parameters:
+///   - subscriptionID: The identifier of the subscription to delete.
+///   - completionHandler: The block to execute after CloudKit deletes the subscription.
+///
+/// The completion handler takes the following parameters:
+///
+///   - term `subscriptionID`: The identifier of the deleted subscription, or `nil` if there's an error.
+///   - term `error`: An error if a problem occurs, or `nil` if CloudKit successfully deletes the subscription.
+///
+/// For information on a more configurable way to delete subscriptions, see ``CKModifySubscriptionsOperation``.
 - (void)deleteSubscriptionWithID:(CKSubscriptionID)subscriptionID completionHandler:(void (NS_SWIFT_SENDABLE ^)(CKSubscriptionID _Nullable subscriptionID, NSError * _Nullable error))completionHandler API_AVAILABLE(macos(10.10), ios(8.0), tvos(9.0), watchos(6.0)) NS_REFINED_FOR_SWIFT_ASYNC(2);
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDatabaseOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDatabaseOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDatabaseOperation.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDatabaseOperation.h	2026-02-13 10:44:53
@@ -11,14 +11,17 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// The abstract base class for operations that act upon databases in CloudKit.
+///
+/// Database operations typically involve fetching and saving records and other database objects, as well as executing queries on the contents of the database. Use this class's ``database`` property to tell the operation which database to use when you execute it. Don't subclass this class or create instances of it. Instead, create instances of one of its concrete subclasses.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 @interface CKDatabaseOperation : CKOperation
 
-/*! @abstract The database on which to perform the operation.
- *
- *  @discussion If no database is set, @code [self.container privateCloudDatabase] @endcode is used.
- *  This will also set the container property of the operation's configuration to match the container of the passed-in database.
- */
+/// The database that the operation uses.
+///
+/// For operations that you execute in a custom queue, use this property to specify the target database. Setting the database also sets the corresponding container, which it inherits from ``CKOperation``. If this property's value is `nil`, the operation targets the user's private database.
+///
+/// The default value is `nil`.
 @property (nullable, strong, nonatomic) CKDatabase *database;
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDiscoverAllUserIdentitiesOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDiscoverAllUserIdentitiesOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDiscoverAllUserIdentitiesOperation.h	2025-11-09 04:37:40
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDiscoverAllUserIdentitiesOperation.h	2026-02-13 13:17:11
@@ -13,33 +13,85 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-/*! @class CKDiscoverAllUserIdentitiesOperation
- *
- *  @abstract Finds all discoverable users in the device's contacts database. No Contacts access dialog will be displayed.
- *
- *  @discussion This operation scales linearly with the number of email addresses and phone numbers in the device's address book.  It may take some time to complete.
- */
+/// An operation that uses the device's contacts to search for discoverable iCloud users.
+///
+/// Use this operation to discover iCloud users that match entries in the device's Contacts database. CloudKit uses the email addresses and phone numbers in each Contact record to search for a matching iCloud account.
+///
+/// Although your app doesn't need authorization to use the Contacts database to execute this operation, if it has authorization, you can use the ``CKUserIdentity/contactIdentifiers`` property on any returned user identity to fetch the corresponding Contact record from the database.
+///
+/// - Note: This operation scales linearly with the number of email addresses and phone numbers in the device's Contacts database, and may take some time to complete.
+///
+/// Before CloudKit can return a user's identity, you must ask for their permission by calling ``CKContainer/requestApplicationPermission:completionHandler:``. Do this as part of any onboarding where you can highlight the benefits of being discoverable within the context of your app.
+///
+/// The operation executes the handlers you provide on an internal queue it manages. You must provide handlers capable of executing on a background queue. Tasks that need access to the main queue must redirect as appropriate.
+///
+/// The operation calls ``discoverAllUserIdentitiesCompletionBlock`` after it executes and returns results. Use the completion handler to perform housekeeping tasks for the operation. It should also manage any failures, whether due to an error or an explicit cancellation.
+///
+/// - Note: Because this class inherits from <doc://com.apple.documentation/documentation/foundation/operation>, you can also set the <doc://com.apple.documentation/documentation/foundation/operation/completionblock> property. The operation calls both completion handlers if they're both set.
+///
+/// CloudKit operations have a default QoS of <doc://com.apple.documentation/documentation/foundation/qualityofservice/default>. Operations with this service level are discretionary. The system schedules their execution at an optimal time according to battery level and network conditions, among other factors. Use the <doc://com.apple.documentation/documentation/foundation/operation/qualityofservice> property to set a more appropriate QoS for the operation.
+///
+/// The following example shows how to create the operation, configure its callbacks, and execute it using the default container's queue:
+///
+/// ```swift
+/// func fetchUserIdentities(
+///     completion: @escaping (Result<[CKUserIdentity], any Error>) -> Void) {
+///
+///     var identities = [CKUserIdentity]()
+///
+///     // Create an operation to discover all the iCloud users
+///     // in the user's Contacts database that use the app, and
+///     // opt in to being discoverable.
+///     let operation = CKDiscoverAllUserIdentitiesOperation()
+///
+///     // Cache the user identities as CloudKit discovers them.
+///     operation.userIdentityDiscoveredBlock = { userIdentity in
+///         identities.append(userIdentity)
+///     }
+///
+///     // If the operation fails, return the error to the caller.
+///     // Otherwise, return the array of discovered user identities.
+///     operation.discoverAllUserIdentitiesCompletionBlock = { error in
+///         if let error = error {
+///             completion(.failure(error))
+///         } else {
+///             completion(.success(identities))
+///         }
+///     }
+///
+///     // Set an appropriate QoS and add the operation to the
+///     // default container's queue to execute it.
+///     operation.qualityOfService = .userInitiated
+///     CKContainer.default().add(operation)
+/// }
+/// ```
 API_DEPRECATED("No longer supported. Please see Sharing CloudKit Data with Other iCloud Users.", macos(10.12, 14.0), ios(10.0, 17.0), watchos(3.0, 10.0))
 API_UNAVAILABLE(tvos)
 @interface CKDiscoverAllUserIdentitiesOperation : CKOperation
 
+/// Creates an operation for searching the device's contacts.
+///
+/// You can use the operation only once. Create a new operation for each subsequent search.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
 
-/*! @abstract Called once for each successfully-discovered user identity from the device's address book.
- *
- *  @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute for each user identity.
+///
+/// The closure doesn't return a value and takes the following parameter:
+///
+/// - The user identity that matches an entry in the device's Contacts.
+///
+/// The operation executes this closure one or more times for each user identity it discovers. Each time the closure executes, it executes serially with respect to the other closures of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or add the operation to a queue.
 @property (nullable, copy, nonatomic) void (^userIdentityDiscoveredBlock)(CKUserIdentity *identity);
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when the operation finishes.
+///
+/// The closure doesn't return a value and takes the following parameter:
+///
+/// - An error if a problem occurs, or `nil` if CloudKit successfully fetches the user identities.
+///
+/// This closure executes only once, after all of the individual discovery closures finish. The closure executes serially with respect to the operation's other closures. If you intend to use this closure to process results, update the property's value before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^discoverAllUserIdentitiesCompletionBlock)(NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use discoverAllUserIdentitiesResultBlock instead", macos(10.12, 12.0), ios(10.0, 15.0), watchos(3.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDiscoverUserIdentitiesOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDiscoverUserIdentitiesOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDiscoverUserIdentitiesOperation.h	2025-11-09 04:37:40
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKDiscoverUserIdentitiesOperation.h	2026-02-14 00:26:10
@@ -13,29 +13,99 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An operation that uses the provided criteria to search for discoverable iCloud users.
+///
+/// Use this operation to discover one or more iCloud users that match identity information you provide, such as email addresses and phone numbers.
+///
+/// Before CloudKit can return a user's identity, you must ask for their permission by calling ``CKContainer/requestApplicationPermission:completionHandler:``. Do this as part of any onboarding where you can highlight the benefits of being discoverable within the context of your app.
+///
+/// The operation executes the handlers you provide on an internal queue it manages. You must provide handlers capable of executing on a background queue. Tasks that need access to the main queue must redirect as appropriate.
+///
+/// The operation calls ``discoverUserIdentitiesCompletionBlock`` after it executes and returns results. Use the completion handler to perform housekeeping tasks for the operation. It should also manage any failures, whether due to an error or an explicit cancellation.
+///
+/// - Note: Because this class inherits from <doc://com.apple.documentation/documentation/foundation/operation>, you can also set the <doc://com.apple.documentation/documentation/foundation/operation/completionblock> property. The operation calls both completion handlers if they're both set.
+///
+/// CloudKit operations have a default QoS of <doc://com.apple.documentation/documentation/foundation/qualityofservice/default>. Operations with this service level are discretionary. The system schedules their execution at an optimal time according to battery level and network conditions, among other factors. Use the <doc://com.apple.documentation/documentation/foundation/operation/qualityofservice> property to set a more appropriate QoS for the operation.
+///
+/// The following example shows how to create the operation, configure its callbacks, and execute it using the default container's queue:
+///
+/// ```swift
+/// func fetchUserIdentities(withEmails emails: [String],
+///     completion: @escaping (Result<[CKUserIdentity], any Error>) -> Void) {
+///
+///     var identities = [CKUserIdentity]()
+///
+///     // Convert the email addresses into instances of
+///     // CKUserIdentity.LookupInfo, which CloudKit uses
+///     // to discover identities.
+///     let lookupInfos =
+///         CKUserIdentity.LookupInfo.lookupInfos(withEmails: emails)
+///
+///     // Create the operation using the array of lookup objects.
+///     let operation = CKDiscoverUserIdentitiesOperation(
+///         userIdentityLookupInfos: lookupInfos)
+///
+///     // Cache the user identities as CloudKit discovers them.
+///     operation.userIdentityDiscoveredBlock = { userIdentity, _ in
+///         identities.append(userIdentity)
+///     }
+///
+///     // If the operation fails, return the error to the caller.
+///     // Otherwise, return the array of discovered user identities.
+///     operation.discoverUserIdentitiesCompletionBlock = { error in
+///         if let error = error {
+///             completion(.failure(error))
+///         } else {
+///             completion(.success(identities))
+///         }
+///     }
+///
+///     // Set an appropriate QoS and add the operation to the
+///     // default container's queue to execute it.
+///     operation.qualityOfService = .userInitiated
+///     CKContainer.default().add(operation)
+/// }
+/// ```
 API_DEPRECATED("No longer supported. Please see Sharing CloudKit Data with Other iCloud Users.", macos(10.12, 14.0), ios(10.0, 17.0), tvos(10.0, 17.0), watchos(3.0, 10.0))
 @interface CKDiscoverUserIdentitiesOperation : CKOperation
 
+/// Creates an operation for discovering user identities.
+///
+/// You can use the operation only once. Create a new operation for each subsequent search.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for discovering the user identities of the specified lookup infos.
+///
+/// - Parameters:
+///   - userIdentityLookupInfos: An array that contains instances of ``CKUserIdentity/LookupInfo``. CloudKit uses this parameter as the default value for the ``CKDiscoverUserIdentitiesOperation/userIdentityLookupInfos`` property. If you specify `nil`, you must assign a value to that property before you execute the operation.
+///
+/// After you create the operation, assign a handler to ``CKDiscoverUserIdentitiesOperation/discoverUserIdentitiesCompletionBlock`` so that you can process the search results.
 - (instancetype)initWithUserIdentityLookupInfos:(NSArray<CKUserIdentityLookupInfo *> *)userIdentityLookupInfos;
 
+/// The lookup info for discovering user identities.
+///
+/// Use this property to view or change the lookup info that CloudKit uses to discover user identities. If you intend to modify this property's value, do so before you execute the operation or submit it to a queue.
 @property (copy, nonatomic) NSArray<CKUserIdentityLookupInfo *> *userIdentityLookupInfos;
 
-/*! @abstract Called once for each user identity lookup info that was successfully discovered on the server
- *
- *  @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute for each user identity.
+///
+/// The closure doesn't return a value and takes the following parameters:
+///
+/// - The user identity.
+/// - The lookup info that corresponds to the user identity.
+///
+/// The operation executes this closure one or more times for each user identity it discovers. Each time the closure executes, it executes serially with respect to the other closures of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or add the operation to a queue.
 @property (nullable, copy, nonatomic) void (^userIdentityDiscoveredBlock)(CKUserIdentity *identity, CKUserIdentityLookupInfo * lookupInfo);
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when the operation finishes.
+///
+/// The closure doesn't return a value and takes the following parameter:
+///
+/// - An error if a problem occurs, or `nil` if CloudKit successfully fetches the user identities.
+///
+/// This closure executes only once, after all of the individual discovery closures finish. The closure executes serially with respect to the operation's other closures. If you intend to use this closure to process results, update the property's value before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^discoverUserIdentitiesCompletionBlock)(NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use discoverUserIdentitiesResultBlock instead", macos(10.12, 12.0), ios(10.0, 15.0), tvos(10.0, 15.0), watchos(3.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKError.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKError.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKError.h	2025-11-09 05:05:27
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKError.h	2026-02-13 11:10:17
@@ -13,156 +13,221 @@
 
 API_AVAILABLE_BEGIN(macos(10.10), ios(8.0), watchos(3.0))
 
+/// The error domain for CloudKit errors.
 CK_EXTERN NSString * const CKErrorDomain;
 
-/*! @abstract When a CKErrorPartialFailure happens this key will be set in the error's userInfo dictionary.
- *
- *  @discussion The value of this key will be a dictionary, and the values will be errors for individual items with the keys being the item IDs that failed.
- */
+/// The key to retrieve partial errors.
+///
+/// The value of this key is a dictionary that maps an item ID to an error. The type of each ID depends on where the error occurs. For example, if you receive a partial error when modifying a record, the ID is an instance of ``CKRecord/ID`` that corresponds to the record that CloudKit can't modify.
 CK_EXTERN NSString * const CKPartialErrorsByItemIDKey;
 
-/*! If the server rejects a record save because it has been modified since the last time it was read,
- *  a @c CKErrorServerRecordChanged will be returned.  The error's @c userInfo dictionary will contain
- *  a @c CKRecord keyed by @c CKRecordChangedErrorAncestorRecordKey.  This is the original
- *  record used as a basis for making your changes.
- *
- *  Note that if you had attempted to save a new @c CKRecord instance, this record may not have any
- *  key / value pairs set on it, as there was no @c CKRecord instance that represents an ancestor point.
- */
+/// The key to retrieve the original version of the record.
 CK_EXTERN NSString * const CKRecordChangedErrorAncestorRecordKey;
 
-/*! If the server rejects a record save because it has been modified since the last time it was read,
- *  a @c CKErrorServerRecordChanged will be returned.  The error's @c userInfo dictionary will contain
- *  a @c CKRecord keyed by @c CKRecordChangedErrorServerRecordKey.  This is the record
- *  object that was found on the server.
- *
- *  Use this record as the basis for merging your changes.
- */
+/// The key to retrieve the server's version of the record.
 CK_EXTERN NSString * const CKRecordChangedErrorServerRecordKey;
 
-/*! If the server rejects a record save because it has been modified since the last time it was read,
- *  a @c CKErrorServerRecordChanged will be returned.  The error's @c userInfo dictionary will contain
- *  a @c CKRecord keyed by @c CKRecordChangedErrorClientRecordKey.  This is the record
- *  object that you tried to save.
- */
+/// The key to retrieve the local version of the record.
 CK_EXTERN NSString * const CKRecordChangedErrorClientRecordKey;
 
-/* On error CKErrorZoneNotFound, the userInfo dictionary may contain a NSNumber instance that specifies a boolean value representing if the error is caused by the user having reset all encrypted data for their account */
+/// The key that determines whether CloudKit deletes a record zone because of a user action.
+///
+/// An <doc://com.apple.documentation/documentation/foundation/nsnumber> that represents a Boolean value you use to determine whether a user action causes CloudKit to delete a record zone. CloudKit adds this key to the error's `userInfo` dictionary when the error code is ``CKError/Code/zoneNotFound``.
 CK_EXTERN NSString * const CKErrorUserDidResetEncryptedDataKey API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0));
 
-/*! On some errors, the userInfo dictionary may contain a NSNumber instance that specifies the period of time in seconds after which the client may retry the request. For example, this key will be on @c CKErrorServiceUnavailable, @c CKErrorRequestRateLimited, and other errors for which the recommended resolution is to retry after a delay.
- */
+/// The key to retrieve the number of seconds to wait before you retry a request.
+///
+/// An <doc://com.apple.documentation/documentation/foundation/nsnumber> that contains the number of seconds until you can retry a request. CloudKit adds this key to the error's <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary when the error code is ``CKError/Code/serviceUnavailable`` or ``CKError/Code/requestRateLimited``.
 CK_EXTERN NSString * const CKErrorRetryAfterKey;
 
+/// The error codes that CloudKit returns.
 typedef NS_ENUM(NSInteger, CKErrorCode) {
-    /*! CloudKit.framework encountered an error.  This is a non-recoverable error. */
+    /// A nonrecoverable error that CloudKit encounters.
+    ///
+    /// If you receive this error, file a [bug report](http://radar.apple.com) that includes the error log.
     CKErrorInternalError                  = 1,
     
-    /*! Some items failed, but the operation succeeded overall. Check CKPartialErrorsByItemIDKey in the userInfo dictionary for more details.
-     *  This error is only returned from CKOperation completion blocks, which are deprecated in swift.
-     *  It will not be returned from (swift-only) CKOperation result blocks, which are their replacements
-     */
+    /// An error that occurs when an operation completes with partial failures.
+    ///
+    /// Examine the specific item failures, and act on the failed items. Each specific item error is from the CloudKit error domain. You can inspect the <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> ``CKPartialErrorsByItemIDKey`` to see per-item errors.
+    ///
+    /// Note that in a custom zone, the system processes all items in an operation atomically. As a result, you may get a ``CKError/Code/batchRequestFailed`` error for all other items in an operation that don't cause an error.
     CKErrorPartialFailure                 = 2,
     
-    /*! Network not available */
+    /// An error that occurs when the network is unavailable.
+    ///
+    /// You can retry network failures immediately, but have your app implement a backoff period so that it doesn't attempt the same operation repeatedly.
+    ///
+    /// If the network is unavailable, have your app monitor for network reachability and wait to reissue the operation when the network is available again. See <doc://com.apple.documentation/documentation/cfnetwork/cfnetworkerrors> for more information.
     CKErrorNetworkUnavailable             = 3,
     
-    /*! Network error (available but CFNetwork gave us an error) */
+    /// An error that occurs when a network is available, but CloudKit is inaccessible.
+    ///
+    /// You can retry network failures immediately, but have your app implement a backoff period so that it doesn't attempt the same operation repeatedly.
+    ///
+    /// If the network is unavailable, have your app monitor for network reachability and wait to reissue the operation when the network is available again. See <doc://com.apple.documentation/documentation/cfnetwork/cfnetworkerrors> for more information.
     CKErrorNetworkFailure                 = 4,
     
-    /*! Un-provisioned or unauthorized container. Try provisioning the container before retrying the operation. */
+    /// An error that occurs when you use an unknown or unauthorized container.
     CKErrorBadContainer                   = 5,
     
-    /*! Service unavailable */
+    /// An error that occurs when CloudKit is unavailable.
     CKErrorServiceUnavailable             = 6,
     
-    /*! Client is being rate limited */
+    /// An error that occurs when CloudKit rate-limits requests.
+    ///
+    /// Check for a ``CKErrorRetryAfterKey`` key in the <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary of any CloudKit error that you receive. It's especially important to check for it if you receive any of these errors. Use the value of the ``CKErrorRetryAfterKey`` key as the number of seconds to wait before retrying this operation.
     CKErrorRequestRateLimited             = 7,
     
-    /*! Missing entitlement */
+    /// An error that occurs when the app is missing a required entitlement.
     CKErrorMissingEntitlement             = 8,
     
-    /*! Not authenticated (writing without being logged in, no user record) */
+    /// An error that occurs when CloudKit cannot authenticate the user.
     CKErrorNotAuthenticated               = 9,
     
-    /*! Access failure (save, fetch, or shareAccept) */
+    /// An error that occurs when the user doesn't have permission to save or fetch data.
+    ///
+    /// This error typically occurs in the public database in one of these circumstances:
+    ///
+    /// - You have roles for record types.
+    /// - Your app is trying to accept a share that the user doesn't have an invitation for.
+    ///
+    /// Let users know they can't perform this operation. This error is nonrecoverable and you can't retry the operation.
     CKErrorPermissionFailure              = 10,
     
-    /*! Record does not exist */
+    /// An error that occurs when the specified record doesn't exist.
     CKErrorUnknownItem                    = 11,
     
-    /*! Bad client request (bad record graph, malformed predicate) */
+    /// An error that occurs when the request contains invalid information.
+    ///
+    /// Consult the error's <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary for more information about the issue.
     CKErrorInvalidArguments               = 12,
     
+    /// An error that occurs when CloudKit truncates a query's results.
     CKErrorResultsTruncated API_DEPRECATED("Will not be returned", macos(10.10, 10.12), ios(8.0, 10.0), tvos(9.0, 10.0), watchos(3.0, 3.0)) = 13,
     
-    /*! The record was rejected because the version on the server was different */
+    /// An error that occurs when CloudKit rejects a record because the server's version is different.
+    ///
+    /// This error indicates that the server's version of the record is newer than the local version the client's trying to save. Your app needs to handle this error, resolve any conflicts in the record, and attempt another save of the record, if necessary.
+    ///
+    /// CloudKit provides your app with three copies of the record in this error's `userInfo` dictionary to assist with comparing and merging the changes:
+    ///
+    /// - ``CKRecordChangedErrorClientRecordKey``: The local record that the client's trying to save.
+    /// - ``CKRecordChangedErrorServerRecordKey``: The record that exists on the server.
+    /// - ``CKRecordChangedErrorAncestorRecordKey``: The original version of the record.
+    ///
+    /// When a conflict occurs, your app needs to merge all changes into the record for the ``CKRecordChangedErrorServerRecordKey`` key and attempt a new save using that record. Merging into either of the other two copies of the record results in another conflict error because those records have the old record change tag.
     CKErrorServerRecordChanged            = 14,
     
-    /*! The server rejected this request. This is a non-recoverable error */
+    /// An error that occurs when CloudKit rejects the request.
+    ///
+    /// This error is nonrecoverable.
     CKErrorServerRejectedRequest          = 15,
     
-    /*! Asset file was not found */
+    /// An error that occurs when the system can't find the specified asset.
     CKErrorAssetFileNotFound              = 16,
     
-    /*! Asset file content was modified while being saved */
+    /// An error that occurs when the system modifies an asset while saving it.
     CKErrorAssetFileModified              = 17,
     
-    /*! App version is less than the minimum allowed version */
+    /// An error that occurs when the current app version is older than the oldest allowed version.
     CKErrorIncompatibleVersion            = 18,
     
-    /*! The server rejected the request because there was a conflict with a unique field. */
+    /// An error that occurs when the server rejects the request because of a unique constraint violation.
     CKErrorConstraintViolation            = 19,
     
-    /*! A CKOperation was explicitly cancelled */
+    /// An error that occurs when an operation cancels.
     CKErrorOperationCancelled             = 20,
     
-    /*! The previousServerChangeToken value is too old and the client must re-sync from scratch */
+    /// An error that occurs when the change token expires.
     CKErrorChangeTokenExpired             = 21,
     
-    /*! One of the items in this batch operation failed in a zone with atomic updates, so the entire batch was rejected. */
+    /// An error that occurs when the system rejects the entire batch of changes.
+    ///
+    /// This error occurs when an operation attempts to save multiple items in a custom zone, but one of those items encounters an error. Because custom zones are atomic, the entire batch fails. The items that cause the problem have their own errors, and all other items in the batch have a ``CKError/Code/batchRequestFailed`` error to indicate that the system can't save them.
+    ///
+    /// This error indicates that the system can't process the associated item due to an error in another item in the operation. Check the other per-item errors under ``CKPartialErrorsByItemIDKey`` for any that aren't ``CKError/Code/batchRequestFailed`` errors. Handle those errors, and then retry all items in the operation.
     CKErrorBatchRequestFailed             = 22,
     
-    /*! The server is too busy to handle this zone operation. Try the operation again in a few seconds. */
+    /// An error that occurs when the server is too busy to handle the record zone operation.
+    ///
+    /// Try the operation again in a few seconds. If you encounter this error again, increase the delay time exponentially for each subsequent retry to minimize server contention for the zone.
+    ///
+    /// Check for a ``CKErrorRetryAfterKey`` key in the <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary of any CloudKit error that you receive. Use the value of this key as the number of seconds to wait before retrying the operation.
     CKErrorZoneBusy                       = 23,
-    
-    /*! Operation could not be completed on the given database. Likely caused by attempting to modify zones in the public database. */
+
+    /// An error that occurs when the operation can't complete for the specified database.
+    ///
+    /// The system submitted the operation to the wrong database. Make sure you aren't submitting a share operation to the public database, or a record zone create operation to the shared database.
     CKErrorBadDatabase                    = 24,
     
-    /*! Saving a record would exceed quota */
+    /// An error that occurs when saving a record exceeds the user's storage quota.
+    ///
+    /// **In the public database**: Your app's container doesn't have enough storage. Individual users can't do anything about this, but you can go to the CloudKit Dashboard to view and manage your container's storage.
+    ///
+    /// **In the private database**: The user doesn't have enough iCloud storage. Prompt the user to go to iCloud settings to manage their storage.
+    ///
+    /// **In the shared database**: The owner of the shared record zone doesn't have enough iCloud storage. The user can't do anything about this, but can contact the owner about upgrading their storage or cleaning up their iCloud account.
     CKErrorQuotaExceeded                  = 25,
     
-    /*! The specified zone does not exist on the server */
+    /// An error that occurs when the specified record zone doesn't exist.
     CKErrorZoneNotFound                   = 26,
     
-    /*! The request to the server was too large. Retry this request as a smaller batch. */
+    /// An error that occurs when a request's size exceeds the limit.
+    ///
+    /// The server can change its limits at any time, but the following are general guidelines:
+    ///
+    /// - 400 items (records or shares) per operation
+    /// - 2 MB per request (not counting asset sizes)
+    ///
+    /// If your app receives ``CKError/Code/limitExceeded``, it must split the operation in half and try both requests again.
     CKErrorLimitExceeded                  = 27,
     
-    /*! The user deleted this zone through the settings UI. Your client should either remove its local data or prompt the user before attempting to re-upload any data to this zone. */
+    /// An error that occurs when the user deletes a record zone using the Settings app.
     CKErrorUserDeletedZone                = 28,
     
-    /*! A share cannot be saved because there are too many participants attached to the share */
+    /// An error that occurs when a share has too many participants.
+    ///
+    /// Remove some participants before you retry the operation. Limits can change at any time, but CloudKit generally enforces a maximum of 100 participants for a share.
     CKErrorTooManyParticipants            API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0)) = 29,
     
-    /*! A record/share cannot be saved, doing so would cause a hierarchy of records to exist in multiple shares */
+    /// An error that occurs when CloudKit attempts to share a record with an existing share.
+    ///
+    /// A record can exist in only a single share at a time. This error means that one of the following conditions exists:
+    ///
+    /// - The record already has an existing share.
+    /// - The record has a parent, and its parent has a share.
+    /// - The record is a parent, and one of its children has a share.
     CKErrorAlreadyShared                  API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0)) = 30,
     
-    /*! The target of a record's parent or share reference was not found */
+    /// An error that occurs when CloudKit can't find the target of a reference.
     CKErrorReferenceViolation             API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0)) = 31,
     
-    /*! Request was rejected due to a managed account restriction */
+    /// An error that occurs when CloudKit rejects a request due to a managed-account restriction.
+    ///
+    /// The system restricts CloudKit access for this account. This is a nonrecoverable error.
     CKErrorManagedAccountRestricted       API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0)) = 32,
     
-    /*! Share Metadata cannot be determined, because the user is not a member of the share.  There are invited participants on the share with email addresses or phone numbers not associated with any iCloud account. The user may be able to join the share if they can associate one of those email addresses or phone numbers with their iCloud account via the system Share Accept UI. Call UIApplication's openURL on this share URL to have the user attempt to verify their information. */
+    /// An error that occurs when the user isn't a participant of the share.
+    ///
+    /// A fetch share metadata operation fails when the user isn't a participant of the share. However, there are invited participants on the share with email addresses or phone numbers that don't have associations with an iCloud account. The user may be able to join a share by associating one of those email addresses or phone numbers with the user's iCloud account.
+    ///
+    /// Call <doc://com.apple.documentation/documentation/uikit/uiapplication/openurl(_:)> on the share URL to have the user attempt to verify their information.
     CKErrorParticipantMayNeedVerification API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0)) = 33,
     
-    /*! The server received and processed this request, but the response was lost due to a network failure.  There is no guarantee that this request succeeded.  Your client should re-issue the request (if it is idempotent), or fetch data from the server to determine if the request succeeded. */
+    /// An error that occurs when CloudKit is unable to maintain the network connection and provide a response.
+    ///
+    /// You can retry operations that are idempotent. For non-idempotent operations, you should consult server state to determine if the operation succeeded.
     CKErrorServerResponseLost             API_AVAILABLE(macos(10.13), ios(11.0), tvos(11.0), watchos(4.0)) = 34,
-    
-    /*! The file for this asset could not be accessed. It is likely your application does not have permission to open the file, or the file may be temporarily unavailable due to its data protection class. This operation can be retried after it is able to be opened in your process. */
+
+    /// An error that occurs when the system can't access the specified asset.
     CKErrorAssetNotAvailable              API_AVAILABLE(macos(10.13), ios(11.3), tvos(11.3), watchos(4.3)) = 35,
 
-    /*! The current account is in a state that may need user intervention to recover from. The user should be directed to check the Settings app. Listen for CKAccountChangedNotifications to know when to re-check account status and retry. */
+    /// An error that occurs when the user's iCloud account is temporarily unavailable.
+    ///
+    /// You receive this error when the user's iCloud account is available, but isn't ready to support CloudKit operations. Don't delete any cached data and don't enqueue any additional CloudKit operations.
+    ///
+    /// Checking the account status after the operation fails, assuming there are no other changes to the account's status, returns ``CKAccountStatus/temporarilyUnavailable``. Use the <doc://com.apple.documentation/documentation/foundation/nsnotification/name-swift.struct/ckaccountchanged> notification to listen for future account status changes, and retry the operation after the status becomes ``CKAccountStatus/available``.
     CKErrorAccountTemporarilyUnavailable  API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) = 36,
     
     /// The user is already an invited participant on this share. They must accept the existing share invitation before continuing.
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchDatabaseChangesOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchDatabaseChangesOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchDatabaseChangesOperation.h	2025-11-09 04:43:00
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchDatabaseChangesOperation.h	2026-02-13 11:10:17
@@ -11,81 +11,134 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-/*! @class CKFetchDatabaseChangesOperation
- *
- *  @abstract This operation will fetch changes to record zones within a database
- *
- *  @discussion If a change anchor from a previous @c CKFetchDatabaseChangesOperation is passed in, only the zones that have changed since that anchor will be returned.
- *  This per-database @c serverChangeToken is not to be confused with the per-recordZone @c serverChangeToken from @c CKFetchRecordZoneChangesOperation.
- *  If this is your first fetch or if you wish to re-fetch all zones, pass nil for the change token.
- *  Change token are opaque tokens and clients should not infer any behavior based on their content.
- *  @c CKFetchDatabaseChangesOperation is supported in a @c privateCloudDatabase and @c sharedCloudDatabase
- */
+/// An operation that fetches database changes.
+///
+/// Use this operation to fetch all record zone changes in a database. This includes new record zones, changed zones — including deleted or purged zones — and zones that contain record changes. When you create the operation, you provide a server change token, which is an opaque token that represents a specific point in the database's history. CloudKit returns only the changes that occur after that point. For your app's first fetch, or to refetch every change in the database's history, use `nil` instead.
+///
+/// - Note: Only private and shared databases support this operation. If you attempt to execute this operation in the public database, CloudKit returns an error.
+///
+/// The operation yields new change tokens during its execution, and issues a final change token when it completes without error. The change tokens conform to <doc://com.apple.documentation/documentation/foundation/nssecurecoding> and are safe to cache on-disk. This operation's tokens aren't compatible with ``CKFetchRecordZoneChangesOperation`` so you should segregate them in your cache. Don't infer any behavior or order from the tokens' contents.
+///
+/// When your app launches for the first time, use this operation to fetch all the database's changes. Cache the results on-device and use ``CKDatabaseSubscription`` to subscribe to future changes. Fetch those changes on receipt of the push notifications the subscription generates. It's not necessary to perform a fetch each time your app launches, or to schedule fetches at regular intervals.
+///
+/// The operation calls ``recordZoneWithIDChangedBlock`` for each zone that contains record changes. It also calls it for new and modified record zones. Store the IDs that CloudKit provides to this callback. Use those IDs with ``CKFetchRecordZoneChangesOperation`` to fetch the corresponding changes. There are similar callbacks for deleted and purged record zones.
+///
+/// To run the operation, add it to the corresponding database's operation queue. The operation executes its callbacks on a private serial queue.
+///
+/// The following example shows how to create the operation, configure its callbacks, and execute it. For brevity, it omits the delete, and purge callbacks.
+///
+/// ```swift
+/// // Create a fetch operation using the server change
+/// // token from the previous fetch.
+/// CKFetchDatabaseChangesOperation *operation =
+///     [[CKFetchDatabaseChangesOperation alloc]
+///      initWithPreviousServerChangeToken:token];
+///
+/// // Collect the IDs of the modified record zones.
+/// operation.recordZoneWithIDChangedBlock = ^(CKRecordZoneID *recordZoneID) {
+///     [recordZoneIDs addObject:recordZoneID];
+/// };
+///
+/// // Process any change tokens that CloudKit provides
+/// // as the operation runs.
+/// operation.changeTokenUpdatedBlock = ^(CKServerChangeToken *newToken) {
+///     tokenHandler(newToken);
+/// };
+///
+/// // Store the final change token and pass the IDs of the
+/// // modified record zones for further processing.
+/// operation.fetchDatabaseChangesCompletionBlock =
+///     ^(CKServerChangeToken *newToken, BOOL more, NSError *error) {
+///     if (error) {
+///         // Handle the error.
+///     } else {
+///         tokenHandler(newToken);
+///         recordZonesHandler(recordZoneIDs);
+///     }
+/// };
+///
+/// // Set an appropriate QoS and add the operation to the shared
+/// // database's operation queue to execute it.
+/// operation.qualityOfService = NSQualityOfServiceUtility;
+/// [CKContainer.defaultContainer.sharedCloudDatabase addOperation:operation];
+/// ```
 API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
 @interface CKFetchDatabaseChangesOperation : CKDatabaseOperation
 
+/// Creates an empty fetch database changes operation.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for fetching database changes.
+///
+/// - Parameters:
+///   - previousServerChangeToken: The change token that CloudKit uses to determine which database changes to return.
+///
+/// After creating the operation, assign a handler to the ``CKFetchDatabaseChangesOperation/fetchDatabaseChangesCompletionBlock`` property so that you can process the operation's results.
+///
+/// If this is your first fetch, or if you want to refetch all zones, pass `nil` for the change token. If you provide a change token from a previous ``CKFetchDatabaseChangesOperation``, CloudKit returns only the zones with changes since that token. The per-database ``CKServerChangeToken`` isn't the same as the per-record zone ``CKServerChangeToken`` from ``CKFetchRecordZoneChangesOperation``.
 - (instancetype)initWithPreviousServerChangeToken:(nullable CKServerChangeToken *)previousServerChangeToken;
 
+/// The server change token.
+///
+/// Assign the token you receive from the ``CKFetchDatabaseChangesOperation/fetchDatabaseChangesCompletionBlock`` to this property. Doing so yields only the changes that occur after your most recent fetch operation. If you specify `nil` for this parameter, the operation fetches all changes.
 @property (nullable, copy, nonatomic) CKServerChangeToken *previousServerChangeToken;
+
+/// The maximum number of results that the operation fetches.
+///
+/// Use this property to limit the number of changes this operation returns. When the operation reaches the limit, it updates the change token and returns it to indicate that more results are available.
 @property (assign, nonatomic) NSUInteger resultsLimit;
 
-/*! @discussion When set to YES, this operation will send repeated requests to the server until all record zone changes have been fetched.
- *
- *  @c changeTokenUpdatedBlock will be invoked periodically, to give clients an updated change token so that already-fetched record zone changes don't need to be re-fetched on a subsequent operation.
- *  When set to NO, it is the responsibility of the caller to issue subsequent fetch-changes operations when moreComing is YES in a @c fetchDatabaseChangesCompletionBlock invocation.
- *  @c fetchAllChanges is @c YES by default
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations
- *  Blocks assigned to this operation may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// A Boolean value that indicates whether to send repeated requests to the server.
+///
+/// If <doc://com.apple.documentation/documentation/swift/true>, the operation sends repeat requests to the server until it fetches all changes. CloudKit executes the handler you set on the ``CKFetchDatabaseChangesOperation/changeTokenUpdatedBlock`` property with a change token after each request.
+///
+/// The default value is <doc://com.apple.documentation/documentation/swift/true>.
 @property (assign, nonatomic) BOOL fetchAllChanges;
 
-/*! @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute with a single record zone change.
+///
+/// The closure returns no value and takes the following parameter:
+///
+///   - term `zoneID`: The ID of the  record zone that contains changes.
 @property (nullable, copy, nonatomic) void (^recordZoneWithIDChangedBlock)(CKRecordZoneID *zoneID);
 
-/*! @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when a record zone no longer exists.
+///
+/// The closure returns no value and takes the following parameter:
+///
+///   - term `zoneID`: The deleted record zone's ID.
 @property (nullable, copy, nonatomic) void (^recordZoneWithIDWasDeletedBlock)(CKRecordZoneID *zoneID);
 
-/*! @abstract If this block is set it will be called instead of @c recordZoneWithIDWasDeletedBlock if the user deleted this zone via the iCloud storage UI.
- *
- *  @discussion This is an indication that the user wanted all data deleted, so local cached data should be wiped and not re-uploaded to the server.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when CloudKit purges a record zone.
+///
+/// The closure returns no value and takes the following parameter:
+///
+///   - term `zoneID`: The purged record zone's ID.
 @property (nullable, copy, nonatomic) void (^recordZoneWithIDWasPurgedBlock)(CKRecordZoneID *zoneID) API_AVAILABLE(macos(10.13), ios(11.0), tvos(11.0), watchos(4.0));
 
-/*! @abstract If this block is set it will be called instead of @c recordZoneWithIDWasDeletedBlock if the user chose to reset all encrypted data for their account.
- *
- *  @discussion This is an indication that the user had to reset encrypted data during account recovery, so local cached data should be re-uploaded to the server to minimize data loss.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when a user-invoked account reset deletes a record zone.
+///
+/// The closure returns no value and takes a single parameter: the deleted record zone's ID.
+///
+/// The operation executes this closure, instead of ``CKFetchDatabaseChangesOperation/recordZoneWithIDWasDeletedBlock``, after a user action causes CloudKit to delete the record zone. Reupload any locally cached data to iCloud to minimize data loss.
 @property (nullable, copy, nonatomic) void (^recordZoneWithIDWasDeletedDueToUserEncryptedDataResetBlock)(CKRecordZoneID *zoneID) API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0));
 
-/*! @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when the change token updates.
+///
+/// The closure executes periodically, and provides a new change token so that you don't need to refetch previously fetched record zone changes in a subsequent operation.
 @property (nullable, copy, nonatomic) void (^changeTokenUpdatedBlock)(CKServerChangeToken * serverChangeToken);
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion Clients are responsible for saving the change token at the end of the operation and passing it in to the next call to @c CKFetchDatabaseChangesOperation.
- *  If the server returns a @c CKErrorChangeTokenExpired error, the @c previousServerChangeToken value was too old and the client should toss its local cache and re-fetch the changes in this record zone starting with a nil @c previousServerChangeToken.
- *  If @c moreComing is true then the server wasn't able to return all the changes in this response. Another @c CKFetchDatabaseChangesOperation operation should be run with the @c previousServerChangeToken token from this operation.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when the operation finishes.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - The change token to store and use in subsequent instances of ``CKFetchDatabaseChangesOperation``.
+/// - A Boolen value that indicates whether this is the final database change. If ``CKFetchDatabaseChangesOperation/fetchAllChanges`` is <doc://com.apple.documentation/documentation/swift/false>, it's the app's responsibility to create additional instances of ``CKFetchDatabaseChangesOperation`` to fetch further changes.
+/// - An error object that contains information about a problem, or `nil` if CloudKit successfully retrieves the database changes.
+///
+/// - Note: The change token and error parameters are mutally exclusive — that is, the closure provides one of them but not both.
+///
+/// Your app is responsible for saving the change token at the end of the operation and providing it to future uses of ``CKFetchDatabaseChangesOperation``. If the server returns a ``CKError/Code/changeTokenExpired`` error, the ``CKFetchDatabaseChangesOperation/previousServerChangeToken`` value is stale and your app needs to clear its local cache and refetch the database changes, starting with a `nil` change token.
 @property (nullable, copy, nonatomic) void (^fetchDatabaseChangesCompletionBlock)(CKServerChangeToken * _Nullable serverChangeToken, BOOL moreComing, NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use fetchDatabaseChangesResultBlock instead", macos(10.12, 12.0), ios(10.0, 15.0), tvos(10.0, 15.0), watchos(3.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchNotificationChangesOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchNotificationChangesOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchNotificationChangesOperation.h	2025-11-09 04:37:38
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchNotificationChangesOperation.h	2026-02-13 10:44:52
@@ -9,7 +9,7 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-CK_NEWLY_UNAVAILABLE("Fetching notification changes is no longer supported.  Consider using CKDatabaseSubscription, CKFetchDatabaseChangesOperation, and CKFetchRecordZoneChangesOperation")
+CK_NEWLY_UNAVAILABLE("Fetching notification changes is no longer supported. Consider using CKDatabaseSubscription, CKFetchDatabaseChangesOperation, and CKFetchRecordZoneChangesOperation")
 @interface CKFetchNotificationChangesOperation : CKOperation
 @end
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordChangesOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordChangesOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordChangesOperation.h	2025-11-09 04:34:58
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordChangesOperation.h	2026-02-14 00:26:09
@@ -12,65 +12,108 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-/*! @class CKFetchRecordChangesOperation
- *
- *  @discussion Use CKFetchRecordZoneChangesOperation instead of this class.
- *
- *  Any serverChangeTokens saved from a CKFetchRecordChangesOperation are usable as a serverRecordZoneChangeToken in CKFetchRecordZoneChangesOperation
- *
- *  This operation will fetch records changes in the given record zone.
- *
- *  If a change token from a previous @c CKFetchRecordChangesOperation is passed in, only the records that have changed since that token will be fetched.
- *  If this is your first fetch or if you wish to re-fetch all records, pass nil for the change token.
- *  Change tokens are opaque tokens and clients should not infer any behavior based on their content
- */
+/// An operation that reports on the changed and deleted records in the specified record zone.
+///
+/// @DeprecationSummary {
+///     Use ``CKFetchRecordZoneChangesOperation`` instead.
+/// }
+/// 
+/// Use this type of operation object to optimize fetch operations for sets of records you manage locally. Specifically, use it when you maintain a local cache of your record data and need to synchronize that cache periodically with the server.
+///
+/// To get the most benefit out of a `CKFetchRecordChangesOperation` object, you must maintain a local cache of the records from the specified zone. Each time you fetch changes from that zone, the server provides a token that identifies your request. With each subsequent fetch request, you initialize the operation object with the token from the previous request, and the server returns only the records with changes since that request.
+///
+/// The blocks you assign to process the fetched records execute serially on an internal queue that the operation manages. You must provide blocks capable of executing on a background thread, so any tasks that require access to the main thread must redirect accordingly.
+///
+/// If you assign a completion block to the <doc://com.apple.documentation/documentation/foundation/operation/completionblock> property of the operation object, the system calls the completion block after the operation executes and returns its results to you. You can use a completion block to perform housekeeping tasks for the operation, but don't use it to process the results of the operation. Any completion block you specify should handle the failure of the operation to complete its task, whether due to an error or an explicit cancellation.
 API_DEPRECATED_WITH_REPLACEMENT("CKFetchRecordZoneChangesOperation", macos(10.10, 10.12), ios(8.0, 10.0), tvos(9.0, 10.0), watchos(3.0, 3.0))
 @interface CKFetchRecordChangesOperation : CKDatabaseOperation
 
+/// Creates an empty fetch record changes operation.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for fetching changes in the specified record zone.
+///
+/// - Parameters:
+///   - recordZoneID: The zone that contains the records you want to fetch. You can fetch changes in a custom zone. CloudKit doesn't support syncing the default zone.
+///   - previousServerChangeToken: The change token from a previous fetch operation. This is the token that the system passes to your ``CKFetchRecordChangesOperation/fetchRecordChangesCompletionBlock`` handler during a previous fetch operation. Use this token to limit the returned data to only those changes that occur after that fetch request. If you specify `nil` for this parameter, the operation object fetches all records and their contents.
+///
+/// - Returns: An initialized operation object.
+///
+/// When initializing the operation object, use the token from a previous fetch request if you have one. You can archive tokens and write them to disk for later use.
+///
+/// The returned operation object retrieves all changed fields of the record, including any assets in those fields. If you want to minimize the amount of data that returns even further, configure the ``CKFetchRecordChangesOperation/desiredKeys`` property with the subset of keys that have values you want to fetch.
+///
+/// After initializing the operation, associate at least one progress block with the operation object (excluding the completion block) to process the results.
 - (instancetype)initWithRecordZoneID:(CKRecordZoneID *)recordZoneID previousServerChangeToken:(nullable CKServerChangeToken *)previousServerChangeToken;
 
+/// The ID of the record zone with the records you want to fetch.
+///
+/// Typically, you set the value of this property when you initialize the operation object. If you intend to change the record zone, update the value before executing the operation or submitting it to a queue.
 @property (nullable, copy, nonatomic) CKRecordZoneID *recordZoneID;
+
+/// The token that identifies the starting point for retrieving changes.
+///
+/// Each fetch request returns a unique token in addition to any changes. The token passes as a parameter to your ``CKFetchRecordChangesOperation/fetchRecordChangesCompletionBlock`` handler. During a subsequent fetch request, providing the previous token causes the server to return only the changes that occur after the previous fetch request. Tokens are opaque data objects that you can write to disk safely and reuse later.
+///
+/// Typically, you set the value of this property when you initialize the operation object. If you intend to change the record zone, update the value of the property before executing the operation or submitting it to a queue.
 @property (nullable, copy, nonatomic) CKServerChangeToken *previousServerChangeToken;
 
+/// The maximum number of changed records to report with this operation object.
+///
+/// Use this property to limit the number of results in situations where you expect the number of changed records to be large. The default value is 0, which causes the server to return an appropriate number of results using dynamic conditions.
+///
+/// When the number of returned results exceeds the results limit, the operation object sets the ``CKFetchRecordChangesOperation/moreComing`` property to <doc://com.apple.documentation/documentation/swift/true> before executing the block in the ``CKFetchRecordChangesOperation/fetchRecordChangesCompletionBlock`` property. In your block, check the value of that property, and if it's <doc://com.apple.documentation/documentation/swift/true>, create a new ``CKFetchRecordChangesOperation`` object to fetch more results.
 @property (assign, nonatomic) NSUInteger resultsLimit;
 
-/*! @abstract Declares which user-defined keys should be fetched and added to the resulting CKRecords.
- *
- *  @discussion If nil, declares the entire record should be downloaded. If set to an empty array, declares that no user fields should be downloaded.
- *  Defaults to @c nil.
- */
+/// The fields to fetch for the requested records.
+///
+/// Use this property to limit the amount of data that the system retrieves for each record during the fetch operation. This property contains an array of strings, each of which contains the name of a field from the target records. When you retrieve a record, the returned records only include fields with names that match one of the keys in this property. The default value is `nil`, which causes the system to fetch all keys of the record.
+///
+/// Because you can fetch records of different types, configure the array to include the merged set of all field names for the requested records and at least one field name from each record type.
+///
+/// If you intend to specify the desired set of keys, set the value of this property before executing the operation or submitting it to a queue.
 @property (nullable, copy, nonatomic) NSArray<CKRecordFieldKey> *desiredKeys;
 
-/*! @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The block to execute with the contents of a changed record.
+///
+/// The block returns no value and takes the following parameters:
+///
+///   - term `record`: The changed record. If you specify a value for the ``CKFetchRecordChangesOperation/desiredKeys`` property, the record only contains the fields in the ``CKFetchRecordChangesOperation/desiredKeys`` property.
+///
+/// The operation object executes this block once for each record in the zone with changes since the previous fetch request. Each time the block executes, it executes serially with respect to the other progress blocks of the operation. If no records change, the block doesn't execute.
+///
+/// If you intend to use this block to process results, set it before executing the operation or submitting it to a queue.
 @property (nullable, copy, nonatomic) void (^recordChangedBlock)(CKRecord *record);
 
-/*! @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The block to execute with the ID of a deleted record.
+///
+/// The block returns no value and takes the following parameters:
+///
+///   - term `recordID`: The ID of the deleted record.
+///
+/// The operation object executes this block once for each record the server deletes in the record zone after the previous fetch request. Each time the block executes, it executes serially with respect to the other progress blocks of the operation. If there aren't any deleted records, this block doesn't execute.
+///
+/// If you intend to use this block to process results, set it before executing the operation or submitting it to a queue.
 @property (nullable, copy, nonatomic) void (^recordWithIDWasDeletedBlock)(CKRecordID *recordID);
 
-/*! @abstract If true, then the server wasn't able to return all the changes in this response.
- *
- *  @discussion Will be set before fetchRecordChangesCompletionBlock is called.
- *  Another CKFetchRecordChangesOperation operation should be run with the updated serverChangeToken token from this operation.
- */
+/// A Boolean value that indicates whether more results are available.
+///
+/// If the server is unable to deliver all of the changed results with this operation object, it sets this property to <doc://com.apple.documentation/documentation/swift/true> before executing the block in the ``CKFetchRecordChangesOperation/fetchRecordChangesCompletionBlock`` property. To fetch the remaining changes, create a new ``CKFetchRecordChangesOperation`` object using the change token that the server returns.
 @property (readonly, assign, nonatomic) BOOL moreComing;
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion Clients are responsible for saving the change token at the end of the operation and passing it in to the next call to @c CKFetchRecordChangesOperation.
- *  Note that a fetch can fail partway. If that happens, an updated change token may be returned in the completion block so that already fetched records don't need to be re-downloaded on a subsequent operation.
- *  The @c clientChangeTokenData from the most recent @c CKModifyRecordsOperation is also returned, or nil if none was provided.
- *  If the server returns a @c CKErrorChangeTokenExpired error, the @c previousServerChangeToken value was too old and the client should toss its local cache and re-fetch the changes in this record zone starting with a nil @c previousServerChangeToken.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The block to execute when the system finishes processing all changes.
+///
+/// The block returns no value and takes the following parameters:
+///
+///   - term `serverChangeToken`: The new change token from the server. You can store this token locally and use it during subsequent fetch operations to limit the results to records that the system changes after executing the operation.
+///   - term `clientChangeToken`: The most recent client change token from the device. If the change token isn't the most recent change token you provided, the server might not have received the associated changes.
+///   - term `operationError`: An error object that contains information about a problem, or `nil` if the system successfully retrieves the changes.
+///
+/// When implementing this block, check the ``CKFetchRecordChangesOperation/moreComing`` property of the operation object to verify that the server was able to deliver all results. If that property is <doc://com.apple.documentation/documentation/swift/true>, you must create another operation object using the value in the `serverChangeToken` parameter to fetch any remaining changes.
+///
+/// The operation object executes this block only once at the conclusion of the operation. It executes after all individual change blocks, but before the operation's completion block. The block executes serially with respect to the other progress blocks of the operation.
+///
+/// If you intend to use this block to process results, set it before executing the operation or submitting the operation object to a queue.
 @property (nullable, copy, nonatomic) void (^fetchRecordChangesCompletionBlock)(CKServerChangeToken * _Nullable serverChangeToken, NSData * _Nullable clientChangeTokenData, NSError * _Nullable operationError);
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordZoneChangesOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordZoneChangesOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordZoneChangesOperation.h	2025-11-12 06:00:29
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordZoneChangesOperation.h	2026-02-13 13:17:11
@@ -14,109 +14,264 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-/*! @abstract This operation will fetch records changes across the given record zones
- *
- *  @discussion For each @c previousServerChangeToken passed in with a @c CKFetchRecordZoneChangesConfiguration, only records that have changed since that anchor will be fetched.
- *  If this is your first fetch of a zone or if you wish to re-fetch all records within a zone, do not include a @c previousServerChangeToken.
- *  Change tokens are opaque tokens and clients should not infer any behavior based on their content.
- */
+/// An operation that fetches record zone changes.
+///
+/// Use this operation to fetch record changes in one or more record zones, such as those that occur during record creation, modification, and deletion. You provide a configuration object for each record zone to query for changes. The configuration contains a server change token, which is an opaque pointer to a specific change in the zone's history. CloudKit returns only the changes that occur after that point. For the first time you fetch a record zone's changes, or to refetch all changes in a zone's history, use `nil` instead.
+///
+/// - Note: Only private and shared databases support this operation. If you attempt to execute this operation in the public database, CloudKit returns an error.
+///
+/// CloudKit processes the record zones in succession, and returns the changes for each zone in batches. Each batch yields a new change token. If all batches return without error, the operation issues a final change token for that zone. The change tokens conform to <doc://com.apple.documentation/documentation/foundation/nssecurecoding> and are safe to cache on-disk. This operation's tokens aren't compatible with ``CKFetchDatabaseChangesOperation`` so you should segregate them in your app's cache. Don't infer behavior or order from the tokens' contents.
+///
+/// If you create record zones in the private database, fetch all changes the first time the app launches. Cache the results on-device and use ``CKRecordZoneSubscription`` to subscribe to future changes. Fetch those changes on receipt of the push notifications the subscription generates. If you use the shared database, subscribe to changes with ``CKDatabaseSubscription`` instead. When a user participates in sharing, CloudKit adds and removes record zones. This means you don't know in advance which zones exist in the shared database. Use ``CKFetchDatabaseChangesOperation`` to fetch shared record zones on receipt of the subscription's push notifications. Then fetch the changes in those zones using this operation. Regardless of which database you use, it's not necessary to perform fetches each time your app launches, or to schedule fetches at regular intervals.
+///
+/// To run the operation, add it to the corresponding database's operation queue. The operation executes its callbacks on a private serial queue.
+///
+/// The following example demonstrates how to create the operation, configure its callbacks, and execute it. For brevity, it omits the delete and operation completion callbacks.
+///
+/// ```swift
+/// // Create a dictionary that maps a record zone ID to its
+/// // corresponding zone configuration. The configuration
+/// // contains the server change token from the most recent
+/// // fetch of that record zone.
+/// NSMutableDictionary *configurations = [NSMutableDictionary new];
+/// for (CKRecordZoneID *recordZoneID in recordZoneIDs) {
+///     CKFetchRecordZoneChangesConfiguration *config =
+///         [CKFetchRecordZoneChangesConfiguration new];
+///     config.previousServerChangeToken = [tokenCache objectForKey:recordZoneID];
+///     [configurations setObject:config forKey:recordZoneID];
+/// }
+///
+/// // Create a fetch operation with an array of record zone IDs
+/// // and the zone configuration mapping dictionary.
+/// CKFetchRecordZoneChangesOperation *operation =
+///     [[CKFetchRecordZoneChangesOperation alloc]
+///      initWithRecordZoneIDs:recordZoneIDs
+///      configurationsByRecordZoneID:configurations];
+///
+/// // Process each changed record as CloudKit returns it.
+/// operation.recordChangedBlock = ^(CKRecord *record) {
+///     recordHandler(record);
+/// };
+///
+/// // Cache the change tokens that CloudKit provides as
+/// // the operation runs.
+/// operation.recordZoneChangeTokensUpdatedBlock = ^(CKRecordZoneID *recordZoneID,
+///                                                  CKServerChangeToken *token,
+///                                                  NSData *data) {
+///     [tokenCache setObject:token forKey:recordZoneID];
+/// };
+///
+/// // If the fetch for the current record zone completes
+/// // successfully, cache the final change token.
+/// operation.recordZoneFetchCompletionBlock = ^(CKRecordZoneID *recordZoneID,
+///                                              CKServerChangeToken *token,
+///                                              NSData *data, BOOL more,
+///                                              NSError *error) {
+///     if (error) {
+///         // Handle the error.
+///     } else {
+///         [tokenCache setObject:token forKey:recordZoneID];
+///     }
+/// };
+///
+/// // Set an appropriate QoS and add the operation to the shared
+/// // database's operation queue to execute it.
+/// operation.qualityOfService = NSQualityOfServiceUtility;
+/// [CKContainer.defaultContainer.sharedCloudDatabase addOperation:operation];
+/// ```
 API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
 @interface CKFetchRecordZoneChangesOperation : CKDatabaseOperation
 
+/// Creates an empty fetch record zone changes operation.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for fetching record zone changes.
+///
+/// - Parameters:
+///   - recordZoneIDs: The IDs of the record zones that you want to query for changes. You can specify `nil` for this parameter.
+///   - configurationsByRecordZoneID: A dictionary that maps record zone IDs to their corresponding configurations. You can specify `nil` for this parameter.
+///
+/// CloudKit configures the operation for retrieving all of the record zones that you specify. If you want to reduce the amount of data that CloudKit returns, provide zone configurations for each record zone.
 - (instancetype)initWithRecordZoneIDs:(NSArray<CKRecordZoneID *> *)recordZoneIDs configurationsByRecordZoneID:(nullable NSDictionary<CKRecordZoneID *, CKFetchRecordZoneChangesConfiguration *> *)configurationsByRecordZoneID API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0));
 
+/// The IDs of the record zones that contain the records to fetch.
+///
+/// Typically, you set the value of this property when you create the operation. If you intend to change the record zone IDs, update the value before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) NSArray<CKRecordZoneID *> *recordZoneIDs;
+
+/// A dictionary of configurations for fetching change operations by zone identifier.
 @property (nullable, copy, nonatomic) NSDictionary<CKRecordZoneID *, CKFetchRecordZoneChangesConfiguration *> *configurationsByRecordZoneID API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0));
 
-/*! @abstract Determines if the operation should fetch all changes from the server before completing.
- *
- *  @discussion When set to YES, this operation will send repeated requests to the server until all record changes have been fetched. @c recordZoneChangeTokensUpdatedBlock will be invoked periodically, to give clients an updated change token so that already-fetched record changes don't need to be re-fetched on a subsequent operation. @c recordZoneFetchCompletionBlock will only be called once and @c moreComing will always be NO.
- *
- *  When set to NO, it is the responsibility of the caller to issue subsequent fetch-changes operations when @c moreComing is YES in a @c recordZoneFetchCompletionBlock invocation.
- *
- *  @c fetchAllChanges is YES by default
- */
+/// A Boolean value that indicates whether to send repeated requests to the server.
+///
+/// If <doc://com.apple.documentation/documentation/swift/true>, the operation sends repeat requests to the server until it fetches all changes. CloudKit executes the handler you set on the ``CKFetchRecordZoneChangesOperation/recordZoneFetchResultBlock`` property with a change token after each request.
+///
+/// The default value is <doc://com.apple.documentation/documentation/swift/true>.
 @property (assign, nonatomic) BOOL fetchAllChanges;
 
-/*! @discussion If the replacement callback @c recordWasChangedBlock is set, this callback block is ignored.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute with the contents of a changed record.
+///
+/// The closure returns no value and takes the following parameter:
+///
+/// - The changed record. If you specify a value for the ``CKFetchRecordZoneChangesConfiguration/desiredKeys`` property, the record contains only the corresponding fields.
+///
+/// The operation executes this closure once for each record in the record zone with changes since the previous fetch request. Each time the closure executes, it executes serially with respect to the other closures of the operation. If there aren't any record changes, this closure doesn't execute.
+///
+/// Set this property before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^recordChangedBlock)(CKRecord *record) API_DEPRECATED("Use recordWasChangedBlock instead, which surfaces per-record errors", macos(10.12, 12.0), ios(10.0, 15.0), tvos(10.0, 15.0), watchos(3.0, 8.0));
 
-/*! @discussion If a record fails in post-processing (say, a network failure materializing a @c CKAsset record field), the per-record error will be passed here.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute with the results of retrieving a record change.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - The ID of the changed record to retrieve.
+/// - The changed record, or `nil` if CloudKit can't retrieve the record.
+///   If you specify a value for the ``CKFetchRecordZoneChangesConfiguration/desiredKeys`` property, the record contains only the corresponding fields.
+/// - An error that contains information about a problem, or `nil` if CloudKit retrieves the record successfully.
+///
+/// The operation executes this closure once for each record in the record zone with changes since the previous fetch request. Each time the closure executes, it executes serially with respect to the other closures of the operation. If there aren't any record changes, this closure doesn't execute.
+///
+/// Set this property before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^recordWasChangedBlock)(CKRecordID *recordID, CKRecord * _Nullable record, NSError * _Nullable error) API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) NS_REFINED_FOR_SWIFT;
 
-/*! @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The block to execute when a record no longer exists.
+///
+/// The block returns no value and takes the following parameters:
+///
+///   - term `recordID`: The deleted record's ID.
+///   - term `recordType`: The deleted record's type.
+///
+/// The operation executes this block once for each record the server deletes after the previous change token. Each time the block executes, it executes serially with respect to the other blocks of the operation. If there aren't any record deletions, this block doesn't execute.
+///
+///  Set this property before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^recordWithIDWasDeletedBlock)(CKRecordID *recordID, CKRecordType recordType);
 
-/*! @discussion Clients are responsible for saving this per-recordZone @c serverChangeToken and passing it in to the next call to @c CKFetchRecordZoneChangesOperation.
- *  Note that a fetch can fail partway. If that happens, an updated change token may be returned in this block so that already fetched records don't need to be re-downloaded on a subsequent operation.
- *  @c recordZoneChangeTokensUpdatedBlock will not be called after the last batch of changes in a zone; the @c recordZoneFetchCompletionBlock block will be called instead.
- *  The @c clientChangeTokenData from the most recent @c CKModifyRecordsOperation issued on this zone is also returned, or nil if none was provided.
- *  If the server returns a @c CKErrorChangeTokenExpired error, the @c serverChangeToken used for this record zone when initting this operation was too old and the client should toss its local cache and re-fetch the changes in this record zone starting with a nil @c serverChangeToken.
- *  @c recordZoneChangeTokensUpdatedBlock will not be called if @c fetchAllChanges is NO.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when the change token updates.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - The record zone's ID.
+/// - The new change token from the server. You can store this token locally and use it during subsequent fetch operations to limit the results to records that change after this operation executes.
+/// - The most recent client change token from the device. If the change token isn't the most recent change token you provided, the server might not have received the associated changes.
+///
+/// The operation executes this closure once for each retrieved change token. Each time the closure executes, it executes serially with respect to the other blocks of the operation.
+///
+/// Set this property before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^recordZoneChangeTokensUpdatedBlock)(CKRecordZoneID *recordZoneID, CKServerChangeToken * _Nullable serverChangeToken, NSData * _Nullable clientChangeTokenData);
+
+/// The closure to execute when a record zone's fetch finishes.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - The record zone's ID.
+/// - The change token to store and use in subsequent instances of ``CKFetchRecordZoneChangesOperation``.
+/// - The more recent client change token from the device. If the change token isn't the more recent change token you provided, the server might not have received the associated changes.
+/// - A Boolean that indicates whether this is the final record zone change. If ``CKFetchRecordZoneChangesOperation/fetchAllChanges`` is <doc://com.apple.documentation/documentation/swift/false>, it's the app's responsibility to create additional instances of ``CKFetchRecordZoneChangesOperation`` to fetch further changes.
+/// - An error object that contains information about a problem, or `nil` if the operation successfully retrieves the results.
+///
+/// The app is responsible for saving the change token at the end of the operation and providing it to future uses of ``CKFetchRecordZoneChangesOperation``. Each time the closure executes, it executes serially with respect to the other closures of the operation.
+///
+/// Set this property before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^recordZoneFetchCompletionBlock)(CKRecordZoneID *recordZoneID, CKServerChangeToken * _Nullable serverChangeToken, NSData * _Nullable clientChangeTokenData, BOOL moreComing, NSError * _Nullable recordZoneError) CK_SWIFT_DEPRECATED("Use recordZoneFetchResultBlock instead", macos(10.12, 12.0), ios(10.0, 15.0), tvos(10.0, 15.0), watchos(3.0, 8.0));
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion @c serverChangeToken-s previously returned via a @c recordZoneChangeTokensUpdatedBlock or @c recordZoneFetchCompletionBlock invocation, along with the record changes that preceded it, are valid even if there is a subsequent @c operationError
- *  If the error is @c CKErrorPartialFailure, the error's userInfo dictionary contains a dictionary of recordIDs and zoneIDs to errors keyed off of @c CKPartialErrorsByItemIDKey.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when the operation finishes.
+///
+/// The closure has no return value and takes the following parameter:
+///
+/// - An error object that contains information about a problem, or `nil` if CloudKit successfully retrieves the record zone changes.
+///
+/// This closure executes only once, and represents your final opportunity to process the results. The closure executes serially with respect to the other closures of the operation.
+/// 
+/// Set this property before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^fetchRecordZoneChangesCompletionBlock)(NSError * _Nullable operationError) CK_SWIFT_DEPRECATED("Use fetchRecordZoneChangesResultBlock instead", macos(10.12, 12.0), ios(10.0, 15.0), tvos(10.0, 15.0), watchos(3.0, 8.0));
 
 @end
 
 @interface CKFetchRecordZoneChangesOperation(Deprecated)
 
+/// Creates an operation for fetching record zone changes.
+///
+/// @DeprecationSummary {
+///     Use ``CKFetchRecordZoneChangesOperation/init(recordZoneIDs:configurationsByRecordZoneID:)`` instead.
+/// }
+/// 
+/// - Parameters:
+///   - recordZoneIDs: The IDs of the record zones that you want to query for changes.
+///   - optionsByRecordZoneID: A dictionary that maps record zone IDs to their corresponding options. You can specify `nil` for this parameter.
+///
+/// CloudKit configures the operation for retrieving all of the record zones that you specify. If you want to reduce the amount of data that CloudKit returns, provide zone options for each record zone.
 - (instancetype)initWithRecordZoneIDs:(NSArray<CKRecordZoneID *> *)recordZoneIDs optionsByRecordZoneID:(nullable NSDictionary<CKRecordZoneID *, CKFetchRecordZoneChangesOptions *> *)optionsByRecordZoneID
 API_DEPRECATED_WITH_REPLACEMENT("initWithRecordZoneIDs:configurationsByRecordZoneID:", macos(10.12, 10.14), ios(10.0, 12.0), tvos(10.0, 12.0), watchos(3.0, 5.0));
 
+/// Configuration options for each record zone that the operation retrieves.
+///
+/// @DeprecationSummary {
+///     Use ``CKFetchRecordZoneChangesOperation/configurationsByRecordZoneID`` instead.
+/// }
+/// 
+/// You can associate each record zone ID with options that define what CloudKit fetches for that record zone.  See ``CKFetchRecordZoneChangesOperation/ZoneOptions`` for more information.
 @property (nullable, copy, nonatomic) NSDictionary<CKRecordZoneID *, CKFetchRecordZoneChangesOptions *> *optionsByRecordZoneID
 API_DEPRECATED_WITH_REPLACEMENT("configurationsByRecordZoneID", macos(10.12, 10.14), ios(10.0, 12.0), tvos(10.0, 12.0), watchos(3.0, 5.0));
 @end
 
 
+/// A configuration object that describes the information to fetch from a record zone.
 API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 // NS_SWIFT_SENDABLE on macos(13.3), macCatalyst(16.4), ios(16.4), tvos(16.4), watchos(9.4)
 @interface CKFetchRecordZoneChangesConfiguration : NSObject <NSSecureCoding, NSCopying>
 
+/// The token that identifies the starting point for retrieving changes.
+///
+/// Each fetch request returns a unique token in addition to any changes. CloudKit passes the token to your ``CKFetchRecordZoneChangesOperation/recordZoneFetchResultBlock`` handler. During a subsequent fetch request, providing the previous token causes the server to return only the changes since the previous fetch request. Tokens are opaque values that you can write to disk safely and reuse later.
 @property (nullable, copy) CKServerChangeToken *previousServerChangeToken;
 
+/// The maximum number of records to fetch from the record zone.
+///
+/// Use this property to limit the number of results in situations where you expect a large number of records. The default value is 0, which causes the server to return an appropriate number of records using dynamic conditions.
+///
+/// When the number of records that CloudKit returns exceeds this limit, the operation sets the `moreComing` property to <doc://com.apple.documentation/documentation/swift/true> when executing the ``CKFetchRecordZoneChangesOperation/recordZoneFetchResultBlock`` handler.
 @property (assign) NSUInteger resultsLimit;
 
-/*! @abstract Declares which user-defined keys should be fetched and added to the resulting CKRecords.
- *
- *  @discussion If nil, declares the entire record should be downloaded. If set to an empty array, declares that no user fields should be downloaded.
- *  Defaults to @c nil.
- */
+/// The fields to fetch for the requested records.
+///
+/// Use this property to limit the amount of data that CloudKit retrieves for each record during the fetch operation. This property contains an array of strings, each of which is the name of a field from the target records. When you retrieve a record, CloudKit only includes fields with names that match one of the keys in this property. The default value is `nil`, which causes CloudKit to fetch all of the record's keys.
+///
+/// Because you can fetch records of different types, configure the array to include the merged set of all field names for the requested records and at least one field name from each record type.
+///
+/// If you intend to specify the desired set of keys, set the value of this property before executing the operation or submitting it to a queue.
 @property (nullable, copy) NSArray<CKRecordFieldKey> *desiredKeys;
 @end
 
 
 
+/// A configuration object that describes the information to fetch from a record zone.
+///
+/// @DeprecationSummary {
+///     Use ``CKFetchRecordZoneChangesOperation/ZoneConfiguration`` instead.
+/// }
 API_DEPRECATED_WITH_REPLACEMENT("CKFetchRecordZoneChangesConfiguration", macos(10.12, 10.14), ios(10.0, 12.0), tvos(10.0, 12.0), watchos(3.0, 5.0))
 @interface CKFetchRecordZoneChangesOptions : NSObject <NSSecureCoding, NSCopying>
+
+/// The token that identifies the starting point for retrieving changes.
+///
+/// Each fetch request returns a unique token in addition to any changes. CloudKit passes the token to your ``CKFetchRecordZoneChangesOperation/recordZoneFetchCompletionBlock`` handler. During a subsequent fetch request, providing the previous token causes the server to return only the changes since the previous fetch request. Tokens are opaque values that you can write to disk safely and reuse later.
 @property (nullable, copy, nonatomic) CKServerChangeToken *previousServerChangeToken;
+
+/// The maximum number of records to fetch from the record zone.
+///
+/// Use this property to limit the number of results in situations where you expect a large number of records. The default value is 0, which causes the server to return an appropriate number of records using dynamic conditions.
+///
+/// When the number of records that CloudKit returns exceeds this limit, the operation sets the `moreComing` property to <doc://com.apple.documentation/documentation/swift/true> when executing the ``CKFetchRecordZoneChangesOperation/recordZoneFetchCompletionBlock`` handler.
 @property (assign, nonatomic) NSUInteger resultsLimit;
+
+/// The fields to fetch for the requested records.
+///
+/// Use this property to limit the amount of data that CloudKit retrieves for each record during the fetch operation. This property contains an array of strings, each of which is the name of a field from the target records. When you retrieve a record, CloudKit only includes fields with names that match one of the keys in this property. The default value is `nil`, which causes CloudKit to fetch all of the record's keys.
+///
+/// Because you can fetch records of different types, configure the array to include the merged set of all field names for the requested records and at least one field name from each record type.
+///
+/// If you intend to specify the desired set of keys, set the value of this property before executing the operation or submitting it to a queue.
 @property (nullable, copy, nonatomic) NSArray<CKRecordFieldKey> *desiredKeys;
 @end
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordZonesOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordZonesOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordZonesOperation.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordZonesOperation.h	2026-02-13 10:47:06
@@ -11,34 +11,67 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An operation for retrieving record zones from a database.
+///
+/// Use this operation object to fetch record zones so that you can ascertain their capabilities.
+///
+/// If you assign a handler to the <doc://com.apple.documentation/documentation/foundation/operation/completionblock> property of the operation, CloudKit calls it after the operation executes and returns its results. You can use the handler to perform any housekeeping tasks that relate to the operation, but don't use it to process the results of the operation. The handler you specify should manage any failures, whether due to an error or an explicit cancellation.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 @interface CKFetchRecordZonesOperation : CKDatabaseOperation
 
+/// Returns an operation for fetching all record zones in the current database.
+///
+/// Assign a value to the ``CKFetchRecordZonesOperation/fetchRecordZonesCompletionBlock`` property of the operation that this method returns so that you can process the results.
 + (instancetype)fetchAllRecordZonesOperation;
 
+/// Creates an empty fetch zones operation.
+///
+/// You must set the ``CKFetchRecordZonesOperation/recordZoneIDs`` property before you execute the operation.
+///
+/// After creating the operation, assign a value to the ``CKFetchRecordZonesOperation/fetchRecordZonesCompletionBlock`` property so you can process the results.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for fetching the specified record zones.
+///
+/// - Parameters:
+///   - zoneIDs: An array of ``CKRecordZone/ID`` objects that represents the zones you want to retrieve. If you provide an empty array, you must set the ``CKFetchRecordZonesOperation/recordZoneIDs`` property before you execute the operation.
+///
+/// After creating the operation, assign a value to the ``CKFetchRecordZonesOperation/fetchRecordZonesCompletionBlock`` property so you can process the results.
 - (instancetype)initWithRecordZoneIDs:(NSArray<CKRecordZoneID *> *)zoneIDs;
 
+/// The IDs of the record zones to retrieve.
+///
+/// Use this property to view or change the IDs of the record zones you want to retrieve. If you intend to change the value of this property, do so before you execute the operation or submit the operation to a queue.
+///
+/// If you use the operation that ``CKFetchRecordZonesOperation/fetchAllRecordZonesOperation()`` returns, CloudKit ignores the contents of this property and sets its value to `nil`.
 @property (nullable, copy, nonatomic) NSArray<CKRecordZoneID *> *recordZoneIDs;
 
-/*! @abstract Called on success or failure for each record zone.
- *
- *  @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute as the operation fetches individual record zones.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - The ID of the record zone.
+/// - The record zone, or `nil` if CloudKit can't fetch the record zone.
+/// - If CloudKit can't fetch the record zone, this parameter provides information about the failure; otherwise, it's `nil`.
+///
+/// The operation executes this closure once for each record zone ID in the ``CKFetchRecordZonesOperation/recordZoneIDs`` property. Each time the closure executes, it executes serially with respect to the other closures of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perRecordZoneCompletionBlock)(CKRecordZoneID *zoneID, CKRecordZone * _Nullable recordZone, NSError * _Nullable error) API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) NS_REFINED_FOR_SWIFT;
 
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  If the error is @c CKErrorPartialFailure, the error's userInfo dictionary contains a dictionary of zoneIDs to errors keyed off of @c CKPartialErrorsByItemIDKey.
- *  @c recordZonesByZoneID and any @c CKPartialErrorsByItemIDKey errors are repeats of the data sent back in previous @c perRecordZoneCompletionBlock invocations
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute after CloudKit retrieves all of the record zones.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - A dictionary that maps the zone IDs you request to the results. The keys in the dictionary are ``CKRecordZone/ID`` objects, and the values are the corresponding ``CKRecordZone`` objects that CloudKit returns.
+/// - If CloudKit can't retrieve any of the record zones, an error that provides information about the failure; otherwise, `nil`.
+///
+/// The operation executes the closure only once, and it's your only chance to process the results. You must provide a closure capable of executing on a background thread, so any tasks that require access to the main thread must redirect accordingly.
+///
+/// The closure reports an error of type ``CKError/Code/partialFailure`` when it retrieves only some of the record zones successfully. The <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary of the error contains a ``CKPartialErrorsByItemIDKey`` key that has a dictionary as its value. The keys of the dictionary are the IDs of the record zones that the operation can't retrieve, and the corresponding values are errors that contain information about the failures.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^fetchRecordZonesCompletionBlock)(NSDictionary<CKRecordZoneID *, CKRecordZone *> * _Nullable recordZonesByZoneID, NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use fetchRecordZonesResultBlock instead", macos(10.10, 12.0), ios(8.0, 15.0), tvos(9.0, 15.0), watchos(3.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordsOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordsOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordsOperation.h	2025-11-09 04:37:40
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchRecordsOperation.h	2026-02-13 10:47:07
@@ -11,52 +11,99 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An operation for retrieving records from a database.
+///
+/// Use this operation to retrieve the entire contents of each record or only a subset of its contained values. As records become available, the operation object reports progress about the state of the operation to several different blocks, which you can use to process the results.
+///
+/// Fetching records is a common use of CloudKit, even if your app doesn't cache record IDs locally. For example, when you fetch a record related to the current record through a ``CKRecord/Reference`` object, you use the ID in the reference to perform the fetch.
+///
+/// The handlers you assign to process the fetched records execute serially on an internal queue that the fetch operation manages. You must provide handlers capable of executing on a background thread, so any tasks that require access to the main thread must redirect accordingly.
+///
+/// In addition to data records, a fetch records operation can fetch the current user record. The ``fetchCurrentUserRecordOperation()`` method returns a specially configured operation object that retrieves the current user record. That record is a standard ``CKRecord`` object that has no content initially. You can add data to the user record and save it as necessary. Don't store sensitive personal information, such as passwords, in the user record because other users of your app can access the discoverable user record in a public database. If you must store sensitive information about a user, do so in a separate record that is accessible only to that user.
+///
+/// If you assign a closure to the <doc://com.apple.documentation/documentation/foundation/operation/completionblock> property of the operation object, CloudKit calls it after the operation executes and returns its results. Use a closure to perform any housekeeping tasks for the operation, but don't use it to process the results of the operation. The closure you specify should handle the failure of the operation to complete its task, whether due to an error or an explicit cancellation.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 @interface CKFetchRecordsOperation : CKDatabaseOperation
 
+/// Creates an empty fetch operation.
+///
+/// You must set the ``CKFetchRecordsOperation/recordIDs`` property before you execute the operation.
+///
+/// A fetch operation retrieves all of a record's fields, including any assets that those fields reference. If you want to minimize the amount of data that the operation returns, configure the ``CKFetchRecordsOperation/desiredKeys-34l1l`` property with only the keys that contain the values that you have an interest in.
+///
+/// After initializing the operation, you must associate at least one progress handler with the operation (excluding the completion handler) to process the results.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates a fetch operation for retrieving the records with the specified IDs.
+///
+/// - Parameters:
+///   - recordIDs: An array of ``CKRecord/ID`` objects that represents the records you want to retrieve. If you provide an empty array, you must set the ``CKFetchRecordsOperation/recordIDs`` property before you execute the operation.
+///
+/// A fetch operation retrieves all of a record's fields, including any assets that those fields reference. If you want to minimize the amount of data that the operation returns, configure the ``CKFetchRecordsOperation/desiredKeys-34l1l`` property with only the keys that contain the values that you have an interest in.
+///
+/// After initializing the operation, you must associate at least one progress handler with the operation (excluding the completion handler) to process the results.
 - (instancetype)initWithRecordIDs:(NSArray<CKRecordID *> *)recordIDs;
 
+/// Returns a fetch operation for retrieving the current user record.
+///
+/// The returned operation object searches for the single record that corresponds to the current user record. You must associate at least one progress handler with the operation object (excluding the completion handler) to process the results.
 + (instancetype)fetchCurrentUserRecordOperation;
 
+/// The record IDs of the records to fetch.
+///
+/// Use this property to view or change the IDs of the records you want to retrieve. If you use the operation that ``CKFetchRecordsOperation/fetchCurrentUserRecordOperation()`` returns, CloudKit ignores the contents of this property and sets its value to `nil`.
+///
+/// If you intend to specify a value other than `nil`, do so before you execute the operation or add the operation to a queue. The records you fetch don't need to be in the same record zone. The record ID for each record provides the zone information that CloudKit needs to fetch the corresponding record.
 @property (nullable, copy, nonatomic) NSArray<CKRecordID *> *recordIDs;
 
-/*! @abstract Declares which user-defined keys should be fetched and added to the resulting CKRecords.
- *
- *  @discussion If nil, declares the entire record should be downloaded. If set to an empty array, declares that no user fields should be downloaded.
- *  Defaults to @c nil.
- */
+/// The fields of the records to fetch.
+///
+/// Use this property to limit the amount of data that CloudKit returns for each record during the fetch operation. When CloudKit returns a record, it only includes fields with names that match one of the keys in this property. The property's default value is `nil`, which instructs CloudKit to return all of a record's keys.
+///
+/// If you're retrieving records of different types, make sure the array includes the fields you want from all of the various record types that the operation can return.
+///
+/// If you intend to specify a value other than `nil`, do so before you execute the operation or add the operation to a queue.
 @property (nullable, copy, nonatomic) NSArray<CKRecordFieldKey> *desiredKeys;
 
-/*! @abstract Indicates the progress for each record.
- *
- *  @discussion This method is called at least once with a progress of 1.0 for every record. Intermediate progress is only reported for records that contain assets.
- *  It is possible for progress to regress when a retry is automatically triggered.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute with progress information for individual records.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The ID of the record to retrieve.
+/// - The amount of data, as a percentage, that CloudKit downloads for the record. The range is `0.0` to `1.0`, where `0.0` indicates that CloudKit hasn't downloaded anything, and `1.0` means the download is complete.
+///
+/// The fetch operation executes this closure one or more times for each record ID in the ``CKFetchRecordsOperation/recordIDs`` property. Each time the closure executes, it executes serially with respect to the other progress closures of the operation. You can use this closure to track the ongoing progress of the download operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or add the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perRecordProgressBlock)(CKRecordID *recordID, double progress);
 
-/*! @abstract Called on success or failure for each record.
- *
- *  @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when a record becomes available.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The record, or `nil` if CloudKit can't retrieve the record.
+/// - The ID of the record.
+/// - If CloudKit can't retrieve the record, an error that provides information about the failure; otherwise, `nil`.
+///
+/// The fetch operation executes this closure once for each record ID in the ``CKFetchRecordsOperation/recordIDs`` property. Each time the closure executes, it executes serially with respect to the other progress closures of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perRecordCompletionBlock)(CKRecord * _Nullable record, CKRecordID * _Nullable recordID, NSError * _Nullable error)
 CK_SWIFT_DEPRECATED("Use perRecordResultBlock instead", macos(10.10, 12.0), ios(8.0, 15.0), tvos(9.0, 15.0), watchos(3.0, 8.0));
 
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  If the error is @c CKErrorPartialFailure, the error's userInfo dictionary contains a dictionary of recordIDs to errors keyed off of @c CKPartialErrorsByItemIDKey.
- *  @c recordsByRecordID and any @c CKPartialErrorsByItemIDKey errors are repeats of the data sent back in previous @c perRecordCompletionBlock invocations
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute after CloudKit retrieves all of the records.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - A dictionary that contains the records that CloudKit retrieves. Each key in the dictionary is a ``CKRecord/ID`` object that corresponds to a record you request. The value of each key is the actual ``CKRecord`` object that CloudKit returns.
+/// - If CloudKit can't retrieve any of the records, an error that provides information about the failure; otherwise, `nil`.
+///
+/// The fetch operation executes this closure only once, and it's your final opportunity to process the results. The closure executes after all of the individual progress closures, but before the operation's completion closure. The closure executes serially with respect to the other progress closures of the operation.
+///
+/// The closure reports an error of type ``CKError/Code/partialFailure`` when it retrieves only some of the records successfully. The <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary of the error contains a ``CKPartialErrorsByItemIDKey`` key that has a dictionary as its value. The keys of the dictionary are the IDs of the records that the operation can't retrieve, and the corresponding values are errors that contain information about the failures.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^fetchRecordsCompletionBlock)(NSDictionary<CKRecordID * , CKRecord *> * _Nullable recordsByRecordID, NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use fetchRecordsResultBlock instead", macos(10.10, 12.0), ios(8.0, 15.0), tvos(9.0, 15.0), watchos(3.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchShareMetadataOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchShareMetadataOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchShareMetadataOperation.h	2025-11-09 04:37:40
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchShareMetadataOperation.h	2026-02-13 11:10:17
@@ -12,52 +12,122 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-/*! @class CKFetchShareMetadataOperation
- *
- *  @abstract Fetch the @c CKShareMetadata for a share URL.
- *
- *  @discussion Since you can't know what container this share is in before you fetch its metadata, you may run this operation in any container you have access to
- */
+/// An operation that fetches metadata for one or more shares.
+///
+/// Use this operation to fetch the metadata for one or more shares. A share's metadata contains the share and details about the user's participation. Fetch metadata when you want to manually accept participation in a share using ``CKAcceptSharesOperation``.
+///
+/// For a shared record hierarchy, the fetched metadata includes the record ID of the share's root record. Set ``shouldFetchRootRecord`` to <doc://com.apple.documentation/documentation/swift/true> to fetch the entire root record. You can further customize this behavior using ``rootRecordDesiredKeys-3xrex`` to specify which fields you want to include in your fetch. This functionality isn't applicable for a shared record zone because, unlike a shared record hierarchy, it doesn't have a nominated root record.
+///
+/// To run the operation, add it to any container's operation queue. Returned metadata includes the ID of the container that stores the share. The operation executes its callbacks on a private serial queue.
+///
+/// The operation calls ``perShareMetadataBlock`` once for each URL you provide, and CloudKit returns the metadata, or an error if the fetch fails. CloudKit also batches per-URL errors. If the operation completes with errors, it returns a ``CKError/partialFailure`` error. The error stores individual errors in its <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary. Use the ``CKPartialErrorsByItemIDKey`` key to extract them.
+///
+/// When all of the following conditions are true, CloudKit returns a ``CKError/participantMayNeedVerification`` error:
+///
+/// - There are pending participants that don't have matched iCloud accounts.
+/// - The current user has an active iCloud account and isn't an existing participant (pending or otherwise).
+///
+/// On receipt of this error, call <doc://com.apple.documentation/documentation/uikit/uiapplication/open(_:options:completionhandler:)> with the share's URL to allow CloudKit to verify the user.
+///
+/// The following example demonstrates how to create the operation, configure it, and then execute it using the default container's operation queue:
+///
+/// ```swift
+/// func fetchShareMetadata(for shareURLs: [URL],
+///     completion: @escaping (Result<[URL: CKShare.Metadata], any Error>) -> Void) {
+///
+///     var cache = [URL: CKShare.Metadata]()
+///
+///     // Create the fetch operation using the share URLs that
+///     // the caller provides to the method.
+///     let operation = CKFetchShareMetadataOperation(shareURLs: shareURLs)
+///
+///     // To reduce network requests, request that CloudKit
+///     // includes the root record in the metadata it returns.
+///     operation.shouldFetchRootRecord = true
+///
+///     // Cache the metadata that CloudKit returns using the
+///     // share URL. This implementation ignores per-metadata
+///     // fetch errors and handles any errors in the completion
+///     // closure instead.
+///     operation.perShareMetadataBlock = { url, metadata, _ in
+///         guard let metadata = metadata else { return }
+///         cache[url] = metadata
+///     }
+///
+///     // If the operation fails, return the error to the caller.
+///     // Otherwise, return the array of participants.
+///     operation.fetchShareMetadataCompletionBlock = { error in
+///         if let error = error {
+///             completion(.failure(error))
+///         } else {
+///             completion(.success(cache))
+///         }
+///     }
+///
+///     // Set an appropriate QoS and add the operation to the
+///     // container's queue to execute it.
+///     operation.qualityOfService = .userInitiated
+///     CKContainer.default().add(operation)
+/// }
+/// ```
 API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
 @interface CKFetchShareMetadataOperation : CKOperation
 
+/// Creates an empty fetch share metadata operation.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for fetching the metadata for the specified shares.
+///
+/// - Parameters:
+///   - shareURLs: The URLs of the shares. If you specify `nil`, you must assign a value to the ``CKFetchShareMetadataOperation/shareURLs`` property before you execute the operation.
+///
+/// After creating the operation, assign a handler to the ``CKFetchShareMetadataOperation/fetchShareMetadataCompletionBlock`` property to process the results.
 - (instancetype)initWithShareURLs:(NSArray<NSURL *> *)shareURLs;
 
+/// The URLs of the shares to fetch.
+///
+/// Use this property to view or change the URLs of the shares to fetch. If you intend to specify or change this property's value, do so before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) NSArray<NSURL *> *shareURLs;
 
-/*! @abstract If set to YES, the resulting @c CKShareMetadata will have a @c rootRecord object filled out.
- *
- *  @discussion Defaults to @c NO.
- *  The resulting @c CKShareMetadata will have a @c rootRecordID property regardless of the value of this property.
- */
+/// A Boolean value that indicates whether to retrieve the root record.
+///
+/// For a shared record hierarchy, set this property to <doc://com.apple.documentation/documentation/swift/true> to include the root record in the fetched share metadata. CloudKit ignores this property for a shared record zone because, unlike a shared record hierarchy, it doesn't have a nominated root record.
+///
+/// The default value is <doc://com.apple.documentation/documentation/swift/false>.
 @property (assign, nonatomic) BOOL shouldFetchRootRecord;
 
-/*! @abstract Declares which user-defined keys should be fetched and added to the resulting @c rootRecord.
- *
- *  @discussion Only consulted if @c shouldFetchRootRecord is @c YES.
- *  If nil, declares the entire root record should be downloaded. If set to an empty array, declares that no user fields should be downloaded.
- *  Defaults to @c nil.
- */
+/// The fields to return when fetching the root record.
+///
+/// For a shared record hierarchy, and when ``CKFetchShareMetadataOperation/shouldFetchRootRecord`` is <doc://com.apple.documentation/documentation/swift/true>, set this property to specify which of the root record's fields the operation fetches. Use `nil` to fetch the entire record. CloudKit ignores this property for a shared record zone because, unlike a hierarchy, it doesn't have a nominated root record.
+///
+/// The default value is `nil`.
 @property (nullable, copy, nonatomic) NSArray<CKRecordFieldKey> *rootRecordDesiredKeys;
 
-/*! @abstract Called once for each share URL that the server processed
- *
- *  @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute as the operation fetches individual shares.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - The share's URL.
+/// - The share metadata, or `nil` if CloudKit can't fetch the metadata.
+/// - If CloudKit can't fetch the share metadata, this parameter provides information about the failure; otherwise, it's `nil`.
+///
+/// The operation executes this closure once for each URL in the ``CKFetchShareMetadataOperation/shareURLs`` property. Each time the closure executes, it executes serially with respect to the other closures of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perShareMetadataBlock)(NSURL *shareURL, CKShareMetadata * _Nullable shareMetadata, NSError * _Nullable error)
 CK_SWIFT_DEPRECATED("Use perShareMetadataResultBlock instead", macos(10.12, 12.0), ios(10.0, 15.0), tvos(10.0, 15.0), watchos(3.0, 8.0));
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  If the error is @c CKErrorPartialFailure, the error's userInfo dictionary contains a dictionary of shareURLs to errors keyed off of @c CKPartialErrorsByItemIDKey.  These errors are repeats of those sent back in previous @c perShareMetadataBlock invocations
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when the operation finishes.
+///
+/// The closure returns no value and takes the following parameter:
+///
+/// - An error that contains information about a problem, or `nil` if CloudKit successfully fetches the metadatas.
+///
+/// The operation executes this closure only once. The closure executes on a background queue, so any tasks that require access to the main queue must dispatch accordingly.
+///
+/// The closure reports an error of type ``CKError/Code/partialFailure`` when it can't fetch some of the metadatas. The `userInfo` dictionary of the error contains a ``CKPartialErrorsByItemIDKey`` key that has a dictionary as its value. The keys of the dictionary identify the metadatas that CloudKit can't fetch, and the corresponding values are errors that contain information about the failures.
+///
+/// Set this property's value before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^fetchShareMetadataCompletionBlock)(NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use fetchShareMetadataResultBlock instead", macos(10.12, 12.0), ios(10.0, 15.0), tvos(10.0, 15.0), watchos(3.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchShareParticipantsOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchShareParticipantsOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchShareParticipantsOperation.h	2025-11-09 04:37:40
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchShareParticipantsOperation.h	2026-02-13 10:44:53
@@ -11,39 +11,116 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An operation that converts user identities into share participants.
+///
+/// Participants are a fundamental part of sharing in CloudKit. A participant provides information about a user and their participation in a share, which includes their identity, acceptance status, role, and permissions. The acceptance status manages the user's visibilty of the shared records. The role and permissions control what actions the user can perform on those records.
+///
+/// You don't create participants. Instead, create an instance of ``CKUserIdentity/LookupInfo`` for each user. Provide the user's email address or phone number, and then use this operation to convert them into participants that you can add to a share. CloudKit limits the number of participants in a share to 100, and each participant must have an active iCloud account.
+///
+/// - Note: <doc://com.apple.documentation/documentation/uikit/uicloudsharingcontroller> provides a consistent and familiar experience for managing a share's participants and their permissions. Only use this operation when you want to provide an app-specific approach.
+///
+/// CloudKit queries iCloud for corresponding accounts as part of the operation. If it doesn't find an account, the server updates the participant's ``CKShare/Participant/userIdentity`` to reflect that by setting the ``CKUserIdentity/hasiCloudAccount`` property to <doc://com.apple.documentation/documentation/swift/false>. CloudKit associates a participant with their iCloud account when they accept the share.
+///
+/// Anyone with the URL of a public share can become a participant in that share. For a private share, the owner manages its participants. A participant can't accept a private share unless the owner adds them first.
+///
+/// To run the operation, add it to the container's operation queue. The operation executes its callbacks on a private serial queue.
+///
+/// The following example demonstrates how to create the operation, configure it, and then execute it using the default container's operation queue:
+///
+/// ```swift
+/// func fetchParticipants(for lookupInfos: [CKUserIdentity.LookupInfo],
+///     completion: @escaping (Result<[CKShare.Participant], any Error>) -> Void) {
+///
+///     var participants = [CKShare.Participant]()
+///
+///     // Create the operation using the lookup objects
+///     // that the caller provides to the method.
+///     let operation = CKFetchShareParticipantsOperation(
+///         userIdentityLookupInfos: lookupInfos)
+///
+///     // Collect the participants as CloudKit generates them.
+///     operation.shareParticipantFetchedBlock = { participant in
+///         participants.append(participant)
+///     }
+///
+///     // If the operation fails, return the error to the caller.
+///     // Otherwise, return the array of participants.
+///     operation.fetchShareParticipantsCompletionBlock = { error in
+///         if let error = error {
+///             completion(.failure(error))
+///         } else {
+///             completion(.success(participants))
+///         }
+///     }
+///
+///     // Set an appropriate QoS and add the operation to the
+///     // container's queue to execute it.
+///     operation.qualityOfService = .userInitiated
+///     CKContainer.default().add(operation)
+/// }
+/// ```
+///
+/// The operation calls ``shareParticipantFetchedBlock`` once for each item you provide, and CloudKit returns the participant, or an error if it can't generate a particpant. CloudKit also batches per-participant errors. If the operation completes with errors, it returns a ``CKError/partialFailure`` error. The error stores the individual errors in its <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary. Use the ``CKPartialErrorsByItemIDKey`` key to extract them.
 API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
 @interface CKFetchShareParticipantsOperation : CKOperation
 
+/// Creates an empty operation.
+///
+/// You can use this operation only once.
+///
+/// - Note: If you don't set ``CKFetchShareParticipantsOperation/userIdentityLookupInfos`` prior to executing the operation, it returns immediately with no results.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for generating share participants from the specified user data.
+///
+/// - Parameters:
+///   - userIdentityLookupInfos: The user data for the participants. If you specify `nil`, you must assign a value to the ``CKFetchShareParticipantsOperation/userIdentityLookupInfos`` property before you execute this operation.
+///
+/// After you create the operation, assign a handler to the ``CKFetchShareParticipantsOperation/fetchShareParticipantsCompletionBlock`` property to process the results.
 - (instancetype)initWithUserIdentityLookupInfos:(NSArray<CKUserIdentityLookupInfo *> *)userIdentityLookupInfos;
 
+/// The user data for the participants.
+///
+/// Use this property to view or change the participants user data. If you intend to specify or change the value of this property, do so before you execute the operation or submit it to a queue.
+///
+/// - Note: If you don't set ``CKFetchShareParticipantsOperation/userIdentityLookupInfos`` prior to executing the operation, it returns immediately with no results.
 @property (nullable, copy, nonatomic) NSArray<CKUserIdentityLookupInfo *> *userIdentityLookupInfos;
 
-/*! @abstract Called once for each share participant created from a submitted user identity lookup info.
- *
- *  @discussion If the replacement callback @c perShareParticipantCompletionBlock is set, this callback block is ignored.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute as the operation generates individual participants.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - The participant that the operation generates.
+///
+/// The operation executes this closure once for each item of user data in the ``CKFetchShareParticipantsOperation/userIdentityLookupInfos`` property. Each time the closure executes, it executes serially with respect to the other closures of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^shareParticipantFetchedBlock)(CKShareParticipant *participant) API_DEPRECATED("Use perShareParticipantCompletionBlock instead, which surfaces per-share-participant errors", macos(10.12, 12.0), ios(10.0, 15.0), tvos(10.0, 15.0), watchos(3.0, 8.0));
 
-/*! @abstract Called once for each lookup info.
- *
- *  @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute as the operation generates individual participants.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - The lookup info of the share participant.
+/// - The generated share participant, or `nil` if CloudKit can't generate the share participant.
+/// - If CloudKit can't generate the share participant, this parameter provides information about the failure; otherwise, it's `nil`.
+///
+/// The operation executes this closure once for each item of user data in the ``CKFetchShareParticipantsOperation/userIdentityLookupInfos`` property. Each time the closure executes, it executes serially with respect to the other closures of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perShareParticipantCompletionBlock)(CKUserIdentityLookupInfo *lookupInfo, CKShareParticipant * _Nullable participant, NSError * _Nullable error) NS_REFINED_FOR_SWIFT;
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  If the error is @c CKErrorPartialFailure, the error's userInfo dictionary contains a dictionary of lookup infos to errors keyed off of @c CKPartialErrorsByItemIDKey.  These errors are repeats of those sent back in previous @c perShareParticipantCompletionBlock invocations
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when the operation finishes.
+///
+/// The closure returns no value and takes the following parameter:
+///
+/// - An error that contains information about a problem, or `nil` if CloudKit successfully generates the participants.
+///
+/// The operation executes this closure only once. The closure executes on a background queue, so any tasks that require access to the main queue must dispatch accordingly.
+///
+/// The closure reports an error of type ``CKError/Code/partialFailure`` when it can't generate some of the participants. The `userInfo` dictionary of the error contains a ``CKPartialErrorsByItemIDKey`` key that has a dictionary as its value. The keys of the dictionary identify the participants that CloudKit can't generate, and the corresponding values are errors that contain information about the failures.
+///
+/// Set this property's value before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^fetchShareParticipantsCompletionBlock)(NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use fetchShareParticipantsResultBlock instead", macos(10.12, 12.0), ios(10.0, 15.0), tvos(10.0, 15.0), watchos(3.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchSubscriptionsOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchSubscriptionsOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchSubscriptionsOperation.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchSubscriptionsOperation.h	2026-02-13 10:47:06
@@ -12,33 +12,66 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An operation for fetching subscriptions.
+///
+/// A fetch subscriptions operation retrieves subscriptions (with IDs you already know) from iCloud and can fetch all subscriptions for the current user.
+///
+/// You might fetch subscriptions so you can examine or modify their parameters — for example, to adjust the delivery options for push notifications that the subscription generates.
+///
+/// If you assign a handler to the <doc://com.apple.documentation/documentation/foundation/operation/completionblock> property, the operation calls it after it executes and passes it the results. Use the handler to perform any housekeeping tasks for the operation. The handler you specify should manage any failures, whether due to an error or an explicit cancellation.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(6.0))
 @interface CKFetchSubscriptionsOperation : CKDatabaseOperation
 
+/// Returns an operation that fetches all of the user's subscriptions.
+///
+/// After creating the operation, set the ``CKFetchSubscriptionsOperation/fetchSubscriptionCompletionBlock-207ep`` property to process the results.
 + (instancetype)fetchAllSubscriptionsOperation;
 
+/// Creates an empty fetch subscriptions operation.
+///
+/// You must set the ``CKFetchSubscriptionsOperation/subscriptionIDs-714ct`` property before you execute the operation.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for fetching the specified subscriptions.
+///
+/// - Parameters:
+///   - subscriptionIDs: An array of strings where each one is an ID of a subscription that you want to retrieve. This parameter sets the ``CKFetchSubscriptionsOperation/subscriptionIDs-714ct`` property's value. If you specify `nil`, you must set the `subscriptionIDs` property before you execute the operation.
+///
+/// After creating the operation, assign a block to the ``CKFetchSubscriptionsOperation/fetchSubscriptionCompletionBlock-207ep`` property to process the results.
 - (instancetype)initWithSubscriptionIDs:(NSArray<CKSubscriptionID> *)subscriptionIDs;
 
+/// The IDs of the subscriptions to fetch.
+///
+/// Use this property to view or change the IDs of the subscriptions to fetch. Each element of the array is a string that represents the ID of a subscription. If you intend to modify this property's value, do so before you execute the operation or submit it to a queue.
+///
+/// If you use the ``CKFetchSubscriptionsOperation/fetchAllSubscriptionsOperation()`` method to create the operation, CloudKit ignores this property's value and sets it to `nil`.
 @property (nullable, copy, nonatomic) NSArray<CKSubscriptionID> *subscriptionIDs;
 
-/*! @abstract Called on success or failure for each subscriptionID.
- *
- *  @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute as the operation fetches individual subscriptions.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - The ID of the subscription.
+/// - The subscription, or `nil` if CloudKit can't fetch the subscription.
+/// - If CloudKit can't fetch the subscription, this parameter provides information about the failure; otherwise, it's `nil`.
+///
+/// The operation executes this closure once for each subscription ID in the ``CKFetchSubscriptionsOperation/subscriptionIDs-714ct`` property. Each time the closure executes, it executes serially with respect to the other closures of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perSubscriptionCompletionBlock)(CKSubscriptionID subscriptionID, CKSubscription * _Nullable subscription, NSError * _Nullable error) API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) NS_REFINED_FOR_SWIFT;
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  If the error is @c CKErrorPartialFailure, the error's userInfo dictionary contains a dictionary of subscriptionID to errors keyed off of @c CKPartialErrorsByItemIDKey.
- *  @c subscriptionsBySubscriptionID and any @c CKPartialErrorsByItemIDKey errors are repeats of the data sent back in previous @c perSubscriptionCompletionBlock invocations
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The block to execute after the operation fetches the subscriptions.
+///
+/// The block returns no value and takes the following parameters:
+///
+/// - term `subscriptionsBySubscriptionID`: A dictionary with keys that are the IDs of the subscriptions you request, and values that are the corresponding subscriptions.
+/// - term `operationError`: An error that contains information about a problem, or `nil` if the system successfully fetches the subscriptions.
+///
+/// The operation executes this block only once, and it's your only opportunity to process the results. The block executes on a background queue, so any tasks that require access to the main queue must dispatch accordingly.
+///
+/// The block reports an error of type ``CKError/Code/partialFailure`` when it retrieves only some of the subscriptions successfully. The <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary of the error contains a ``CKPartialErrorsByItemIDKey`` key that has a dictionary as its value. The keys of the dictionary are the IDs of the subscriptions that the operation can't fetch, and the corresponding values are errors that contain information about the failures.
+///
+/// Set this property's value before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^fetchSubscriptionCompletionBlock)(NSDictionary<CKSubscriptionID, CKSubscription *> * _Nullable subscriptionsBySubscriptionID, NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use fetchSubscriptionsResultBlock instead", macos(10.10, 12.0), ios(8.0, 15.0), tvos(9.0, 15.0), watchos(6.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchWebAuthTokenOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchWebAuthTokenOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchWebAuthTokenOperation.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKFetchWebAuthTokenOperation.h	2026-02-13 09:49:21
@@ -9,26 +9,73 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-/*! @class CKFetchWebAuthTokenOperation
- *
- *  @abstract This operation will fetch a web auth token given an API token obtained from the CloudKit Dashboard for your container
- */
+/// An operation that creates an authentication token for use with CloudKit web services.
+///
+/// CloudKit web services provides an HTTP interface to fetch, create, update, and delete records, zones, and subscriptions. Each request you send requires an API token, which you configure in [CloudKit Dashboard](https://icloud.developer.apple.com). You must create an API token for each container in each environment.
+///
+/// If you want to send a request to an endpoint that requires an authenticated user, use this operation to fetch an authentication token. Append the authentication token, along with the API token, to the endpoint's URL. That request then acts on behalf of the current user. Authentication tokens are short-lived and expire after a single use.
+///
+/// For an example of using a web authentication token with a CloudKit web service, see <doc:changing-access-controls-on-user-data>.
+///
+/// This operation executes the handlers you provide on a background queue. Tasks that need access to the main queue must redirect as appropriate.
+///
+/// The operation calls ``fetchWebAuthTokenCompletionBlock`` after it executes to provide the fetched token. Use the completion handler to perform housekeeping tasks for the operation. It should also manage any failures, whether due to an error or an explicit cancellation.
+///
+/// - Note: Because this class inherits from <doc://com.apple.documentation/documentation/foundation/operation>, you can also set the <doc://com.apple.documentation/documentation/foundation/operation/completionblock> property. The operation calls both completion handlers if they're both set.
+///
+/// CloudKit operations have a default QoS of <doc://com.apple.documentation/documentation/foundation/qualityofservice/default>. Operations with this service level are discretionary. The system schedules their execution at an optimal time according to battery level and network conditions, among other factors. Use the <doc://com.apple.documentation/documentation/foundation/operation/qualityofservice> property to set a more appropriate QoS for the operation.
+///
+/// The following example shows how to create the operation, configure its callbacks, and execute it in the user's private database:
+///
+/// ```swift
+/// func fetchWebAuthToken(for apiToken: String,
+///     completion: @escaping (Result<String, any Error>) -> Void) {
+///
+///     // Create the operation using the API token
+///     // that the caller provides to the method.
+///     let operation = CKFetchWebAuthTokenOperation(apiToken: apiToken)
+///
+///     // If the operation fails, return the error to the caller.
+///     // Otherwise, return the fetched authentication token.
+///     operation.fetchWebAuthTokenCompletionBlock = { webToken, error in
+///         if let error = error {
+///             completion(.failure(error))
+///         } else {
+///             completion(.success(webToken!))
+///         }
+///     }
+///
+///     // Set an appropriate QoS and add the operation to the
+///     // private database's queue to execute it.
+///     operation.qualityOfService = .utility
+///     CKContainer.default().privateCloudDatabase.add(operation)
+/// }
+/// ```
 API_AVAILABLE(macos(10.11), ios(9.2), tvos(9.1), watchos(3.0))
 @interface CKFetchWebAuthTokenOperation : CKDatabaseOperation
 
+/// Creates an empty fetch operation.
+///
+/// You must set ``CKFetchWebAuthTokenOperation/apiToken`` before you execute the operation or add it to a queue.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates a fetch operation for the specified API token.
+///
+/// - Parameters:
+///   - APIToken: The API token that allows access to an app's container.
 - (instancetype)initWithAPIToken:(NSString *)APIToken;
 
-/*! APIToken is expected to be set before you begin this operation. */
+/// The API token that allows access to an app's container.
 @property (nullable, copy, nonatomic) NSString *APIToken;
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The block to execute when the operation finishes.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - If the operation is successful, the web authentication token; otherwise, `nil`.
+/// - An error that contains information about a problem, or `nil` if the system successfully fetches the token.
+///
+/// The operation executes this closure only once. You must provide a closure capable of executing on a background thread, so any tasks that require access to the main thread must dispatch accordingly.
 @property (nullable, copy, nonatomic) void (^fetchWebAuthTokenCompletionBlock)(NSString * _Nullable webAuthToken, NSError * _Nullable operationError) CK_SWIFT_DEPRECATED("Use fetchWebAuthTokenResultBlock instead", macos(10.11, 12.0), ios(9.2, 15.0), tvos(9.1, 15.0), watchos(3.0, 8.0));
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKLocationSortDescriptor.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKLocationSortDescriptor.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKLocationSortDescriptor.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKLocationSortDescriptor.h	2026-02-13 10:44:52
@@ -13,14 +13,33 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An object for sorting records that contain location data.
+///
+/// You can add a location sort descriptor to your queries when searching for records. At creation time, you must provide the sort descriptor with a key that has a <doc://com.apple.documentation/documentation/corelocation/cllocation> object as its value. The sort descriptor uses the value of that key to perform the sort.
+///
+/// CloudKit computes distance by drawing a direct line between the two locations that follows the curvature of the Earth. Distances don't account for altitude changes between the two locations.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 @interface CKLocationSortDescriptor : NSSortDescriptor <NSSecureCoding>
 
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
+
+/// Creates a location sort descriptor using the specified key and relative location.
+///
+/// - Parameters:
+///   - key: The name of the key with a <doc://com.apple.documentation/documentation/corelocation/cllocation> object as its value. The key must belong to the records you're sorting. The sort descriptor uses this key to retrieve the corresponding value from the record.
+///   - relativeLocation: The reference location when sorting. CloudKit sorts records according to their distance from this location.
+///
+/// During sorting, the sort descriptor computes the distance between the value in the `relativeLocation` parameter and the location value in the specified key of each record. It then sorts the records in ascending order using the distance between the two points. You can't change the sort order.
 - (instancetype)initWithKey:(NSString *)key relativeLocation:(CLLocation *)relativeLocation NS_DESIGNATED_INITIALIZER;
+
+/// Creates a location sort descriptor from a serialized instance.
+///
+/// - Parameters:
+///   - aDecoder: The coder to use when deserializing the location sort descriptor.
 - (instancetype)initWithCoder:(NSCoder *)aDecoder NS_DESIGNATED_INITIALIZER;
 
+/// The reference location for sorting records.
 @property (readonly, copy, nonatomic) CLLocation *relativeLocation;
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKMarkNotificationsReadOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKMarkNotificationsReadOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKMarkNotificationsReadOperation.h	2025-11-09 04:37:38
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKMarkNotificationsReadOperation.h	2026-02-13 10:44:51
@@ -9,7 +9,7 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-CK_NEWLY_UNAVAILABLE("Marking notifications read is no longer supported.  Consider using CKDatabaseSubscription, CKFetchDatabaseChangesOperation, and CKFetchRecordZoneChangesOperation")
+CK_NEWLY_UNAVAILABLE("Marking notifications read is no longer supported. Consider using CKDatabaseSubscription, CKFetchDatabaseChangesOperation, and CKFetchRecordZoneChangesOperation")
 @interface CKMarkNotificationsReadOperation : CKOperation
 @end
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifyRecordZonesOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifyRecordZonesOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifyRecordZonesOperation.h	2025-11-09 04:37:40
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifyRecordZonesOperation.h	2026-02-14 00:26:10
@@ -11,40 +11,80 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An operation that modifies one or more record zones.
+///
+/// After you create one or more record zones, use this operation to save those zones to the database. You can also use the operation to delete record zones and their records.
+///
+/// If you assign a handler to the <doc://com.apple.documentation/documentation/foundation/operation/completionblock> property of the operation, CloudKit calls the handler after the operation executes and returns its results. Use the handler to perform housekeeping tasks for the operation, but don't use it to process the results of the operation. The handler you provide should manage any failures of the operation, whether due to an error or an explicit cancellation.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 @interface CKModifyRecordZonesOperation : CKDatabaseOperation
 
+/// Creates an empty modify record zones operation.
+///
+/// You must set at least one of the ``CKModifyRecordZonesOperation/recordZonesToSave`` or ``CKModifyRecordZonesOperation/recordZoneIDsToDelete`` properties before you execute the operation.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for modifying the specified record zones.
+///
+/// - Parameters:
+///   - recordZonesToSave: The record zones to save. You can specify `nil` for this parameter.
+///   - recordZoneIDsToDelete: The IDs of the record zones to delete. You can specify `nil` for this parameter.
+///
+/// The record zones you intend to save or delete must all reside in the same database, which you specify when you configure the operation. If you delete a record zone, CloudKit deletes any records it contains.
 - (instancetype)initWithRecordZonesToSave:(nullable NSArray<CKRecordZone *> *)recordZonesToSave recordZoneIDsToDelete:(nullable NSArray<CKRecordZoneID *> *)recordZoneIDsToDelete;
 
+/// The record zones to save to the database.
+///
+/// The initial value of the property is the array that you provide to the ``CKModifyRecordZonesOperation/init(recordZonesToSave:recordZoneIDsToDelete:)`` method. You can modify this array as necessary before you execute the operation. The record zones must all target the same database. You can specify `nil`, or an empty array, for this property.
+///
+/// If you intend to change the value of this property, do so before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) NSArray<CKRecordZone *> *recordZonesToSave;
+
+/// The IDs of the record zones to delete permanently from the database.
+///
+/// The initial value of the property is the array of zone IDs that you provide to the ``CKModifyRecordZonesOperation/init(recordZonesToSave:recordZoneIDsToDelete:)`` method. You can modify this array as necessary before you execute the operation. The record zones must all target the same database. You can specify `nil`, or an empty array, for this property.
+///
+/// If you intend to change the value of this property, do so before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) NSArray<CKRecordZoneID *> *recordZoneIDsToDelete;
 
-/*! @abstract Called on success or failure of a record zone save
- *
- *  @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when CloudKit saves a record zone.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The ID of the record zone that CloudKit saves.
+/// - The record zone that CloudKit saves, or `nil` if CloudKit can't save the record zone.
+/// - If CloudKit can't save the record zone, an error that provides information about the failure; otherwise, `nil`.
+///
+/// The closure executes once for each record zone in the ``CKModifyRecordZonesOperation/recordZonesToSave`` property. Each time the closure executes, it executes serially with respect to the other record zone completion blocks of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perRecordZoneSaveBlock)(CKRecordZoneID *recordZoneID, CKRecordZone * _Nullable recordZone, NSError * _Nullable error) API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) NS_REFINED_FOR_SWIFT;
 
-/*! @abstract Called on success or failure of a record zone deletion
- *
- *  @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when CloudKit deletes a record zone.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The ID of the record zone that CloudKit deletes.
+/// - If CloudKit can't delete the record zone, an error that provides information about the failure; otherwise, `nil`.
+///
+/// The closure executes once for each record zone in the ``CKModifyRecordZonesOperation/recordZoneIDsToDelete`` property. Each time the closure executes, it executes serially with respect to the other record zone completion blocks of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perRecordZoneDeleteBlock)(CKRecordZoneID *recordZoneID, NSError * _Nullable error) API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) NS_REFINED_FOR_SWIFT;
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  If the error is @c CKErrorPartialFailure, the error's userInfo dictionary contains a dictionary of recordZoneIDs to errors keyed off of @c CKPartialErrorsByItemIDKey.
- *  @c savedRecordZones, @c deletedRecordZoneIDs and any @c CKPartialErrorsByItemIDKey errors are repeats of the data sent back in previous @c perRecordZoneSaveBlock and @c perRecordZoneDeleteBlock invocations
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute after CloudKit modifies all of the record zones.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The record zones that CloudKit saves.
+/// - The IDs of the record zones that CloudKit deletes.
+/// - If CloudKit can't modify any of the record zones, this parameter provides information about the failure; otherwise, it's `nil`.
+///
+/// The closure executes once, and represents your only opportunity to process the results.
+///
+/// The closure reports an error of type ``CKError/Code/partialFailure`` when it modifies only some of the record zones successfully. The <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary of the error contains a ``CKPartialErrorsByItemIDKey`` key that has a dictionary as its value. The keys of the dictionary are the IDs of the record zones that the operation can't modify, and the corresponding values are errors that contain information about the failures.
+///
+/// If you intend to use this closure to process the results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^modifyRecordZonesCompletionBlock)(NSArray<CKRecordZone *> * _Nullable savedRecordZones, NSArray<CKRecordZoneID *> * _Nullable deletedRecordZoneIDs, NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use modifyRecordZonesResultBlock instead", macos(10.10, 12.0), ios(8.0, 15.0), tvos(9.0, 15.0), watchos(3.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifyRecordsOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifyRecordsOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifyRecordsOperation.h	2025-11-12 06:00:29
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifyRecordsOperation.h	2026-02-13 10:44:54
@@ -11,114 +11,165 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-/*! @enum CKRecordSavePolicy
- *
- *  @constant CKRecordSaveIfServerRecordUnchanged
- *  @discussion Locally edited keys are sent to the server, updating the record if the server record has not been modified. This is the default and recommended save policy for regular use.
- *  This policy compares the record change tag with the server record, and may return @c CKErrorServerRecordChanged if the server record has been modified, for example by another device.
- *  Note: A @c CKShare record is always treated as @c CKRecordSaveIfServerRecordUnchanged, regardless of the @c savePolicy of the operation that modifies the share.
- *
- *  @constant CKRecordSaveChangedKeys
- *  @discussion Locally edited keys are written to the server, updating the record even if the server record has been modified.
- *  Note: This policy should be used with care, as it can overwrite changes made by other devices.
- *  Any previously committed change to the server, for example by other devices, will always be overwritten by the locally changed value.
- *  Note: A @c CKShare record is always treated as @c CKRecordSaveIfServerRecordUnchanged, regardless of the @c savePolicy of the operation that modifies the share.
- *  For non-CKShare records, this policy does not compare the record change tag and therefore will not return @c CKErrorServerRecordChanged
- *
- *  @constant CKRecordSaveAllKeys
- *  @discussion All local keys are written to the server, updating the record even if the server record has been modified.
- *  Note: This policy should be used with care. Any previously committed change to the server, for example by other devices, will be overwritten by the local value.
- *  Keys present only on the server remain unchanged.
- *  There are two common ways in which a server record will contain keys not present locally:
- *  1 - Another client may have added a new key to the record since it was fetched.
- *  2 - If @c desiredKeys was used with the fetch / query that returned this record, only a portion of the record's keys may have been downloaded.
- *  Note: A @c CKShare record is always treated as @c CKRecordSaveIfServerRecordUnchanged, regardless of the @c savePolicy of the operation that modifies the share.
- *  For non-CKShare records, this policy does not compare the record change tag and therefore will not return @c CKErrorServerRecordChanged
- */
-
+/// Constants that indicate which policy to apply when saving records.
 typedef NS_ENUM(NSInteger, CKRecordSavePolicy) {
+    /// A policy that instructs CloudKit to only proceed if the record's change tag matches that of the server's copy.
+    ///
+    /// The server maintains a change tag for each record automatically. When you fetch a record, that change tag accompanies the rest of the record's data. If the change tag in your local record matches the change tag of the record on the server, the save operation proceeds normally. If the server record contains a newer change tag, CloudKit doesn't save the record and reports a ``CKError/Code/serverRecordChanged`` error.
+    ///
+    /// - Note: A ``CKShare`` record is always saved with policy `ifServerRecordUnchanged`, regardless of an operation's ``CKModifyRecordsOperation/savePolicy``.
     CKRecordSaveIfServerRecordUnchanged = 0,
-    CKRecordSaveChangedKeys             = 1, /** Does not compare record change tags */
-    CKRecordSaveAllKeys                 = 2, /** Does not compare record change tags */
+
+    /// A policy that instructs CloudKit to save only the fields of a record that contain changes.
+    ///
+    /// - Important: This policy doesn't compare record change tags. To only save changes to the most recent version of a record, use ``CKModifyRecordsOperation/RecordSavePolicy/ifServerRecordUnchanged`` instead.
+    CKRecordSaveChangedKeys             = 1,
+
+    /// A policy that instructs CloudKit to save all keys of a record, even those without changes.
+    ///
+    /// - Important: This policy doesn't compare record change tags. To only save changes to the most recent version of a record, use ``CKModifyRecordsOperation/RecordSavePolicy/ifServerRecordUnchanged`` instead.
+    ///
+    /// This policy causes CloudKit to overwrite any existing values on the server. It's possible for a server record to contain keys that aren't present locally. Another client might add keys to the record after you fetch it. Also, if you use the ``CKFetchRecordsOperation/desiredKeys-34l1l`` property to request a subset of keys during a fetch operation, saving that same record modifies only those keys that you include in the fetch and any keys you add to the record after that.
+    CKRecordSaveAllKeys                 = 2
 } API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0));
 
+/// An operation that modifies one or more records.
+///
+/// After modifying the fields of a record, use this operation to save those changes to a database. You also use this operation to delete records permanently from a database.
+///
+/// If you're saving a record that contains a reference to another record, set the reference's ``CKRecord/Reference/action`` to indicate if the target record's deletion should cascade to the saved record. This helps avoid orphaned records in explicit record hierarchies. When creating two new records that have a reference between them, use the same operation to save both records at the same time. During a save operation, CloudKit requires that the target record of the ``CKRecord/parent`` reference, if set, exists in the database or is part of the same operation; all other reference fields are exempt from this requirement.
+///
+/// When you save records, the value in the ``savePolicy`` property determines how to proceed when CloudKit detects conflicts. Because records can change between the time you fetch them and the time you save them, the save policy determines whether new changes overwrite existing changes. By default, the operation reports an error when there's a newer version on the server. You can change the default setting to permit your changes to overwrite the server values wholly or partially.
+///
+/// The handlers you assign to monitor progress of the operation execute serially on an internal queue that the operation manages. You must provide handlers capable of executing on a background thread, so any tasks that require access to the main thread must redirect accordingly.
+///
+/// If you assign a completion handler to the <doc://com.apple.documentation/documentation/foundation/operation/completionblock> property of the operation, CloudKit calls it after the operation executes and returns the results. Use the completion handler to perform any housekeeping tasks for the operation, but don't use it to process the results of the operation. The completion handler you provide should manage any failures of the operation, whether due to an error or an explicit cancellation.
+///
+/// - Important: To ensure the speed of fetching and saving records, the server may reject large operations. When this occurs, a block reports the ``CKError/Code/limitExceeded`` error. Your app should handle this error, and refactor the operation into multiple smaller batches.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 @interface CKModifyRecordsOperation : CKDatabaseOperation
 
+/// Creates an empty modify records operation.
+///
+/// You must set at least one of the ``CKModifyRecordsOperation/recordsToSave`` or ``CKModifyRecordsOperation/recordIDsToDelete`` properties before you execute the operation.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for modifying the specified records.
+///
+/// - Parameters:
+///   - records: The records to save. You can specify `nil` for this parameter.
+///   - recordIDs: The IDs of the records to delete. You can specify `nil` for this parameter.
+///
+/// The records that you intend to save or delete must all reside in the same database, which you specify when you configure the operation. If your app saves a record in a database that doesn't exist, the server creates the database.
 - (instancetype)initWithRecordsToSave:(nullable NSArray<CKRecord *> *)records recordIDsToDelete:(nullable NSArray<CKRecordID *> *)recordIDs;
 
+/// The records to save to the database.
+///
+/// The initial value of the property is the array that you provide to the ``CKModifyRecordsOperation/init(recordsToSave:recordIDsToDelete:)`` method. You can modify this array as necessary before you execute the operation. The records must all target the same database, but can belong to different record zones.
+///
+/// If you intend to change the value of this property, do so before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) NSArray<CKRecord *> *recordsToSave;
+
+/// The IDs of the records to delete permanently from the database.
+///
+/// An array of ``CKRecord/ID`` objects that identifies the records to delete. The initial value of the property is the array of record IDs that you provide to the ``CKModifyRecordsOperation/init(recordsToSave:recordIDsToDelete:)`` method.
+///
+/// When deleting records, the operation reports progress only on the records with the IDs that you specify in this property. Deleting records can trigger the deletion of related records if there is an owner-owned relationship between the records involving a ``CKRecord/Reference`` object. When additional deletions occur, CloudKit doesn't pass them to the progress handler of the operation. For that reason, it's important to understand the implications of the ownership model you use when you relate records to each other through a ``CKRecord/Reference`` object. For more information about owner-owned relationships, see ``CKRecord/Reference``.
+///
+/// If you intend to change the value of this property, do so before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) NSArray<CKRecordID *> *recordIDsToDelete;
 
-/*! @abstract  Determines what data is sent to the server and whether the save should succeed even if the record on the server has changed.
- *
- *  @discussion:  The default value is @c CKRecordSaveIfServerRecordUnchanged, which is the recommended value for regular use.
- *  A @c CKShare record is always treated as @c CKRecordSaveIfServerRecordUnchanged, regardless of the @c savePolicy specified.
- */
+/// The policy to use when saving changes to records.
+///
+/// The server uses this property to determine how to proceed when saving record changes. The exact behavior depends on the policy you choose:
+///
+/// - Use ``CKModifyRecordsOperation/RecordSavePolicy/ifServerRecordUnchanged`` to only save a record when the change tag of the local copy matches that of the server's copy. If the server record's change tag is more recent, CloudKit discards the save and returns a ``CKError/Code/serverRecordChanged`` error.
+/// - Use ``CKModifyRecordsOperation/RecordSavePolicy/changedKeys`` to save only the fields of the record that contain changes. The server doesn't compare record change tags when using this policy.
+/// - Use ``CKModifyRecordsOperation/RecordSavePolicy/allKeys`` to save every field of the record, even those without changes. The server doesn't compare record change tags when using this policy.
+///
+/// If you change the property's value, do so before you execute the operation or submit the operation to a queue. The default value is ``CKModifyRecordsOperation/RecordSavePolicy/ifServerRecordUnchanged``.
 @property (assign, nonatomic) CKRecordSavePolicy savePolicy;
 
-/*! @discussion This property is kept by the server to identify the last known request from this client.
- *  Multiple requests from the client with the same change token will be ignored by the server.
- */
+/// A token that tracks local changes to records.
+///
+/// The default value is `nil`.
+///
+/// When you modify records from a fetch operation, specify a token using this property to indicate which version of the record you most recently modified. Compare the token you supply to the token in the next record fetch to confirm the server  successfully receives the device's most recent modify request.
+///
+/// If you intend to change the value of this property, do so before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) NSData *clientChangeTokenData;
 
-/*! @abstract  Determines whether the batch should fail atomically or not.
- *
- *  @discussion YES by default.
- *  Server-side write atomicity is only enforced on zones that have @c CKRecordZoneCapabilityAtomic.
- *  If @c isAtomic is YES, client-side checks are enforced regardless of the zone's capabilities.  (For example, if a record is malformed, and cannot be sent to the server, the client will forcibly fail all other records-to-be-modified in that zone)
- */
+/// A Boolean value that indicates whether the entire operation fails when CloudKit can't update one or more records in a record zone.
+///
+/// Modifying records atomically prevents you from updating your data in a way that leaves it in an inconsistent state. You use atomic updates when you want to write multiple records to the same record zone. If there's a failure to modify any of the records in a zone, CloudKit doesn't change the other records in that same zone. The record zone must have the ``CKRecordZone/Capabilities/atomic`` capability for this behavior to apply. If a record zone doesn't support the atomic capability, setting this property has no effect.
+///
+/// The default value of this property is <doc://com.apple.documentation/documentation/swift/true>, which causes all modifications within a single record zone to occur atomically. If your operation contains records in multiple record zones, a failure in one zone doesn't prevent modifications to records in a different zone. Changing the value of this property to <doc://com.apple.documentation/documentation/swift/false> causes CloudKit to modify records individually, regardless of whether the record zone supports atomic modifications.
 @property (assign, nonatomic) BOOL atomic NS_SWIFT_NAME(isAtomic);
 
-/*! @abstract Indicates the progress for each record.
- *
- *  @discussion This method is called at least once with a progress of 1.0 for every record. Intermediate progress is only reported for records that contain assets.
- *  It is possible for progress to regress when a retry is automatically triggered.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute with progress information for individual records.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The record that CloudKit saves.
+/// - The amount of data, as a percentage, that CloudKit saves for the record. The range is `0.0` to `1.0`, where `0.0` indicates that CloudKit hasn't saved any data, and `1.0` means that CloudKit has saved the entire record.
+///
+/// The modify records operation executes this closure one or more times for each record in the ``CKModifyRecordsOperation/recordsToSave`` property. Each time the closure executes, it executes serially with respect to the other progress closures of the operation. You can use this closure to track the ongoing progress of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or add the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perRecordProgressBlock)(CKRecord *record, double progress);
 
-/*! @abstract Called on success or failure for each record.
- *
- *  @discussion Will not be invoked if @c perRecordSaveBlock is set.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when CloudKit saves a record.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The record that CloudKit saves.
+/// - If CloudKit can't save the record, an error that provides information about the failure; otherwise, `nil`.
+///
+/// The closure executes once for each record in the ``CKModifyRecordsOperation/recordsToSave`` property. Each time the closure executes, it executes serially with respect to the other record completion blocks of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perRecordCompletionBlock)(CKRecord *record, NSError * _Nullable error) API_DEPRECATED_WITH_REPLACEMENT("perRecordSaveBlock", macos(10.10, 12.0), ios(8.0, 15.0), tvos(9.0, 15.0), watchos(3.0, 8.0));
 
-
-/*! @abstract Called on success or failure of a record save
- *
- *  @discussion Following a successful record save, this callback will be invoked with a nonnull @c record, and a nil @c error.
- *  Following a save failure due to a per-item error (@c CKErrorServerRecordChanged, for example), this callback will be invoked with a nil @c record, and a nonnull @c error
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when CloudKit saves a record.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The ID of the record that CloudKit saves.
+/// - The record that CloudKit saves, or `nil` if CloudKit can't save the record.
+/// - If CloudKit can't save the record, an error that provides information about the failure; otherwise, `nil`.
+///
+/// The closure executes once for each record in the ``CKModifyRecordsOperation/recordsToSave`` property. Each time the closure executes, it executes serially with respect to the other record completion blocks of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perRecordSaveBlock)(CKRecordID *recordID, CKRecord * _Nullable record, NSError * _Nullable error) API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) NS_REFINED_FOR_SWIFT;
 
-/*! @abstract Called on success or failure of a record deletion
- *
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when CloudKit deletes a record.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The ID of the record that CloudKit deletes.
+/// - If CloudKit can't delete the record, an error that provides information about the failure; otherwise, `nil`.
+///
+/// The closure executes once for each record in the ``CKModifyRecordsOperation/recordIDsToDelete`` property. Each time the closure executes, it executes serially with respect to the other record completion blocks of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perRecordDeleteBlock)(CKRecordID *recordID, NSError * _Nullable error) API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) NS_REFINED_FOR_SWIFT;
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  If the error is @c CKErrorPartialFailure, the error's userInfo dictionary contains a dictionary of recordIDs to errors keyed off of @c CKPartialErrorsByItemIDKey.
- *  @c savedRecords, @c deletedRecordIDs and any @c CKPartialErrorsByItemIDKey errors are repeats of the data sent back in previous @c perRecordSaveBlock and @c perRecordDeleteBlock invocations
- *  This call happens as soon as the server has seen all record changes, and may be invoked while the server is processing the side effects of those changes.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute after CloudKit modifies all of the records.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The records that CloudKit saves.
+/// - The IDs of the records that CloudKit deletes.
+/// - If CloudKit can't modify any of the records, this parameter provides information about the failure; otherwise, it's `nil`.
+///
+/// The closure executes only once, and represents your final opportunity to process the operation's results. It executes after all record progress closures and record completion closures finish. The closure executes serially with respect to the other closures of the operation.
+///
+/// Although this closure executes after the modification of records completes, it executes prior to the indexing of queries for those modified records. Therefore, if a query executes in this completion closure, the results of that query might not include the changes from this operation. Conversely, records that CloudKit fetches in the completion closure are up to date with the changes from the associated operation.
+///
+/// The closure reports an error of type ``CKError/Code/partialFailure`` when it modifies only some of the records successfully. The <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary of the error contains a ``CKPartialErrorsByItemIDKey`` key that has a dictionary as its value. The keys of the dictionary are the IDs of the records that the operation can't modify, and the corresponding values are errors that contain information about the failures.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^modifyRecordsCompletionBlock)(NSArray<CKRecord *> * _Nullable savedRecords, NSArray<CKRecordID *> * _Nullable deletedRecordIDs, NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use modifyRecordsResultBlock instead", macos(10.10, 12.0), ios(8.0, 15.0), tvos(9.0, 15.0), watchos(3.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifySubscriptionsOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifySubscriptionsOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifySubscriptionsOperation.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKModifySubscriptionsOperation.h	2026-02-13 13:17:09
@@ -11,40 +11,74 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An operation for modifying one or more subscriptions.
+///
+/// After you create or change the configuration of a subscription, use this operation to save those changes to the server. You can also use this operation to permanently delete subscriptions.
+///
+/// If you assign a handler to the <doc://com.apple.documentation/documentation/foundation/operation/completionblock> property, the operation calls it after it executes and passes it the results. Use the handler to perform any housekeeping tasks for the operation. The handler you specify should manage any failures, whether due to an error or an explicit cancellation.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(6.0))
 @interface CKModifySubscriptionsOperation : CKDatabaseOperation
 
+/// Creates an empty modify subscriptions operation.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation for saving and deleting the specified subscriptions.
+///
+/// - Parameters:
+///   - subscriptionsToSave: The subscriptions to save or update. You can specify `nil` for this parameter.
+///   - subscriptionIDsToDelete: The IDs of the subscriptions to delete. You can specify `nil` for this parameter.
+///
+/// The subscriptions that you want to save or delete must reside in the same container. CloudKit creates a subscription if you save one that doesn't already exist. CloudKit returns an error if you try to delete a subscription that doesn't exist.
 - (instancetype)initWithSubscriptionsToSave:(nullable NSArray<CKSubscription *> *)subscriptionsToSave subscriptionIDsToDelete:(nullable NSArray<CKSubscriptionID> *)subscriptionIDsToDelete;
 
+/// The subscriptions to save to the database.
+///
+/// This property contains the subscriptions that you want to save. Its initial value is the array that you pass to the ``CKModifySubscriptionsOperation/init(subscriptionsToSave:subscriptionIDsToDelete:)`` method. Modify this property as necessary before you execute the operation or submit it to a queue. After CloudKit saves the subscriptions, it begins generating push notifications according to their criteria.
 @property (nullable, copy, nonatomic) NSArray<CKSubscription *> *subscriptionsToSave;
+
+/// The IDs of the subscriptions that you want to delete.
+///
+/// This property contains the IDs of the subscriptions that you want to delete. Its initial value is the array that you pass to the ``CKModifySubscriptionsOperation/init(subscriptionsToSave:subscriptionIDsToDelete:)`` method. Modify this property as necessary before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) NSArray<CKSubscriptionID> *subscriptionIDsToDelete;
 
-/*! @abstract Called on success or failure of a subscription save
- *
- *  @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when CloudKit saves a subscription.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The ID of the subscription that CloudKit saves.
+/// - The subscription that CloudKit saves, or `nil` if CloudKit can't save the subscription.
+/// - If CloudKit can't save the subscription, an error that provides information about the failure; otherwise, `nil`.
+///
+/// The closure executes once for each subscription in the ``CKModifySubscriptionsOperation/subscriptionsToSave`` property. Each time the closure executes, it executes serially with respect to the other subscription completion blocks of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perSubscriptionSaveBlock)(CKSubscriptionID subscriptionID, CKSubscription * _Nullable subscription, NSError * _Nullable error) API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) NS_REFINED_FOR_SWIFT;
 
-/*! @abstract Called on success or failure of a subscription deletion
- *
- *  @discussion Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when CloudKit deletes a subscription.
+///
+/// This property is a closure that returns no value and has the following parameters:
+///
+/// - The ID of the subscription that CloudKit deletes.
+/// - If CloudKit can't delete the subscription, an error that provides information about the failure; otherwise, `nil`.
+///
+/// The closure executes once for each subscription in the ``CKModifySubscriptionsOperation/subscriptionIDsToDelete-14x82`` property. Each time the closure executes, it executes serially with respect to the other subscription completion blocks of the operation.
+///
+/// If you intend to use this closure to process results, set it before you execute the operation or submit the operation to a queue.
 @property (nullable, copy, nonatomic) void (^perSubscriptionDeleteBlock)(CKSubscriptionID subscriptionID, NSError * _Nullable error) API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) NS_REFINED_FOR_SWIFT;
 
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  If the error is @c CKErrorPartialFailure, the error's userInfo dictionary contains a dictionary of subscriptionIDs to errors keyed off of @c CKPartialErrorsByItemIDKey.
- *  @c savedSubscriptions, @c deletedSubscriptionIDs and any @c CKPartialErrorsByItemIDKey errors are repeats of the data sent back in previous @c perSubscriptionSaveBlock and @c perSubscriptionDeleteBlock invocations
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The block to execute after the operation modifies the subscriptions.
+///
+/// The block returns no value and takes the following parameters:
+///
+///   - term `savedSubscriptions`: The subscriptions to save.
+///   - term `deletedSubscriptionIDs`: The IDs of the subscriptions to delete.
+///   - term `operationError`: An error that contains information about a problem, or `nil` if CloudKit successfully modifies the subscriptions.
+///
+/// The operation executes this block only once, and it's your only opportunity to process the results. The block executes on a background queue, so any tasks that require access to the main queue must dispatch accordingly.
+///
+/// The block reports an error of type ``CKError/Code/partialFailure`` when it can't modify some of the subscriptions. The <doc://com.apple.documentation/documentation/foundation/nserror/userinfo> dictionary of the error contains a ``CKPartialErrorsByItemIDKey`` key that has a dictionary as its value. The keys of the dictionary are the IDs of the subscriptions that CloudKit can't modify, and the corresponding values are errors that contain information about the failures.
+///
+/// Set this property's value before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^modifySubscriptionsCompletionBlock)(NSArray<CKSubscription *> * _Nullable savedSubscriptions, NSArray<CKSubscriptionID> * _Nullable deletedSubscriptionIDs, NSError * _Nullable operationError);
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKNotification.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKNotification.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKNotification.h	2025-11-09 04:42:59
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKNotification.h	2026-02-13 10:47:06
@@ -15,51 +15,63 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An object that uniquely identifies a push notification that a container sends.
+///
+/// You don't create notification IDs directly. The server creates them when it creates instances of ``CKNotification`` that correspond to the push notifications that CloudKit sends to your app. You can compare two IDs using the <doc://com.apple.documentation/documentation/objectivec/nsobjectprotocol/isequal(_:)> method to determine whether two notifications are the same. This class defines no methods or properties.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 // NS_SWIFT_SENDABLE on swift(4.2)
 @interface CKNotificationID : NSObject <NSCopying, NSSecureCoding>
 @end
 
+/// Constants that indicate the type of event that generates the push notification.
 typedef NS_ENUM(NSInteger, CKNotificationType) {
-    /// Generated by ``CKQuerySubscription``s
+    /// A notification that CloudKit generates from a query subscription's predicate.
     CKNotificationTypeQuery            = 1,
 
-    /// Generated by ``CKRecordZoneSubscription``s
+    /// A notification that CloudKit generates when the contents of a record zone change.
     CKNotificationTypeRecordZone       = 2,
 
-    /// Indicates a notification that a client had previously marked as read
+    /// A notification that your app marks as read.
     CKNotificationTypeReadNotification = 3,
 
-    /// Generated by ``CKDatabaseSubscription``s
+    /// A notification that CloudKit generates when the contents of a database change.
     CKNotificationTypeDatabase         API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) = 4,
 } API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0));
 
-/// Pushes from CloudKit servers contain both CloudKit-specific and APS-specific information.
-/// APS-specific information includes elements like alerts, badges, sounds, categories, etc.
-/// When receiving a push from CloudKit servers, the push may be delivered via multiple API flows.
-/// The flow(s) chosen will depend on the type of push requested (e.g. via the ``CKSubscription``
-/// that triggered it and its configured `notificationInfo`).
+/// The abstract base class for CloudKit notifications.
 ///
-/// Pushes with UI elements (alerts, badges, sounds):
-/// These pushes are delivered via the `UserNotifications` framework, in the form of a `UNNotification`
-/// Applications should use the `UserNotifications` framework to interact with the UI elements of this push.
+/// Use subclasses of `CKNotification` to extract data from push notifications that the system receives, or to fetch a container's previous push notifications. In both cases, the object indicates the changed data.
+///
+/// `CKNotification` is an abstract class. When you create a notification from a payload dictionary, the ``init(fromRemoteNotificationDictionary:)`` method returns an instance of the appropriate subclass. Similarly, when you fetch notifications from a container, you receive instances of a concrete subclass. `CKNotification` provides information about the push notification and its method of delivery. Subclasses contain specific data that provides the changes.
+///
+/// The system delivers notifications with alerts, badges, or sounds via the `UserNotifications` framework, in the form of a `UNNotification`.
+///
+/// Applications should use the `UserNotifications` framework to interact with the alert, badge, and sound properties of the notification.
+///
 /// Applications may create a ``CKNotification`` from a `UNNotification` in their `UNUserNotificationCenterDelegate`:
 ///
-///     func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification) async -> UNNotificationPresentationOptions {
-///         let ckNotification = CKNotification(fromRemoteNotificationDictionary: notification.request.content.userInfo)
-///     }
+/// ```swift
+///  func userNotificationCenter(
+///      _ center: UNUserNotificationCenter, willPresent notification: UNNotification
+///  ) async -> UNNotificationPresentationOptions {
+///     let ckNotification = CKNotification(fromRemoteNotificationDictionary: notification.request.content.userInfo)
+/// }
+///```
 ///
-/// Pushes with `content-available`:
-/// These pushes are delivered via an application delegate, in the form of a remote notification.
+/// Notifications without alerts, badges, or sounds are delivered via an application delegate, in the form of a remote notification.
+///
 /// For example: `UIApplicationDelegate.application(_:didReceiveRemoteNotification:) async`
-/// Applications do not need to interact with any UI element in the push payload argument, that's intended to be handled via the `UserNotifications` flow
-/// (a push with both UI elements and `content-available` will be delivered via both API flows)
+///
 /// Applications may create a ``CKNotification`` from the remote notification in their `UIApplicationDelegate`:
 ///
-///     func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any]) async -> UIBackgroundFetchResult {
-///         let ckNotification = CKNotification(fromRemoteNotificationDictionary: userInfo)
-///     }
+/// ```swift
+/// func application(
+///     _ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any]
+/// ) async -> UIBackgroundFetchResult {
+///     let ckNotification = CKNotification(fromRemoteNotificationDictionary: userInfo)
+/// }
+/// ```
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 // This class should not be subclassed. If it is, Sendable may no longer apply.
 NS_SWIFT_SENDABLE
@@ -68,159 +80,248 @@
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
+/// Creates a new notification using the specified payload data.
+///
+/// - Parameters:
+///   - notificationDictionary: The push notification's payload data. Use the dictionary that the system provides to your app delegate's <doc://com.apple.documentation/documentation/uikit/uiapplicationdelegate/application(_:didreceiveremotenotification:fetchcompletionhandler:)> method. This parameter must not be `nil`.
 + (nullable instancetype)notificationFromRemoteNotificationDictionary:(NSDictionary *)notificationDictionary;
 
-/// When you instantiate a ``CKNotification`` from a remote notification dictionary, you will get back a concrete
-/// subclass defined below.  Use `notificationType` to avoid `as?` or `-isKindOfClass:` checks.
+/// The type of event that generates the notification.
+///
+/// Different notification types correspond to different subclasses of ``CKNotification``, so you can use the value in this property to determine how to handle the notification data.
 @property (readonly, assign, nonatomic) CKNotificationType notificationType;
 
+/// The notification's ID.
+///
+/// Use this property to differentiate notifications.
 @property (nullable, readonly, copy, nonatomic) CKNotificationID *notificationID;
 
+/// The ID of the container with the content that triggers the notification.
+///
+/// Use this property to determine the location of the changed content.
 @property (nullable, readonly, copy, nonatomic) NSString *containerIdentifier;
 
-/// The user `recordID` of the owner of the subscription for which this notification was generated
+/// The ID of the user record that creates the subscription that generates the push notification.
+///
+/// On a system that supports multiple users, such as tvOS, use this identifier to check whether the pending content is for the current user. If your app always fetches data from CloudKit on launch, you may improve efficiency by disregarding notifications for other users.
+///
+/// For more information about supporting a multiuser environment, see <doc://com.apple.documentation/documentation/tvservices/personalizing-your-app-for-each-user-on-apple-tv>.
 @property (nullable, readonly, copy, nonatomic) CKRecordID *subscriptionOwnerUserRecordID API_AVAILABLE(macos(10.15), ios(13.0), tvos(13.0), watchos(6.0));
 
-/// Whether or not the notification fully represents what the server wanted to send.
+/// A Boolean value that indicates whether the system removes some push notification content before delivery.
 ///
-/// Push notifications have a limited size.  In some cases, CloudKit servers may not be able to send you a full ``CKNotification``'s worth of info in one push.
-/// In those cases, `isPruned` returns `true`.
-/// The order in which properties are dropped from a push notification is defined in each ``CKNotification`` subclass below.
+/// The server may truncate the payload data of a push notification if the size of that data exceeds the allowed maximum. For notifications you create using a payload dictionary, the value of this property is <doc://com.apple.documentation/documentation/swift/true> if the payload data doesn't contain all information regarding the change. The value is <doc://com.apple.documentation/documentation/swift/false> if the payload data is complete.
+///
+/// For notifications you fetch from the database using a `CKFetchNotificationChangesOperation` operation, this property's value is always <doc://com.apple.documentation/documentation/swift/true>.
+///
+/// When CloudKit must remove payload data, it removes it in a specific order. This class's properties are among the last that CloudKit removes because they define information about how to deliver the push notification. The following list shows the properties that CloudKit removes, and the order for removing them:
+///
+/// 1. ``CKNotification/containerIdentifier``
+/// 2. Keys that subclasses of `CKNotification` define.
+/// 3. ``CKNotification/soundName``
+/// 4. ``CKNotification/alertLaunchImage``
+/// 5. ``CKNotification/alertActionLocalizationKey``
+/// 6. ``CKNotification/alertBody``
+/// 7. ``CKNotification/alertLocalizationArgs``
+/// 8. ``CKNotification/alertLocalizationKey``
+/// 9. ``CKNotification/badge``
+/// 10. ``CKNotification/notificationID``
 @property (readonly, assign, nonatomic) BOOL isPruned;
 
-/// The ID of the subscription that caused this notification to fire.
+/// The ID of the subscription that triggers the notification.
 @property (nullable, readonly, copy, nonatomic) CKSubscriptionID subscriptionID API_AVAILABLE(macos(10.11), ios(9.0), watchos(3.0));
 
 @end
 
 API_DEPRECATED_BEGIN("Interact with UI elements of a CloudKit-server-generated push message via UserNotifications.framework", macos(10.10, 14.0), ios(8.0, 17.0), tvos(9.0, 17.0), watchos(3.0, 10.0))
 @interface CKNotification (DeprecatedAPSProperties)
+
+/// The notification's alert body.
+///
+/// This property contains the nonlocalized text that the notification's alert displays.
 @property (nullable, readonly, copy, nonatomic) NSString *alertBody __TVOS_PROHIBITED;
+
+/// The key that identifies the localized text for the alert body.
+///
+/// When the system delivers a push notification to your app, it gets the text for the alert body by looking up the specified key in your app's `Localizable.strings` file. CloudKit ignores the value in ``CKNotification/alertBody`` if you set this property.
 @property (nullable, readonly, copy, nonatomic) NSString *alertLocalizationKey __TVOS_PROHIBITED;
+
+/// The fields for building a notification's alert.
+///
+/// This property is an array of field names that CloudKit uses to extract the corresponding values from the record that triggers the push notification. The values are strings, numbers, or dates. CloudKit may truncate strings with a length greater than 100 characters when it adds them to a notification's payload.
+///
+/// If you use `%@` for your substitution variables, CloudKit replaces those variables by traversing the array in order. If you use variables of the form `%n$@`, where `n` is an integer, `n` represents the index (starting at 1) of the item in the array to use. So, the first item in the array replaces the variable `%1$@`, the second item replaces the variable `%2$@`, and so on. You can use indexed substitution variables to change the order of items in the resulting string, which might be necessary when you localize your app's content.
 @property (nullable, readonly, copy, nonatomic) NSArray<NSString *> *alertLocalizationArgs __TVOS_PROHIBITED;
+
+/// The notification's title.
+///
+/// The system ignores this property if ``CKNotification/titleLocalizationKey`` has a value.
 @property (nullable, readonly, copy, nonatomic) NSString *title __TVOS_PROHIBITED API_AVAILABLE(macos(10.13), ios(11.0), watchos(4.0));
+
+/// The key that identifies the localized string for the notification's title.
+///
+/// This property takes precedence over ``CKNotification/title``.
 @property (nullable, readonly, copy, nonatomic) NSString *titleLocalizationKey __TVOS_PROHIBITED API_AVAILABLE(macos(10.13), ios(11.0), watchos(4.0));
+
+/// The fields for building a notification's title.
+///
+/// This property is an array of field names that CloudKit uses to extract the corresponding values from the record that triggers the push notification. The values are strings, numbers, or dates. CloudKit may truncate strings with a length greater than 100 characters when it adds them to a notification's payload.
+///
+/// If you use `%@` for your substitution variables, CloudKit replaces those variables by traversing the array in order. If you use variables of the form `%n$@`, where `n` is an integer, `n` represents the index (starting at 1) of the item in the array to use. So, the first item in the array replaces the variable `%1$@`, the second item replaces the variable `%2$@`, and so on. You can use indexed substitution variables to change the order of items in the resulting string, which might be necessary when you localize your app's content.
 @property (nullable, readonly, copy, nonatomic) NSArray<NSString *> *titleLocalizationArgs __TVOS_PROHIBITED API_AVAILABLE(macos(10.13), ios(11.0), watchos(4.0));
+
+/// The notification's subtitle.
+///
+/// The system ignores this property if ``CKNotification/subtitleLocalizationKey`` has a value.
 @property (nullable, readonly, copy, nonatomic) NSString *subtitle __TVOS_PROHIBITED API_AVAILABLE(macos(10.13), ios(11.0), watchos(4.0));
+
+/// The key that identifies the localized string for the notification's subtitle.
+///
+/// This property takes precedence over ``CKNotification/subtitle``.
 @property (nullable, readonly, copy, nonatomic) NSString *subtitleLocalizationKey __TVOS_PROHIBITED API_AVAILABLE(macos(10.13), ios(11.0), watchos(4.0));
+
+/// The fields for building a notification's subtitle.
+///
+/// This property is an array of field names that CloudKit uses to extract the corresponding values from the record that triggers the push notification. The values are strings, numbers, or dates. CloudKit may truncate strings with a length greater than 100 characters when it adds them to a notification's payload.
+///
+/// If you use `%@` for your substitution variables, CloudKit replaces those variables by traversing the array in order. If you use variables of the form `%n$@`, where `n` is an integer, `n` represents the index (starting at 1) of the item in the array to use. So, the first item in the array replaces the variable `%1$@`, the second item replaces the variable `%2$@`, and so on. You can use indexed substitution variables to change the order of items in the resulting string, which might be necessary when you localize your app's content.
 @property (nullable, readonly, copy, nonatomic) NSArray<NSString *> *subtitleLocalizationArgs __TVOS_PROHIBITED API_AVAILABLE(macos(10.13), ios(11.0), watchos(4.0));
+
+/// The key that identifies the localized string for the notification's action.
+///
+/// The system uses this property's value to find the matching string in your app's `Localizable.strings` file. It uses the string as the text of the button that opens your app, which the notification alert displays.
+///
+/// If this property's value is `nil`, the system displays a single button to dismiss the alert.
 @property (nullable, readonly, copy, nonatomic) NSString *alertActionLocalizationKey __TVOS_PROHIBITED;
+
+/// The filename of an image to use as a launch image.
+///
+/// The system uses this property's value to locate an image in the app's bundle, and displays it as a launch image when the user launches the app after receiving a push notification.
 @property (nullable, readonly, copy, nonatomic) NSString *alertLaunchImage __TVOS_PROHIBITED;
+
+/// The value that the app icon's badge displays.
 @property (nullable, readonly, copy, nonatomic) NSNumber *badge API_AVAILABLE(tvos(10.0));
+
+/// The name of the sound file to play when a notification arrives.
+///
+/// The system uses this property's value to locate a sound file in the app's bundle. The sound plays when the system receives a push notification. If the system can't find the specified file, or if the property's value is the string `default`, the system plays the default sound.
 @property (nullable, readonly, copy, nonatomic) NSString *soundName __TVOS_PROHIBITED;
+
+/// The name of the action group that corresponds to this notification.
+///
+/// Categories allow you to present custom actions to the user on your push notifications. For more information, see <doc://com.apple.documentation/documentation/uikit/uimutableusernotificationcategory>.
 @property (nullable, readonly, copy, nonatomic) NSString *category __TVOS_PROHIBITED API_AVAILABLE(macos(10.11), ios(9.0), watchos(3.0));
+
 @end
 API_DEPRECATED_END // macos(10.10, 14.0), ios(8.0, 17.0), tvos(9.0, 17.0), watchos(3.0, 10.0))
 
+/// Constants that indicate the event that triggers the notification.
 typedef NS_ENUM(NSInteger, CKQueryNotificationReason) {
+    /// A notification that indicates the creation of a record matching the subscription's predicate.
     CKQueryNotificationReasonRecordCreated = 1,
+
+    /// A notification that indicates the update of a record matching the subscription's predicate.
     CKQueryNotificationReasonRecordUpdated,
+
+    /// A notification that indicates the deletion of a record matching the subscription's predicate.
     CKQueryNotificationReasonRecordDeleted,
 } API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0));
 
-/// A notification generated by a ``CKQuerySubscription``
+/// A notification that triggers when a record that matches the subscription's predicate changes.
 ///
-/// `notificationType` == `.query`
-/// When properties must be dropped (see @c isPruned), here's the order of importance.  The most important properties are first, they'll be the last ones to be dropped.
-/// - notificationID
-/// - badge
-/// - alertLocalizationKey
-/// - alertLocalizationArgs
-/// - alertBody
-/// - alertActionLocalizationKey
-/// - alertLaunchImage
-/// - soundName
-/// - content-available
-/// - desiredKeys
-/// - queryNotificationReason
-/// - recordID
-/// - containerIdentifier
-/// - subscriptionOwnerUserRecordID
-/// - titleLocalizationKey
-/// - titleLocalizationArgs
-/// - title
-/// - subtitleLocalizationKey
-/// - subtitleLocalizationArgs
-/// - subtitle
+/// Query subscriptions execute when a record that matches the subscription's predicate changes, for example, when the user modifies a field's value in the record. When CloudKit registers the change, it sends push notifications to the user's devices to inform your app about the change. You can then fetch the changes and cache them on-device. When appropriate, CloudKit excludes the device where the change originates.
+///
+/// You configure a subscription's notifications by setting it's ``CKSubscription/notificationInfo`` property. Do this before you save it to the server. A subscription generates either high-priority or medium-priority push notifications. CloudKit delivers medium-priority notifications to your app in the background. High-priority notifications are visual and the system displays them to the user. Visual notifications need the user's permission. For more information, see <doc://com.apple.documentation/documentation/usernotifications/asking-permission-to-use-notifications>.
+///
+/// A subscription uses ``CKSubscription/NotificationInfo`` to configure its notifications. For background delivery, set only its ``CKSubscription/NotificationInfo/shouldSendContentAvailable`` property to <doc://com.apple.documentation/documentation/swift/true>. If you set any other property, CloudKit treats the notification as high-priority.
+///
+/// - Note: To receive silent push notifications, add the Background Modes capability to your Xcode project, and select the "Background fetch" and "Remote notifications" options.
+///
+/// Don't rely on push notifications for changes because the system can coalesce them. CloudKit can omit data to keep the notification's payload size under the APNs size limit. If you use ``CKSubscription/NotificationInfo/desiredKeys`` to include extra data in the payload, the server removes that first. A notification's ``CKNotification/isPruned`` property is <doc://com.apple.documentation/documentation/swift/true> if CloudKit omits data.
+///
+/// Consider notifications an indication of remote changes. Use ``CKDatabaseNotification/databaseScope`` to determine which database contains the changed record. To fetch the changes, configure an instance of ``CKQueryOperation`` to match the subscription and then execute it in the database. CloudKit returns all records that match the predicate, including the changed record. Dispose of any records you cache on-device and use the operation's results instead.
+///
+/// You don't instantiate this class. Instead, implement <doc://com.apple.documentation/documentation/uikit/uiapplicationdelegate/application(_:didreceiveremotenotification:fetchcompletionhandler:)> in your app delegate. Initialize ``CKNotification`` with the `userInfo` dictionary that CloudKit passes to the method. This returns an instance of the appropriate subclass. Use the ``CKNotification/notificationType`` property to determine the type. Then cast to that type to access type-specific properties and methods.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 NS_SWIFT_SENDABLE
 @interface CKQueryNotification : CKNotification
 
+/// The event that triggers the push notification.
+///
+/// Subscription notifications result from the creation, deletion, or updating of a single record. The record in question must match the subscription's predicate for an event to trigger.
 @property (readonly, assign, nonatomic) CKQueryNotificationReason queryNotificationReason;
 
-/// A set of key->value pairs for creates and updates.
+/// A dictionary of fields that have changes.
 ///
-/// You request the server fill out this property via the `desiredKeys` property of `CKSubscription.NotificationInfo`
+/// For record updates and creations, this property contains the subscription's desired keys. When you configure the notification info of a subscription, you specify the names of one or more fields in the ``CKSubscription/NotificationInfo/desiredKeys`` property. When a push notification triggers, CloudKit retrieves the values for each of those keys from the record and includes them in the notification's payload.
+///
+/// For query notifications that you fetch from a container, all keys and values are present. For query notifications that you create from push notifications, one or more keys and values may be missing. Push notification payloads have a size limit, and CloudKit can exclude record fields when a payload exceeds that limit. For information about the order, see the overview of this class.
 @property (nullable, readonly, copy, nonatomic) NSDictionary<NSString *, id> *recordFields;
 
+/// The ID of the record that CloudKit creates, updates, or deletes.
+///
+/// Use this value to fetch the record.
 @property (nullable, readonly, copy, nonatomic) CKRecordID *recordID;
 
+/// The type of database for the record zone.
+///
+/// This property's value is one of the constants that ``CKDatabase/Scope`` defines.
 @property (readonly, assign, nonatomic) CKDatabaseScope databaseScope API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
 @end
 
 
-/// A notification generated by a ``CKRecordZoneSubscription``
+/// A notification that triggers when the contents of a record zone change.
 ///
-/// `notificationType` == `.recordZone`
-/// When properties must be dropped (see @c isPruned), here's the order of importance.  The most important properties are first, they'll be the last ones to be dropped.
-/// - notificationID
-/// - badge
-/// - alertLocalizationKey
-/// - alertLocalizationArgs
-/// - alertBody
-/// - alertActionLocalizationKey
-/// - alertLaunchImage
-/// - soundName
-/// - content-available
-/// - recordZoneID
-/// - containerIdentifier
-/// - subscriptionOwnerUserRecordID
-/// - titleLocalizationKey
-/// - titleLocalizationArgs
-/// - title
-/// - subtitleLocalizationKey
-/// - subtitleLocalizationArgs
-/// - subtitle
+/// A record zone subscription executes when a user, or in certain scenarios, CloudKit, modifies a record in that zone, for example, when a field's value changes in a record. When CloudKit registers the change, it sends push notifications to the user's devices to inform your app about the change. You can then fetch the changes and cache them on-device. When appropriate, CloudKit excludes the device where the change originates.
+///
+/// You configure a subscription's notifications by setting it's ``CKSubscription/notificationInfo`` property. Do this before you save it to the server. A subscription generates either high-priority or medium-priority push notifications. CloudKit delivers medium-priority notifications to your app in the background. High-priority notifications are visual and the system displays them to the user. Visual notifications need the user's permission. For more information, see <doc://com.apple.documentation/documentation/usernotifications/asking-permission-to-use-notifications>.
+///
+/// A subscription uses ``CKSubscription/NotificationInfo`` to configure its notifications. For background delivery, set only its ``CKSubscription/NotificationInfo/shouldSendContentAvailable`` property to <doc://com.apple.documentation/documentation/swift/true>. If you set any other property, CloudKit treats the notification as high-priority.
+///
+/// - Note: To receive silent push notifications, add the Background Modes capability to your Xcode project, and select the "Background fetch" and "Remote notifications" options.
+///
+/// Don't rely on push notifications for specific changes to records because the system can coalesce them. CloudKit can omit data to keep the notification's payload size under the APNs size limit. Consider notifications an indication of remote changes. Use ``databaseScope`` to determine which database contains the changed record zone, and ``recordZoneID`` to determine which zone contains changed records. You can then fetch just those changes using ``CKFetchRecordZoneChangesOperation``. A notification's ``CKNotification/isPruned`` property is <doc://com.apple.documentation/documentation/swift/true> if CloudKit omits data.
+///
+/// You don't instantiate this class. Instead, implement <doc://com.apple.documentation/documentation/uikit/uiapplicationdelegate/application(_:didreceiveremotenotification:fetchcompletionhandler:)> in your app delegate. Initialize ``CKNotification`` with the `userInfo` dictionary that CloudKit passes to the method. This returns an instance of the appropriate subclass. Use the ``CKNotification/notificationType`` property to determine the type. Then cast to that type to access type-specific properties and methods.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 NS_SWIFT_SENDABLE
 @interface CKRecordZoneNotification : CKNotification
 
+/// The ID of the record zone that has changes.
 @property (nullable, readonly, copy, nonatomic) CKRecordZoneID *recordZoneID;
 
+/// The type of database for the record zone.
+///
+/// This property's value is one of the constants that ``CKDatabase/Scope`` defines.
 @property (readonly, assign, nonatomic) CKDatabaseScope databaseScope API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
 @end
 
 
-/// A notification generated by a ``CKDatabaseSubscription``
+/// A notification that triggers when the contents of a database change.
 ///
-/// `notificationType` == `.database`
-/// When properties must be dropped (see @c isPruned), here's the order of importance.  The most important properties are first, they'll be the last ones to be dropped.
-/// - notificationID
-/// - badge
-/// - alertLocalizationKey
-/// - alertLocalizationArgs
-/// - alertBody
-/// - alertActionLocalizationKey
-/// - alertLaunchImage
-/// - soundName
-/// - content-available
-/// - containerIdentifier
-/// - subscriptionOwnerUserRecordID
-/// - titleLocalizationKey
-/// - titleLocalizationArgs
-/// - title
-/// - subtitleLocalizationKey
-/// - subtitleLocalizationArgs
-/// - subtitle
+/// Database subscriptions execute when changes happen in any of a database's record zones, for example, when CloudKit saves a new record. When the subscription registers a change, it sends push notifications to the user's devices to inform your app about the change. You can then fetch the changes and cache them on-device. When appropriate, CloudKit excludes the device where the change originates.
+///
+/// You configure a subscription's notifications by setting it's ``CKSubscription/notificationInfo`` property. Do this before you save it to the server. A subscription generates either high-priority or medium-priority push notifications. CloudKit delivers medium-priority notifications to your app in the background. High-priority notifications are visual and the system displays them to the user. Visual notifications need the user's permission. For more information, see <doc://com.apple.documentation/documentation/usernotifications/asking-permission-to-use-notifications>.
+///
+/// A subscription uses ``CKSubscription/NotificationInfo`` to configure its notifications. For background delivery, set only its ``CKSubscription/NotificationInfo/shouldSendContentAvailable`` property to <doc://com.apple.documentation/documentation/swift/true>. If you set any other property, CloudKit treats the notification as high-priority.
+///
+/// - Note: To receive silent push notifications, add the Background Modes capability to your Xcode project, and select the "Background fetch" and "Remote notifications" options.
+///
+/// Don't rely on push notifications for specific changes because the system can coalesce them. CloudKit can omit data to keep the notification's payload size under the APNs size limit. Consider notifications an indication of remote changes. Use ``databaseScope`` to determine which database has changes, and then ``CKFetchDatabaseChangesOperation`` to fetch those changes. A notification's ``CKNotification/isPruned`` property is <doc://com.apple.documentation/documentation/swift/true> if CloudKit omits data.
+///
+/// You don't instantiate this class. Instead, implement <doc://com.apple.documentation/documentation/uikit/uiapplicationdelegate/application(_:didreceiveremotenotification:fetchcompletionhandler:)> in your app delegate. Initialize ``CKNotification`` with the `userInfo` dictionary that CloudKit passes to the method. This returns an instance of the appropriate subclass. Use the ``CKNotification/notificationType`` property to determine the type. Then cast to that type to access type-specific properties and methods.
 API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 NS_SWIFT_SENDABLE
 @interface CKDatabaseNotification : CKNotification
 
+/// The type of database.
+///
+/// This property's value is one of the constants that ``CKDatabase/Scope`` defines.
 @property (readonly, assign, nonatomic) CKDatabaseScope databaseScope;
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKOperation.h	2025-11-09 04:43:00
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKOperation.h	2026-02-13 10:48:12
@@ -13,121 +13,150 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// A type that represents the ID of an operation.
 typedef NSString *CKOperationID;
 
+/// The abstract base class for all operations that execute in a database.
+///
+/// All CloudKit operations descend from `CKOperation`, which provides the infrastructure for executing tasks in one of your app's containers. Don't subclass or create instances of this class directly. Instead, create instances of one of its concrete subclasses.
+///
+/// Use the properties of this class to configure the behavior of the operation before submitting it to a queue or executing it directly. CloudKit operations involve communicating with the iCloud servers to send and receive data. You can use the properties of this class to configure the behavior of those network requests to ensure the best performance for your app.
+///
+/// - Important: `CKOperation` objects have a default quality of service level of <doc://com.apple.documentation/documentation/foundation/qualityofservice/default> (see <doc://com.apple.documentation/documentation/foundation/operation/qualityofservice>). Operations with this service level are discretionary, and the system schedules them for an optimal time according to battery level and other factors. On iPhone, discretionary activities pause when the device is in Low Power Mode. For information about quality of service levels, see [Prioritize Work with Quality of Service Classes](https://developer.apple.com/library/archive/documentation/Performance/Conceptual/EnergyGuide-iOS/PrioritizeWorkWithQoS.html#//apple_ref/doc/uid/TP40015243-CH39) in [Energy Efficiency Guide for iOS Apps](https://developer.apple.com/library/archive/documentation/Performance/Conceptual/EnergyGuide-iOS/index.html#//apple_ref/doc/uid/TP40015243) and [Prioritize Work at the Task Level](https://developer.apple.com/library/archive/documentation/Performance/Conceptual/power_efficiency_guidelines_osx/PrioritizeWorkAtTheTaskLevel.html#//apple_ref/doc/uid/TP40013929-CH35) in [Energy Efficiency Guide for Mac Apps](https://developer.apple.com/library/archive/documentation/Performance/Conceptual/power_efficiency_guidelines_osx/index.html#//apple_ref/doc/uid/TP40013929).
+///
+/// ### Long-Lived Operations
+///
+/// A _long-lived operation_ is an operation that continues to run after the user closes the app. To specify a long-lived operation, set ``isLongLived`` to <doc://com.apple.documentation/documentation/swift/true>, provide a completion handler, and execute the operation. To get the identifiers of all running long-lived operations, use the ``CKContainer/allLongLivedOperationIDs()`` method that ``CKContainer`` provides. To get a specific long-lived operation, use the ``CKContainer/longLivedOperation(for:)`` method. Make sure you set the completion handler of a long-lived operation before you execute it so that the system can notify you when it completes and you can process the results. Do not execute an operation, change it to long-lived, and execute it again as a long-lived operation.
+///
+/// @TabNavigator {
+///     @Tab("Swift") {
+///         ```swift
+///         container.fetchAllLongLivedOperationIDs(completionHandler: { (operationIDs, error) in
+///             if let error = error {
+///                 print("Error fetching long lived operations: \(error)")
+///                 // Handle error
+///                 return
+///             }
+///             guard let identifiers = operationIDs else { return }
+///             for operationID in identifiers {
+///                 container.fetchLongLivedOperation(withID: operationID, completionHandler: { (operation, error) in
+///                     if let error = error {
+///                         print("Error fetching operation: \(operationID)\n\(error)")
+///                         // Handle error
+///                         return
+///                     }
+///                     guard let operation = operation else { return }
+///                     // Add callback handlers to operation
+///                     container.add(operation)
+///                 })
+///             }
+///         })
+///         ```
+///     }
+///     @Tab("Objective-C") {
+///         ```objc
+///         [container fetchAllLongLivedOperationIDsWithCompletionHandler:^(NSArray<NSString *> *_Nullable operationIDs, NSError *_Nullable error) {
+///             if (error) {
+///                 // Handle error
+///                 return
+///             }
+///             for (NSString *operationID in operationIDs) {
+///                 [container fetchLongLivedOperationWithID:operationID completionHandler:^(CKOperation *_Nullable operation, NSError *_Nullable error) {
+///                     if (error) {
+///                         // Handle error
+///                         return
+///                     }
+///                     // Add callback handlers to operation
+///                     [container addOperation:operation];
+///                 }];
+///             }
+///         }];
+///         ```
+///     }
+/// }
+///
+/// The following is the typical life cycle of a long-lived operation:
+///
+/// 1. The app creates a long-lived operation and executes it.
+///
+/// The daemon starts saving and sending the callbacks to the running app.
+/// 2. The app exits.
+///
+/// The daemon continues running the long-lived operation and saves the callbacks.
+/// 3. The app launches and fetches the long-lived operation.
+///
+/// If the operation is running or if it completed within the previous 24 hours, the daemon returns a proxy for the long-lived operation. If the operation completed more than 24 hours previously, the daemon may stop returning it in fetch requests.
+/// 4. The app runs the long-lived operation again.
+///
+/// The daemon sends the app all the saved callbacks (it doesn't actually rerun the operation), and continues saving the callbacks and sending them to the running app.
+/// 5. The app receives the completion callback or the app cancels the operation.
+///
+/// The daemon stops including the operation in future fetch results.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 @interface CKOperation : NSOperation
 
+/// Creates an operation.
+///
+/// - Important: Don't use this method directly. Instead, create database operations using the initializers of the concrete subclasses.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
 
-/*! @abstract This defines per-operation configuration settings.
- *
- *  @discussion See the CKOperationConfiguration class description for info on how this configuration composes with CKOperationGroup.defaultConfiguration
- */
+/// The operation's configuration.
 @property (null_resettable, copy, nonatomic) CKOperationConfiguration *configuration API_AVAILABLE(macos(10.13), ios(11.0), tvos(11.0), watchos(4.0));
 
-/*! @abstract The group this operation is associated with
- */
+/// The operation's group.
 @property (nullable, strong, nonatomic) CKOperationGroup *group API_AVAILABLE(macos(10.13), ios(11.0), tvos(11.0), watchos(4.0));
 
-/*! @abstract This is an identifier unique to this CKOperation.
- *
- *  @discussion This value is chosen by the system, and will be unique to this instance of a CKOperation.  This identifier will be sent to Apple's servers, and can be used to identify any server-side logging associated with this operation.
- */
+/// A unique identifier for a long-lived operation.
+///
+/// Pass this property's value to the ``CKContainer/longLivedOperation(for:)`` method to fetch the corresponding long-lived operation. For more information, see <doc:CKOperation#Long-Lived-Operations>.
 @property (readonly, copy, nonatomic) CKOperationID operationID API_AVAILABLE(macos(10.12), ios(9.3), tvos(9.2), watchos(3.0));
 
-/*! @abstract This callback is called after a long lived operation has begun running and is persisted.
- *
- *  @discussion Once this callback is called the operation will continue running even if the current process exits.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when the server begins to store callbacks for the long-lived operation.
+///
+/// If your app exits before CloudKit calls this property's value, the system doesn't include the operation's ID in the results of calls to the ``CKContainer/allLongLivedOperationIDs()`` method.
+///
+/// For more information, see <doc:CKOperation#Long-Lived-Operations>.
 @property (nullable, copy, nonatomic) void (^longLivedOperationWasPersistedBlock)(void) API_AVAILABLE(macos(10.12), ios(9.3), tvos(9.2), watchos(3.0));
 
 @end
 
-/*! @class CKOperationConfiguration
- *
- *  @discussion An operation configuration is a set of properties that describes how your operation should behave.  All properties have a default value.  When determining what properties to apply to an operation, we consult the operation's configuration property, as well as the operation->group->defaultConfiguration property.  We combine them following these rules:
- *  @code
- *   Group Default Configuration Value | Operation Configuration Value |        Value Applied To Operation
- *  -----------------------------------+-------------------------------+-----------------------------------------
- *             default value           |         default value         |                  default value
- *             default value           |         explicit value        |       operation.configuration explicit value
- *             explicit value          |         default value         | operation.group.defaultConfiguration explicit value
- *             explicit value          |         explicit value        |       operation.configuration explicit value
- *  @endcode
- *  For example:
- *  CKOperationGroup -> defaultConfiguration -> allowsCellularAccess explicitly set to NO
- *  + CKOperation -> configuration -> allowsCellularAccess has default value of YES
- *  = disallow cellular access
- *
- *  CKOperationGroup -> defaultConfiguration -> allowsCellularAccess explicitly set to NO
- *  + CKOperation -> configuration -> allowsCellularAccess explicitly set to YES
- *  = allow cellular access
- */
+/// An object that describes how a CloudKit operation behaves.
+///
+/// All of the properties in `CKOperationConfiguration` have a default value. When determining which properties to apply to a CloudKit operation, consult the operation's configuration property, as well as the ``CKOperationGroup/defaultConfiguration`` property of the group that the operation belongs to. These properties combine through the following rules:
+///
+/// | Group default configuration value | Operation configuration value | Value applied to operation |
+/// |---|---|---|
+/// | default value | default value | default value |
+/// | default value | explicit value | operation.configuration explicit value |
+/// | explicit value | default value | group.defaultConfiguration explicit value |
+/// | explicit value | explicit value | operation.configuration explicit value |
 API_AVAILABLE(macos(10.13), ios(11.0), tvos(11.0), watchos(4.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 // NS_SWIFT_SENDABLE on macos(13.3), macCatalyst(16.4), ios(16.4), tvos(16.4), watchos(9.4)
 @interface CKOperationConfiguration : NSObject
 
-/*! If no container is set, [CKContainer defaultContainer] is used */
+/// The configuration's container.
+///
+/// If you don't provide a container, CloudKit uses the default container that ``CKContainer`` provides.
 @property (nullable, strong) CKContainer *container;
 
-/*! @discussion CKOperations behave differently depending on how you set qualityOfService.
- *
- *  @code
- *  Quality of Service | timeoutIntervalForResource | Network Error Behavior | Discretionary Behavior
- *  -------------------+----------------------------+------------------------+-----------------------
- *  UserInteractive    | -1 (no enforcement)        | fail                   | nonDiscretionary
- *  UserInitiated      | -1 (no enforcement)        | fail                   | nonDiscretionary
- *  Default            | 1 week                     | fail                   | discretionary when app backgrounded
- *  Utility            | 1 week                     | internally retried     | discretionary when app backgrounded
- *  Background         | 1 week                     | internally retried     | discretionary
- *  @endcode
- * timeoutIntervalForResource
- * - the timeout interval for any network resources retrieved by this operation
- * - this can be overridden via CKOperationConfiguration's timeoutIntervalForResource property
- *
- * Network Error Behavior
- * - when a network request in service of a CKOperation fails due to a networking error, the operation may fail with that error, or internally retry the network request.  Only a subset of networking errors are retried, and limiting factors such as timeoutIntervalForResource are still applicable.
- *
- * Discretionary Behavior
- * - network requests in service of a CKOperation may be marked as discretionary
- * - discretionary network requests are scheduled at the description of the system for optimal performance
- *
- * CKOperations have a default qualityOfService of Default.
- */
+/// The priority that the system uses when it allocates resources to the operations that use this configuration.
 @property (assign) NSQualityOfService qualityOfService;
 
-
-/*! Defaults to @c YES */
+/// A Boolean value that indicates whether operations that use this configuration can send data over the cellular network.
 @property (assign) BOOL allowsCellularAccess;
 
-/*! @discussion Long lived operations will continue running even if your process exits. If your process remains alive for the lifetime of the long lived operation its behavior is the same as a regular operation.
- *
- *  Long lived operations can be fetched and replayed from the container via the @c fetchAllLongLivedOperations: and @c fetchLongLivedOperationsWithIDs: APIs. Your code should only fetch and re-enqueue long lived operations on app launch.
- *
- *  Long lived operations persist until their -[NSOperation completionBlock] returns or until the operation is cancelled.
- *  Long lived operations may be garbage collected 24 hours after they finish running if no client has replayed them.
- *
- *  The default value for longLived is NO. Changing the value of longLived on an already started operation or on an outstanding long lived operation fetched from CKContainer has no effect.
- */
+/// A Boolean value that indicates whether the operations that use this configuration are long-lived.
 @property (assign, getter=isLongLived) BOOL longLived;
 
-/*! @discussion If non-zero, overrides the timeout interval for any network requests issued by this operation.
- *  The default value is 60.
- *
- * @see NSURLSessionConfiguration.timeoutIntervalForRequest
- */
+/// The maximum amount of time that a request can take.
+///
+/// - SeeAlso: `NSURLSessionConfiguration.timeoutIntervalForRequest`
 @property (assign) NSTimeInterval timeoutIntervalForRequest;
 
-/*! @discussion If set, overrides the timeout interval for any network resources retrieved by this operation.
- *  If not explicitly set, defaults to a value based on the operation's @c qualityOfService
- *
- * @see NSURLSessionConfiguration.timeoutIntervalForResource
- */
+/// The maximum amount of time that a resource request can take.
+///
+/// - SeeAlso: `NSURLSessionConfiguration.timeoutIntervalForResource`
 @property (assign) NSTimeInterval timeoutIntervalForResource;
 
 
@@ -135,12 +164,62 @@
 
 #pragma mark - Deprecated CKOperation
 
-/*! These deprecated properties now read and write from the CKOperation's configuration */
+// These deprecated properties now read and write from the CKOperation's configuration
 @interface CKOperation (CKOperationDeprecated)
+
+/// The operation's container.
+///
+/// @DeprecationSummary {
+///     Use ``CKOperation/Configuration/container`` instead.
+/// }
+/// 
+/// The container defines where the operation executes. The ``CKContainer/add(_:)`` method of the ``CKContainer`` and ``CKDatabase`` classes implicitly set this property to their container.
+///
+/// If you execute the operation yourself, either directly or using a custom operation queue, set the value of this property explicitly. If the value is `nil` when you execute an operation, the operation implicitly executes in your app's default container.
 @property (nullable, strong, nonatomic) CKContainer *container          API_DEPRECATED("Use CKOperationConfiguration", macos(10.10, 10.13), ios(8.0, 11.0), tvos(9.0, 11.0), watchos(3.0, 4.0));
+
+/// A Boolean value that indicates whether the operation can send data over the cellular network.
+///
+/// @DeprecationSummary {
+///     Use ``CKOperation/Configuration/allowsCellularAccess`` instead.
+/// }
+/// 
+/// When you send or receive many records, or when you send records with large assets, you might set this property to <doc://com.apple.documentation/documentation/swift/false> to avoid consuming too much of the user's cellular data bandwidth. The default value is <doc://com.apple.documentation/documentation/swift/true>.
+///
+/// When this property is <doc://com.apple.documentation/documentation/swift/false>, the operation fails if Wi-Fi isn't available.
 @property (assign, nonatomic) BOOL allowsCellularAccess                 API_DEPRECATED("Use CKOperationConfiguration", macos(10.10, 10.13), ios(8.0, 11.0), tvos(9.0, 11.0), watchos(3.0, 4.0));
+
+/// A Boolean value that indicates whether the operation is long-lived.
+///
+/// @DeprecationSummary {
+///     Use ``CKOperation/Configuration/isLongLived`` instead.
+/// }
+/// 
+/// Set this property to <doc://com.apple.documentation/documentation/swift/true> to make the operation long-lived. The default value is <doc://com.apple.documentation/documentation/swift/false>. If you change this property's value after you execute the operation, the change has no effect.
+///
+/// For more information, see <doc:CKOperation#Long-Lived-Operations>.
 @property (assign, nonatomic, getter=isLongLived) BOOL longLived        API_DEPRECATED("Use CKOperationConfiguration", macos(10.12, 10.13), ios(9.3, 11.0), tvos(9.2, 11.0), watchos(3.0, 4.0));
+
+/// The timeout interval when waiting for additional data.
+///
+/// @DeprecationSummary {
+///     Use ``CKOperation/Configuration/timeoutIntervalForRequest`` instead.
+/// }
+/// 
+/// This property determines the request timeout interval for the operation, which controls how long, in seconds, the operation waits for additional data to arrive before stopping. The timer for this value resets whenever new data arrives. When the timer reaches the interval without receiving any new data, it triggers a timeout.
+///
+/// The default value is `60`.
 @property (assign, nonatomic) NSTimeInterval timeoutIntervalForRequest  API_DEPRECATED("Use CKOperationConfiguration", macos(10.12, 10.13), ios(10.0, 11.0), tvos(10.0, 11.0), watchos(3.0, 4.0));
+
+/// The maximum amount of time that a resource request can use.
+///
+/// @DeprecationSummary {
+///     Use ``CKOperation/Configuration/timeoutIntervalForResource`` instead.
+/// }
+/// 
+/// This property determines the resource timeout interval for this operation, which controls how long, in seconds, to wait for the entire operation to complete before stopping. The resource timer starts when the operation executes and counts until either the operation completes or this timeout interval occurs, whichever comes first.
+///
+/// The default value is `604800`, the number of seconds in 7 days.
 @property (assign, nonatomic) NSTimeInterval timeoutIntervalForResource API_DEPRECATED("Use CKOperationConfiguration", macos(10.12, 10.13), ios(10.0, 11.0), tvos(10.0, 11.0), watchos(3.0, 4.0));
 @end
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKOperationGroup.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKOperationGroup.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKOperationGroup.h	2025-11-09 05:05:27
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKOperationGroup.h	2026-02-13 10:44:53
@@ -13,93 +13,86 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-/*! @enum CKOperationGroupTransferSize
- *  @abstract Valid values for expectedSendSize and expectedReceiveSize
- *  @constant CKOperationGroupTransferSizeUnknown Default value when you're completely unsure of your working set size.
- *  @constant CKOperationGroupTransferSizeKilobytes Less than 1MB
- *  @constant CKOperationGroupTransferSizeMegabytes 1-10MB
- *  @constant CKOperationGroupTransferSizeTensOfMegabytes 10-100MB
- *  @constant CKOperationGroupTransferSizeHundredsOfMegabytes 100MB-1GB
- *  @constant CKOperationGroupTransferSizeGigabytes 1-10GB
- *  @constant CKOperationGroupTransferSizeTensOfGigabytes 10-100GB
- *  @constant CKOperationGroupTransferSizeHundredsOfGigabytes More than 100GB
- */
+/// Constants that represent possible data transfer sizes.
 typedef NS_ENUM(NSInteger, CKOperationGroupTransferSize) {
+    /// An unknown transfer size.
     CKOperationGroupTransferSizeUnknown,
+
+    /// A transfer size that represents 1 or more kilobytes.
     CKOperationGroupTransferSizeKilobytes,
+
+    /// A transfer size that represents 1 or more megabytes.
     CKOperationGroupTransferSizeMegabytes,
+
+    /// A transfer size that represents tens of megabytes.
     CKOperationGroupTransferSizeTensOfMegabytes,
+
+    /// A transfer size that represents hundreds of megabytes.
     CKOperationGroupTransferSizeHundredsOfMegabytes,
+
+    /// A transfer size that represents 1 or more gigabytes.
     CKOperationGroupTransferSizeGigabytes,
+
+    /// A transfer size that represents tens of gigabytes.
     CKOperationGroupTransferSizeTensOfGigabytes,
+
+    /// A transfer size that represents hundreds of gigabytes.
     CKOperationGroupTransferSizeHundredsOfGigabytes,
 } API_AVAILABLE(macos(10.13), ios(11.0), tvos(11.0), watchos(4.0));
 
-/*! @class CKOperationGroup
- *
- *  @abstract A mechanism for your app to group several operations at the granularity of a user action.
- *
- *  @discussion For example, when building a Calendar application, these things might warrant being their own operation groups:
- *  - an initial fetch of data from the server, consisting of many queries, fetchChanges, and fetch operations
- *  - doing an incremental fetch of data in response to a push notification
- *  - saving several records due to a user saving a calendar event
- *
- *  You associate @c CKOperationGroup s with@c  CKOperation s by setting the @c CKOperation.group property.  Create a new @c CKOperationGroup instance for each distinct user action.
- */
+/// An explicit association between two or more operations.
+///
+/// In certain situations, you might want to perform several CloudKit operations together. Grouping operations in CloudKit doesn't ensure atomicity.
+///
+/// For example, when building a Calendar app, you group the following actions:
+///
+/// - Fetch records from CloudKit, which consists of numerous queries that fetch both new records and records with changes.
+/// - Perform incremental fetches of records in response to a push notification.
+/// - Update several records when the user saves a calendar event.
+///
+/// Associate operation groups with operations by setting their ``CKOperation/group`` property. Create a new operation group for each distinct user interaction.
 API_AVAILABLE(macos(10.13), ios(11.0), tvos(11.0), watchos(4.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 // NS_SWIFT_SENDABLE on macos(13.3), macCatalyst(16.4), ios(16.4), tvos(16.4), watchos(9.4)
 @interface CKOperationGroup : NSObject <NSSecureCoding, NSCopying>
 
+/// Creates an operation group.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation group from a serialized instance.
+///
+/// - Parameters:
+///   - aDecoder: The coder to use when deserializing the group.
 - (instancetype)initWithCoder:(NSCoder *)aDecoder NS_DESIGNATED_INITIALIZER;
 
-/*! @abstract This is an identifier unique to this @c CKOperationGroup
- *
- *  @discussion This value is chosen by the system, and will be unique to this instance of a @c CKOperationGroup.  This identifier will be sent to Apple's servers, and can be used to identify any server-side logging associated with this operation group.
- */
+/// The operation group's unique identifier.
+///
+/// The framework generates this value and it's unique to this operation group. The system sends this identifier to CloudKit, which can use it to identify server-side logs for ``CKOperationGroup``.
 @property (readonly, copy, nonatomic) NSString *operationGroupID;
  
-/*! @abstract This is the default configuration applied to operations in this operation group.
- *
- *  @discussion If an operation associated with this operation group has its own configuration, then any explicitly-set properties in that operation's configuration will override these default configuration values.  See the example in CKOperation.h
- */
+/// The default configuration for operations in the group.
+///
+/// If an operation in the group has its own configuration, that configuration's values override the default configuration's values. For more information, see ``CKOperation/Configuration``.
 @property (null_resettable, copy) CKOperationConfiguration *defaultConfiguration;
 
-/*! @abstract Describes the user action attributed to the operation group.
- *
- *  @discussion @c name should describe the type of work being done.  Some examples:
- *  "Initial Fetch"
- *  "Incremental Fetch"
- *  "Saving User-Entered Record"
- *  This string will be sent to Apple servers to provide aggregate reporting for @c CKOperationGroup s and therefore must not include personally identifying data.
- */
+/// The operation group's name.
+///
+/// The system sends the name of the operation group to CloudKit to provide aggregate reporting for ``CKOperationGroup``. The name must not include any personal data.
 @property (nullable, copy) NSString *name;
 
-/*! @abstract Describes an application-specific "number of elements" associated with the operation group.
- *
- *  @discussion @c quantity is intended to show the app-specific count of items contained within the operation group.  It is your job to assign meaning to this value.  For example, if an app created an operation group to save 3 calendar events the user had created, the app might want to set this to "3".  This value is not shown to your users, it's meant to aid your development and debugging.  This value will be reported in the CloudKit Dashboard's log entries for all operations associated with this operation group.
- */
+/// The number of operations in the operation group.
+///
+/// This property shows the number of operations that you expect to be in this operation group. It's the developer's responsibility to set this value.
 @property (assign) NSUInteger quantity;
 
-/*! @abstract Estimated size of traffic being uploaded to the CloudKit Server
- *
- *  @discussion Inform the system how much data you plan on transferring.  Obviously, these won't be exact.  Be as accurate as possible, but even an order-of-magnitude estimate is better than no value.  The system will consult these values when scheduling discretionary network requests (see the description of @c CKOperationConfiguration.qualityOfService).
- *  Overestimating your workload means that an operation group issuing discretionary network requests may be delayed until network conditions are good.
- *  Underestimating your workload may cause the system to oversaturate a constrained connection, leading to network failures.
- *  You may update after the @c CKOperationGroup is created.  If it is increased, then subsequent @c CKOperation s associated with this operation group may be delayed until network conditions are good.
- *  Defaults to @c CKOperationGroupTransferSizeUnknown
- */
+/// The estimated size of traffic to upload to CloudKit.
+///
+/// This property informs the system about the amount of data your app can transfer. An order-of-magnitude estimate is better than no estimate, and accuracy helps performance. The system checks this value when it schedules discretionary network requests.
 @property (assign) CKOperationGroupTransferSize expectedSendSize;
 
-/*! @abstract Estimated size of traffic being downloaded from the CloudKit Server
- *
- *  @discussion Inform the system how much data you plan on transferring.  Obviously, these won't be exact.  Be as accurate as possible, but even an order-of-magnitude estimate is better than no value.  The system will consult these values when scheduling discretionary network requests (see the description of @c CKOperationConfiguration.qualityOfService).
- *  Overestimating your workload means that an operation group issuing discretionary network requests may be delayed until network conditions are good.
- *  Underestimating your workload may cause the system to oversaturate a constrained connection, leading to network failures.
- *  You may update after the @c CKOperationGroup is created.  If it is increased, then subsequent @c CKOperation s associated with this operation group may be delayed until network conditions are good.
- *  Defaults to @c CKOperationGroupTransferSizeUnknown
- */
+/// The estimated size of traffic to download from CloudKit.
+///
+/// This property informs the system about the amount of data your app can transfer. An order-of-magnitude estimate is better than no estimate, and accuracy helps performance. The system checks this value when it schedules discretionary network requests.
 @property (assign) CKOperationGroupTransferSize expectedReceiveSize;
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKQuery.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKQuery.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKQuery.h	2025-11-09 04:37:40
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKQuery.h	2026-02-13 09:49:22
@@ -11,24 +11,179 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-/*! @class CKQuery
- *
- *  @discussion Only AND compound predicates are allowed.
- *
- *  Key names must begin with either an upper or lower case character ([a-zA-Z]) and may be followed by characters, numbers, or underscores ([0-9a-zA-Z_]). Keypaths may only resolve to the currently evaluated object, so the '.' character is not allowed in key names.
- *
- *  A limited subset of classes are allowed as predicate arguments:
- *  - NSString
- *  - NSDate
- *  - NSData
- *  - NSNumber
- *  - NSArray
- *  - CKReference
- *  - CKRecord
- *  - CLLocation
- *
- * Any other class as an argument will result in an error when executing the query.
- */
+/// A query that describes the criteria to apply when searching for records in a database.
+///
+/// You create a query as the first step in the search process. The query stores the search parameters, including the type of records to search, the match criteria (predicate) to apply, and the sort parameters to apply to the results. Then you use the query to initialize an instance of ``CKQueryOperation``, which you execute to generate the results.
+///
+/// Always designate a record type and predicate when you create a query object. The record type narrows the scope of the search to one type of record, and the predicate defines the conditions for matching records of that type. Predicates usually compare one or more fields of a record to constant values, but you can create predicates that return all records of a specific type or perform more nuanced searches.
+///
+/// Because you can't change the record type and predicate after initialization, you can use the same query to initialize multiple instances of ``CKQueryOperation``, each of which targets a different database or record zone.
+///
+/// ### Building Your Predicates
+///
+/// An <doc://com.apple.documentation/documentation/foundation/nspredicate> object defines the logical conditions for determining whether a record is a match for a query. Queries support only a subset of the predicate behaviors that the `NSPredicate` class offers.
+///
+/// #### Predicate Rules for Query Objects
+///
+/// The predicates you create for your query objects must follow these rules:
+///
+/// - Predicates derive from a format string. You can't use value or block-based predicates.
+/// - Predicates use only the operators in <doc:Supported-Predicate-Operators>.
+/// - Predicates operate only on fields that contain the following types of data:
+///
+///   - <doc://com.apple.documentation/documentation/foundation/nsstring>
+///   - <doc://com.apple.documentation/documentation/foundation/nsdata>
+///   - <doc://com.apple.documentation/documentation/foundation/nsdate>
+///   - <doc://com.apple.documentation/documentation/foundation/nsnumber>
+///   - <doc://com.apple.documentation/documentation/foundation/nsarray>
+///   - ``CKRecord/Reference``
+///   - <doc://com.apple.documentation/documentation/corelocation/cllocation>
+///
+/// - Key names in predicates correspond to fields in the currently evaluated record. Key names can include the names of the record's metadata properties, such as `creationDate`, or any data fields you add to the record. You can't use key paths to specify fields in related records.
+///
+/// - Predicates support the following variable substitution strings:
+///   - Use `%@` for value objects, such as strings, numbers, and dates.
+///   - Use `%K` for the name of a field. This substitution variable indicates that the system uses the substitution string to look up a field name.
+///
+/// - With one exception, the `CONTAINS` operator is only for testing list membership. The exception is when you use it to perform full-text searches in conjunction with the `self` key path. The `self` key path causes the server to look in searchable string-based fields for the specified token string. For example, a predicate string of `@"self contains 'blue'"` searches for the word _blue_ in all fields that you mark for inclusion in full-text searches. You can't use the `self` key path to search in fields with a type that isn't a string.
+/// - You can combine the `ANY` and `SOME` aggregate operators with the `IN` and `CONTAINS` operators to perform list membership tests.
+/// - The `distanceToLocation:fromLocation:` operator function performs a radius-based location comparison and that comparison must determine whether the location value is inside the circular area you provide. You can't use it to search for locations outside the specified circular area. Location indexes have a resolution of no less than 10 km.
+/// - CloudKit doesn't support the `ALL` aggregate operator.
+/// - CloudKit doesn't support the `NOT` compound operator in the following cases:
+///
+///   - You can't use it to negate an `AND` compound predicate.
+///   - You can't use it in tokenized queries, such as `self CONTAINS 'value'`.
+///   - You can't use it with the `distanceToLocation:fromLocation:` function.
+///   - You can't use it in `BETWEEN` queries.
+///
+/// #### Supported Predicate Operators
+///
+/// The following table lists the operators you can use in predicates for a query.
+///
+/// | Operation | Supported operators |
+/// |---|---|
+/// | Basic comparisons | `=`, `==` ![](spacer) `>=`, `=>` ![](spacer) `<=`, `=<` ![](spacer) `<` ![](spacer) `>` ![](spacer) `!=`, `<>` ![](spacer) `BETWEEN` |
+/// | Boolean value predicates | `TRUEPREDICATE` ![](spacer) `FALSEPREDICATE` |
+/// | Basic compound predicates | `AND`, `&&` ![](spacer) `NOT` |
+/// | String comparisons | `BEGINSWITH` |
+/// | Aggregate operations | `IN` ![](spacer) `CONTAINS` |
+/// | Functions | `distanceToLocation:fromLocation:` ![](spacer) `now` ![](spacer) `tokenize:using:` |
+///
+/// Specifying an unsupported operator or data type in your query's predicate results in an error when you execute the query. For more information about creating predicate objects, see [Predicate Programming Guide](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Predicates/AdditionalChapters/Introduction.html#//apple_ref/doc/uid/TP40001789).
+///
+/// #### Sample Predicate Format Strings
+///
+/// To match records that link to a different record with an ID you know, create a predicate that matches a field that contains a reference as Listing 1 shows. In the example, the `employee` field of the record contains a ``CKRecord/Reference`` object that points to another record. When CloudKit executes the query, a match occurs when the ID in the locally-created ``CKRecord/Reference`` object is the same ID as in the specified field of the record.
+///
+/// Listing 1. Matching the ID of a record
+///
+/// ```objc
+/// CKReference* recordToMatch = [[CKReference alloc] initWithRecordID:employeeID action:CKReferenceActionNone];
+/// NSPredicate* predicate = [NSPredicate predicateWithFormat:@"employee == %@", recordToMatch];
+/// ```
+///
+/// To match the contents of a field to a specific value, use a predicate similar to the ones in Listing 2. All of the listed predicates generate the same set of results, which in the example means that the `favoriteColors` field contains the value _red_. The value in the field must match the value you specify in the predicate exactly. String-based comparisons are case-insensitive, but otherwise, all comparisons must be an exact match of the specified value.
+///
+/// Listing 2. Matching a field to a specific value
+///
+/// ```objc
+/// NSPredicate *predicate = nil;
+/// predicate = [NSPredicate predicateWithFormat:@"ANY favoriteColors = 'red'"];
+/// predicate = [NSPredicate predicateWithFormat:@"favoriteColors CONTAINS 'red'"];
+/// predicate = [NSPredicate predicateWithFormat:@"'red' IN favoriteColors"];
+/// predicate = [NSPredicate predicateWithFormat:@"%K CONTAINS %@", @"favoriteColors", @"red"];
+/// ```
+///
+/// You can match more than one value at a time by using a predicate similar to the ones in Listing 3. In the example, the predicates report a match if the value in the `favoriteColor` field of a record matches either of the values `red` or `green`.
+///
+/// Listing 3. Matching a field to one or more values
+///
+/// ```objc
+/// NSPredicate *predicate = nil;
+/// predicate = [NSPredicate predicateWithFormat:@"ANY { 'red', 'green' } = favoriteColor"];
+/// predicate = [NSPredicate predicateWithFormat:@"favoriteColor IN { 'red', 'green' }"];
+/// ```
+///
+/// For fields that contain string values, you can match the beginning portion of the string using the `BEGINSWITH` operator as Listing 4 shows. You can't use other string comparison operators, such as `CONTAINS` or `ENDSWITH`. When using this operator, the field must contain a string value and must start with the string you specify. Matches are case-sensitive. In the examples, the predicate matches records where the `favoriteColors` field contains the strings _red_, _reddish_, or _red_` `_green_` `_duct_` `_tape_.
+///
+/// Listing 4. Matching a field that starts with a string value
+///
+/// ```objc
+/// NSString* matchString = @"red";
+/// NSPredicate *predicate = nil;
+/// predicate = [NSPredicate predicateWithFormat:@"ANY favoriteColors BEGINSWITH 'red'"]
+/// predicate = [NSPredicate predicateWithFormat:@"ANY favoriteColors BEGINSWITH %@", matchString]
+/// ```
+///
+/// To perform a tokenized search of a record's fields, use the special operator `self`. A tokenized search searches any fields where you enable full-text search, which is all string-based fields by default. CloudKit treats each distinct word in the tokenized string as a separate token for the purpose of searching. Comparisons are case- and diacritic-insensitive. These token strings can be in a single field or in multiple fields.
+///
+/// Listing 5 shows an example that searches the fields of a record for the token strings `bob` or `smith`:
+///
+/// Listing 5. Matching a field that contains one or more tokens
+///
+/// ```objc
+/// NSPredicate *predicate = nil;
+/// predicate = [NSPredicate predicateWithFormat:@"self contains 'bob smith'"];
+/// ```
+///
+/// To search for multiple tokens present in the fields, use the `AND` predicate operator, as Listing 6 shows.
+///
+/// Listing 6. Matching a field that contains multiple tokens
+///
+/// ```objc
+/// NSPredicate *predicate = nil;
+/// predicate = [NSPredicate predicateWithFormat:@"self contains 'bob' AND self contains 'smith'"];
+/// ```
+///
+/// To test whether two locations are near each other, create a predicate using the `distanceToLocation:fromLocation:` function as Listing 7 shows. Predicates that use this function must have the structure in the listing. In your code, replace the `location` variable with a field name from one of your records. This data type for the field must be a <doc://com.apple.documentation/documentation/corelocation/cllocation> object. Similarly, replace the `fixedLoc` and `radius` values with appropriate values from your app. The `fixedLoc` value is the geographic coordinate that marks the center of a circle with the specified radius. In this example, the predicate returns a match if the location in the record is within 10 kilometers of the specified latitude and longitude.
+///
+/// Listing 7. Matching by distance from a location
+///
+/// ```objc
+/// CLLocation* fixedLoc = [[CLLocation alloc] initWithLatitude:37.331913 longitude:-122.030210];
+/// CGFloat radius = 10; // kilometers
+/// NSPredicate *predicate =
+///    [NSPredicate predicateWithFormat:@"distanceToLocation:fromLocation:(location, %@) < %f", fixedLoc, radius]];
+/// ```
+///
+/// To retrieve all records of a specific type, use the `TRUEPREDICATE` expression as Listing 8 shows. A predicate with this operator always evaluates to `true` and, therefore, matches every record. When using such an operator, use a cursor to batch the results into smaller groups for processing.
+///
+/// - Note: The `distanceToLocation:fromLocation:` operator function performs a radius-based location comparison, and that comparison must determine whether the location value is inside the circular area you provide. You can't use it to search for locations outside the specified circular area. Location indexes have a resolution of no less than 10 km.
+///
+/// Listing 8. Retrieving all records of a specific type
+///
+/// ```objc
+/// NSPredicate *predicate = nil;
+/// predicate = [NSPredicate predicateWithFormat:@"TRUEPREDICATE"];
+/// ```
+///
+/// ### Indexes and Full-Text Search
+///
+/// Indexes make it possible to search the contents of your records efficiently. During development, the server indexes all fields with data types it can use in the predicate of a query. This automatic indexing makes it easier to experiment with queries during development, but the indexes require space in a database, and require time to generate and maintain. So when migrating to a production environment, remove the indexes for any fields that you don't use in queries.
+///
+/// Full-text search is another feature that is on by default for all fields during development. When you move to the production environment, disable full-text search for fields with content you don't need to search. As with removing indexes, disabling full-text search improves the performance of your tokenized searches. To configure the indexing and full-text search options for fields in your schema, use CloudKit Dashboard.
+///
+/// In a full-text search, CloudKit ignores the following words if they appear in the token strings:
+///
+/// | a | by | not | then |
+/// |---|---|---|---|
+/// | an | for | of | there |
+/// | and | if | on | these |
+/// | are | in | or | they |
+/// | as | into | such | this |
+/// | at | is | that | to |
+/// | be | it | the | was |
+/// | but | no | their | will |
+/// |  |  |  | with |
+///
+/// ### Executing a Search Using Your Query Object
+///
+/// To execute a query, do one of the following:
+///
+/// - Create an instance of ``CKQueryOperation`` using your query. Run the operation directly or add it to an operation queue to perform the query and deliver the results.
+/// - Call the ``CKDatabase/perform(_:inZoneWith:completionHandler:)`` method of ``CKDatabase`` to execute the query. Process the results in your completion handler.
+///
+/// Queries always run asynchronously and deliver results to a completion handler that you provide.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 // NS_SWIFT_SENDABLE on macos(14.0), ios(17.0), tvos(17.0), watchos(10.0)
@@ -36,14 +191,41 @@
 
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
+
+/// Creates an operation group from a serialized instance.
+///
+/// - Parameters:
+///   - aDecoder: The coder to use when deserializing the group.
 - (instancetype)initWithCoder:(NSCoder *)aDecoder NS_DESIGNATED_INITIALIZER;
 
-/*! Use @code [NSPredicate predicateWithValue:YES] / NSPredicate(value: true) @endcode if you want to query for all records of a given type. */
+/// Creates a query with the specified record type and predicate.
+///
+/// - Parameters:
+///   - recordType: The type of record to search. Specify the name of one of your app's supported record types. The method throws an exception if this parameter is `nil` or contains an empty string.
+///   - predicate: The search predicate to apply to the prospective records. Only records that match the predicate criteria appear in the search results. For guidelines on how to construct predicates for your queries, see <doc:CKQuery#Predicate-Rules-for-Query-Objects>. This parameter must not be `nil`.
+///
+/// - Returns: An initialized query object.
+///
+/// You can't change the record type and predicate of a query after you create it. If you want to search for a different set of records using a different set of search criteria, create a new query. You can add sort descriptors to the query and change them later as necessary.
+///
+/// You can't query for user records, and executing a query where the record type is ``CKRecordTypeUserRecord-49k30`` results in an error. You must fetch user records directly using their IDs.
 - (instancetype)initWithRecordType:(CKRecordType)recordType predicate:(NSPredicate *)predicate NS_DESIGNATED_INITIALIZER;
 
+/// The record type to search.
+///
+/// A query's results include only records of the specified type. The record type is an app-specific string that you use to distinguish among the records of your app. The records of a particular type all represent different instances of the same information. For example, an employee record type might store the employee's name, phone number, and a reference to the employee's manager.
 @property (readonly, copy) CKRecordType recordType;
+
+/// The predicate to use for matching records.
+///
+/// A predicate contains one or more expressions that evaluate to <doc://com.apple.documentation/documentation/swift/true> or <doc://com.apple.documentation/documentation/swift/false>. Expressions are often value-based comparisons, but predicates support other types of operators, including string comparisons and aggregate operations. For guidelines on how to construct predicates for your queries, see <doc:CKQuery#Predicate-Rules-for-Query-Objects>.
 @property (readonly, copy) NSPredicate *predicate;
 
+/// The sort descriptors for organizing the query's results.
+///
+/// You can add sort descriptors to a query and change them later as necessary. Each sort descriptor contains a field name of the intended record type and information about whether to sort values in that field in ascending or descending order. The default value of this property is `nil`, which means that records return in an indeterminate order.
+///
+/// The order of the items in the array defines the order that CloudKit applies the sort descriptors to the results. In other words, CloudKit applies the first sort descriptor in the array, then the second sort descriptor, if necessary, then the third, and so on.
 @property (nullable, copy) NSArray<NSSortDescriptor *> *sortDescriptors;
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKQueryOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKQueryOperation.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKQueryOperation.h	2025-11-12 05:59:06
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKQueryOperation.h	2026-02-13 10:44:53
@@ -15,6 +15,11 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An object that marks the stopping point for a query and the starting point for retrieving the remaining results.
+///
+/// You don't create instances of this class yourself. When fetching records using a query operation, if the number of results exceeds the limit for the query, CloudKit provides a cursor. Use that cursor to create a new instance of ``CKQueryOperation`` and retrieve the next batch of results for the same query.
+///
+/// For information about how to use a ``CKQueryOperation/Cursor`` object, see ``CKQueryOperation``.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 // NS_SWIFT_SENDABLE on macos(13.3), macCatalyst(16.4), ios(16.4), tvos(16.4), watchos(9.4)
@@ -23,72 +28,124 @@
 + (instancetype)new NS_UNAVAILABLE;
 @end
 
-/*! @discussion Query operations have a dynamically defined maximum number of results.  If the results of a query exceed this max, your completion block will invoked with a cursor.
- *  Issue a new query with that cursor to fetch the next batch of results.
- */
+/// A constant value that represents the maximum number of results CloudKit retrieves.
+///
+/// The value of this constant doesn't correspond to the actual number of records. CloudKit dynamically determines the actual number according to various conditions at runtime.
+///
+/// This constant is the ``CKQueryOperation/resultsLimit`` property's default value.
 CK_EXTERN const NSUInteger CKQueryOperationMaximumResults API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0));
 
+/// An operation for executing queries in a database.
+///
+/// A `CKQueryOperation` object is a concrete operation that you can use to execute queries. A query operation applies query parameters to the specified database and record zone, delivering any matching records asynchronously to the handlers that you provide.
+///
+/// To perform a new search:
+///
+/// 1. Initialize a `CKQueryOperation` object with a ``CKQuery`` object that contains the search criteria and sorting information for the records you want.
+/// 2. Assign a handler to the ``queryCompletionBlock`` property so that you can process the results and execute the operation.
+///
+/// If the search yields many records, the operation object may deliver a portion of the total results to your blocks immediately, along with a cursor for obtaining the remaining records. Use the cursor to initialize and execute a separate `CKQueryOperation` instance when you're ready to process the next batch of results.
+/// 3. Optionally, configure the results by specifying values for the ``resultsLimit`` and ``desiredKeys-4a6vy`` properties.
+/// 4. Pass the query operation object to the ``CKDatabase/add(_:)`` method of the target database to execute the operation.
+///
+/// CloudKit restricts queries to the records in a single record zone. For new queries, you specify the zone when you initialize the query operation object. For cursor-based queries, the cursor contains the zone information. To search for records in multiple zones, you must create a separate `CKQueryOperation` object for each zone you want to search, although you can initialize each of them with the same ``CKQuery`` object.
+///
+/// If you assign a handler to the operation's <doc://com.apple.documentation/documentation/foundation/operation/completionblock> property, the operation calls it after it executes and returns any results. Use a handler to perform housekeeping tasks for the operation, but don't use it to process the results of the operation. The handler you provide should manage any failures, whether due to an error or an explicit cancellation.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 @interface CKQueryOperation : CKDatabaseOperation
 
-/*! Queries invoked within a sharedCloudDatabase must specify a zoneID.  Cross-zone queries are not supported in a sharedCloudDatabase */
+/// Creates an empty query operation.
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Creates an operation that searches for records in the specified record zone.
+///
+/// - Parameters:
+///   - query: The query for the search.
+///
+/// You can use the operation that this method returns only once to perform a search, but you can reuse the query that you provide. During execution, the operation performs a new search and returns the first batch of results. If there are more results available, you must create a separate query object using the provided cursor object.
 - (instancetype)initWithQuery:(CKQuery *)query;
+
+/// Creates an operation with additional results from a previous search.
+///
+/// - Parameters:
+///   - cursor: The cursor that identifies the previous search. CloudKit passes this value to the completion handler of the previous search. For more information, see the ``CKQueryOperation/queryCompletionBlock`` property.
+///
+/// Use this method to create an operation that retrieves the next batch of results from a previous search. When executing searches for a cursor, don't cache cursors for a long time before using them. A cursor isn't a snapshot of the previous search results; it stores a relative offset into the results list. An operation that you create from a cursor performs a new search, sorts the new set of results, and uses the previous offset value to determine where the next batch of results starts.
 - (instancetype)initWithCursor:(CKQueryCursor *)cursor;
 
+/// The query for the search.
+///
+/// The initial value of this property is the query that you provide to the ``CKQueryOperation/init(query:)`` method. When the value in the ``CKQueryOperation/cursor`` property is `nil`, the operation uses this property's value to execute a new search and return its results to your completion handler. If ``CKQueryOperation/cursor`` isn't `nil`, the operation uses the cursor instead.
+///
+/// If you intend to specify or change the value of this property, do so before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) CKQuery *query;
+
+/// The cursor for continuing the search.
+///
+/// The initial value of this property is the cursor that you provide to the ``CKQueryOperation/init(cursor:)`` method. When you use a cursor, the operation ignores the contents of the ``CKQueryOperation/query`` property. This property's value is an opaque value that CloudKit provides. For more information, see the ``CKQueryOperation/queryCompletionBlock`` property.
+///
+/// If you intend to specify or change the value in this property, do so before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) CKQueryCursor *cursor;
 
-/*! @abstract Indicates which record zone to query.
- *
- *  @discussion For query operations constructed using a cursor, this property is ignored and instead will be evaluated in the record zone in which the cursor was originally created.
- *  Queries that do not specify a @c zoneID will perform a query across all zones in the database.
- */
+/// The ID of the record zone that contains the records to search.
+///
+/// The value of this property limits the scope of the search to only the records in the specified record zone. If you don't specify a record zone, the search includes all record zones.
+///
+/// When you create an operation using the ``CKQueryOperation/init(cursor:)`` method, this property's value is `nil` and CloudKit ignores any changes that you make to it. When the operation executes, the cursor provides the record zone information from the original search that provides the cursor.
 @property (nullable, copy, nonatomic) CKRecordZoneID *zoneID;
 
-/*! @discussion Defaults to @c CKQueryOperationMaximumResults.
- *  Queries may return fewer than @c resultsLimit in some scenarios:
- *  - There are legitimately fewer than @c resultsLimit number of records matching the query (and visible to the current user).
- *  - During the process of querying and fetching the results, some records were deleted, or became un-readable by the current user.
- *  When determining if there are more records to fetch, always check for the presence of a cursor in @c queryCompletionBlock.
- */
+/// The maximum number of records to return at one time.
+///
+/// For most queries, leave the value of this property as the default value, which is the ``CKQueryOperation/maximumResults`` constant. When using that value, CloudKit returns as many records as possible while minimizing delays in receiving those records. If you want to process a fixed number of results, change the value of this property accordingly.
 @property (assign, nonatomic) NSUInteger resultsLimit;
 
-/*! @abstract Declares which user-defined keys should be fetched and added to the resulting CKRecords.
- *
- *  @discussion If nil, declares the entire record should be downloaded. If set to an empty array, declares that no user fields should be downloaded.
- *  Defaults to @c nil.
- */
+/// The fields of the records to fetch.
+///
+/// Use this property to limit the amount of data that CloudKit returns for each record. When CloudKit returns a record, it only includes fields with names that match one of the keys in this property. The property's default value is `nil`, which instructs CloudKit to return all of a record's keys.
+///
+/// If you intend to specify a value other than `nil`, do so before you execute the operation or add the operation to a queue.
 @property (nullable, copy, nonatomic) NSArray<CKRecordFieldKey> *desiredKeys;
 
-/*! @abstract This block will be called once for every record that is returned as a result of the query.
- *
- *  @discussion The callbacks will happen in the order that the results were sorted in.
- *  If the replacement callback @c recordMatchedBlock is set, this callback block is ignored.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when a record becomes available.
+///
+/// The closure returns no value and takes the following parameter:
+///
+/// - A single record that matches the search criteria.
+///
+/// After identifying and sorting the records, the query operation executes this closure once for each of the result's records. The closure executes serially with respect to all other closures of the operation, so you can expect only one closure at a time to execute for this operation.
+///
+/// Set the property's value before you execute the operation or submit it to a queue.
+///
+/// - Warning: Query indexes update asynchronously so they aren't always current. If you query for records that you recently changed and don't allow enough time for those changes to process, the query's results may be incorrect. The results may not contain the correct records, and the records may be out of order.
 @property (nullable, copy, nonatomic) void (^recordFetchedBlock)(CKRecord *record) API_DEPRECATED("Use recordMatchedBlock instead, which surfaces per-record errors", macos(10.10, 12.0), ios(8.0, 15.0), tvos(9.0, 15.0), watchos(3.0, 8.0));
 
-/*! @abstract This block will be called once for every record that is returned as a result of the query.
- *
- *  @discussion The callbacks will happen in the order that the results were sorted in.  If a record fails in post-processing (say, a network failure materializing a @c CKAsset record field), the per-record error will be passed here.
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute when a record match is available.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - The ID of the record.
+/// - The record, or `nil` if CloudKit can't retrieve the record.
+/// - If CloudKit can't retrieve the record, an error that provides information about the failure; otherwise, `nil`.
+///
+/// After identifying and sorting the records, the query operation executes this closure once for each of the result's records. The closure executes serially with respect to all other closures of the operation, so you can expect only one closure at a time to execute for this operation.
+///
+/// Set the property's value before you execute the operation or submit it to a queue.
+///
+/// - Warning: Query indexes update asynchronously so they aren't always current. If you query for records that you recently changed and don't allow enough time for those changes to process, the query's results may be incorrect. The results may not contain the correct records, and the records may be out of order.
 @property (nullable, copy, nonatomic) void (^recordMatchedBlock)(CKRecordID *recordID, CKRecord * _Nullable record, NSError * _Nullable error) API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) NS_REFINED_FOR_SWIFT;
 
-
-/*! @abstract This block is called when the operation completes.
- *
- *  @discussion The @code -[NSOperation completionBlock] @endcode will also be called if both are set.
- *  If the error is @c CKErrorPartialFailure, the error's userInfo dictionary contains a dictionary of recordIDs to errors keyed off of @c CKPartialErrorsByItemIDKey.  These errors are repeats of those sent back in previous @c recordMatchedBlock invocations
- *  Each @c CKOperation instance has a private serial queue. This queue is used for all callback block invocations.
- *  This block may share mutable state with other blocks assigned to this operation, but any such mutable state
- *  should not be concurrently used outside of blocks assigned to this operation.
- */
+/// The closure to execute after CloudKit retrieves all of the records.
+///
+/// The closure returns no value and takes the following parameters:
+///
+/// - A cursor that indicates there are more results to fetch, or `nil` if there are no additional results. Use the cursor to create a new query operation when you're ready to retrieve the next batch of results.
+/// - An error that contains information about a problem, or `nil` if CloudKit retrieves the results successfully.
+///
+/// This closure executes only once, and represents your final opportunity to process the results. It executes after all of the individual record fetch closures. The closure executes serially with respect to the other closures of the operation.
+///
+/// If the number of records that the operation intends to return exceeds ``CKQueryOperation/resultsLimit``, the operation provides a cursor that you can use to retrieve the next batch of results. You must create a separate operation using the cursor to fetch the next batch of results.
+///
+/// Update the value of this property before you execute the operation or submit it to a queue.
 @property (nullable, copy, nonatomic) void (^queryCompletionBlock)(CKQueryCursor * _Nullable cursor, NSError * _Nullable operationError)
 CK_SWIFT_DEPRECATED("Use queryResultBlock instead", macos(10.10, 12.0), ios(8.0, 15.0), tvos(9.0, 15.0), watchos(3.0, 8.0));
 
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecord.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecord.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecord.h	2025-11-09 05:29:54
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecord.h	2026-02-13 10:44:52
@@ -17,33 +17,99 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// A data type that CloudKit requires for record types.
 typedef NSString *CKRecordType;
+
+/// A data type that CloudKit requires for record field names.
 typedef NSString *CKRecordFieldKey;
 
-/*! Use this constant for the recordType parameter when fetching User Records. */
+/// The system type that identifies a user record.
+///
+/// CloudKit automatically creates a user record for each unique user of the app. User records are empty initially. You can add data to the user record using the same rules that apply for all records. Specifically, you must specify a consistent type of data for a particular field name in all user records. However, you can't create new user records using this record type and you can't query for records of this type. To locate user records, you must know the ID of the user record or use the methods that CKContainer provides to discover user records.
 CK_EXTERN CKRecordType const CKRecordTypeUserRecord API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0));
 
-/*! For use in queries to match on record properties.  Matches `record.recordID`.  Value is a ``CKRecordID`` */
+/// A key constant that a record uses for its CKRecord.recordID.
 CK_EXTERN CKRecordFieldKey const CKRecordRecordIDKey API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0)) NS_REFINED_FOR_SWIFT;
 
-/*! For use in queries to match on record properties.  Matches `record.creatorUserRecordID`.  Value is a ``CKRecordID`` */
+/// A key constant that a record uses for its CKRecord.creatorUserRecordID.
 CK_EXTERN CKRecordFieldKey const CKRecordCreatorUserRecordIDKey API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0)) NS_REFINED_FOR_SWIFT;
-/*! For use in queries to match on record properties.  Matches `record.creationDate`.  Value is a `NSDate` */
+
+/// A key constant that a record uses for its CKRecord.creationDate.
 CK_EXTERN CKRecordFieldKey const CKRecordCreationDateKey API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0)) NS_REFINED_FOR_SWIFT;
 
-/*! For use in queries to match on record properties.  Matches `record.lastModifiedUserRecordID`.  Value is a ``CKRecordID`` */
+/// A key constant that a record uses for its CKRecord.lastModifiedUserRecordID.
 CK_EXTERN CKRecordFieldKey const CKRecordLastModifiedUserRecordIDKey API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0)) NS_REFINED_FOR_SWIFT;
-/*! For use in queries to match on record properties.  Matches `record.modificationDate`.  Value is a `NSDate` */
+
+/// A key constant that a record uses for its CKRecord.modificationDate.
 CK_EXTERN CKRecordFieldKey const CKRecordModificationDateKey API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0)) NS_REFINED_FOR_SWIFT;
 
-/*! For use in queries to match on record properties.  Matches `record.parent` */
+/// The key constant that a record uses for its CKRecord.parent.
 CK_EXTERN CKRecordFieldKey const CKRecordParentKey API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
-/*! For use in queries to match on record properties.  Matches `record.share` */
+
+/// The key constant that a record uses for its CKRecord.share.
 CK_EXTERN CKRecordFieldKey const CKRecordShareKey API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
+/// The protocol that provides strong type-checking for objects that the CloudKit framework stores on the server.
+///
+/// CloudKit supports the following classes that adopt this protocol:
+///
+/// - <doc://com.apple.documentation/documentation/foundation/nsstring>
+/// - <doc://com.apple.documentation/documentation/foundation/nsnumber>
+/// - <doc://com.apple.documentation/documentation/foundation/nsarray>
+/// - <doc://com.apple.documentation/documentation/foundation/nsdate>
+/// - <doc://com.apple.documentation/documentation/foundation/nsdata>
+/// - ``CKRecord/Reference``
+/// - ``CKAsset``
+/// - <doc://com.apple.documentation/documentation/corelocation/cllocation>
+///
+/// Don't adopt this protocol in your custom classes. CloudKit doesn't support writing custom data types to the server. Attempting to do so results in an error.
 @protocol CKRecordValue <NSObject>
 @end
 
+/// A collection of key-value pairs that store your app's data.
+///
+/// Records are the fundamental objects that manage data in CloudKit. You can define any number of record types for your app, with each record type corresponding to a different type of information. Within a record type, you then define one or more fields, each with a name and a value. Records can contain simple data types, such as strings and numbers, or more complex types, such as geographic locations or pointers to other records.
+///
+/// An important step in using CloudKit is defining the record types your app supports. A new record object doesn't contain any keys or values. During development, you can add new keys and values at any time. The first time you set a value for a key and save the record, the server associates that type with the key for all records of the same type. The `CKRecord` class doesn't impose these type constraints or do any local validation of a record's contents. CloudKit enforces these constraints when you save the records.
+///
+/// - Note: The ability to add new keys is only possible during development. When you deploy to a production environment, the server returns an error if you try to specify an unknown record type or try to save a record that contains unknown keys.
+///
+/// Although records behave like dictionaries, there are limitations to the types of values you can assign to keys. The following are the object types that the `CKRecord` class supports. Attempting to specify objects of any other type results in failure. Fields of all types are searchable unless otherwise noted.
+///
+/// ### Supported Data Types
+///
+/// `CKRecord` fields support the following data types:
+///
+/// - term <doc://com.apple.documentation/documentation/foundation/nsstring>: Stores relatively small amounts of text. Although strings themselves can be any length, use a ``CKAsset`` to store large amounts of text.
+/// - term <doc://com.apple.documentation/documentation/foundation/nsnumber>: Stores any numerical information, including integers and floating-point numbers.
+/// - term <doc://com.apple.documentation/documentation/foundation/nsdata>: Stores arbitrary bytes of data. A typical use for data objects is to map the bytes that they contain to a `struct`. Don't use data objects for storing large binary data files; use a ``CKAsset`` instead. Data fields aren't searchable.
+/// - term <doc://com.apple.documentation/documentation/foundation/nsdate>: Stores day and time information in an accessible form.
+/// - term <doc://com.apple.documentation/documentation/foundation/nsarray>: Stores one or more objects of any other type in this table. You can store arrays of strings, arrays of numbers, arrays of references, and so on.
+/// - term <doc://com.apple.documentation/documentation/corelocation/cllocation>: Stores geographic coordinate data. You use locations in conjunction with the Core Location framework and any other services that handle location information.
+/// - term ``CKAsset``: Associates a disk-based file with the record. Although assets have a close association with records, you manage them separately. For more information about using assets, see ``CKAsset``.
+/// - term ``Reference``: Creates a link to a related record. A reference stores the ID of the target record. The advantage of using a reference instead of storing the ID as a string is that references can initiate cascade deletions of dependent records. The disadvantage is that references can only link between records in the same record zone. For more information, see ``Reference``.
+///
+/// - Important: To ensure the speed of fetching and saving records, the data that a record stores must not exceed 1 MB. Assets don't count toward this limit, but all other data types do.
+///
+/// ### Defining Records
+///
+/// The process for defining your record types depends entirely on your app and the data you're trying to represent. It's best to design records that encapsulate data for one unit of information. For example, you might use one record type to store an employee's name, job title, and date of hire, and use a separate record type to store the employee's address information. Using different record types lets you manage, manipulate, and validate the two types of information separately.
+///
+/// Use fields that contain ``Reference`` objects to establish relationships between different types of records. After you define your record types, use the iCloud Dashboard to set them up. During development, you can also create new record types programmatically.
+///
+/// ### Indexing the Fields of a Record
+///
+/// Indexes make it possible to search the contents of your records efficiently. During development, the server indexes all fields with data types it can use in the predicate of a query. This automatic indexing makes it easier to experiment with queries during development, but the indexes require space in a database, and require time to generate and maintain.
+///
+/// To manage the indexing behavior of your records in the production environment, use CloudKit Dashboard. When migrating your schema from the development environment to the production environment, enable indexing only for the fields that your app uses in queries, and disable it for all other fields.
+///
+/// ### Customizing Records
+///
+/// Use this class as-is to manage data coming from or going to the server, and don't subclass it.
+///
+/// ### Storing Records Locally
+///
+/// If you store records in a local database, use the ``encodeSystemFields(with:)`` method to encode and store the record's metadata. The metadata contains the record ID and the change tag, which you need later to sync records in a local database with those in CloudKit.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 // This class should not be subclassed. If it is, Sendable may no longer apply.
 // NS_SWIFT_SENDABLE on macos(14.0), ios(17.0), tvos(17.0), watchos(10.0)
@@ -52,119 +118,226 @@
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
-/*! This creates the record in the default zone. */
+/// Creates a new record of the specified type.
+///
+/// - Parameters:
+///   - recordType: A string that represents the type of record that you want to create. You can't change the record type after initialization. You define the record types that your app supports and use them to distinguish between records with different types of data. This parameter must not be `nil` or contain an empty string.
+///
+///     A record type must consist of one or more alphanumeric characters and must start with a letter. CloudKit permits the use of underscores, but not spaces.
+///
+/// - Returns: An initialized record object.
+///
+/// Use this method to initialize a new record object in the default zone of the database. The newly created record contains no data in any of its fields and receives a unique ID.
+///
+/// ```objc
+/// // Create a new record of type "employee".
+/// CKRecord* myRecord = [[CKRecord alloc] initWithRecordType:@"employee"];
+/// ```
+///
+/// New records exist only in memory until you explicitly save them to iCloud. In addition, new records are sparse by default and have no values for the fields you define. Until you set the value of a key explicitly, getting the value of a key in a new record returns `nil`. Even though a record has an associated type, CloudKit ignores the type information until you save the record.
+///
+/// Save the record using a ``CKModifyRecordsOperation`` object or by using the ``CKDatabase/save(_:completionHandler:)-3tatz`` method of ``CKDatabase`` to transfer the record's contents to the server.
 - (instancetype)initWithRecordType:(CKRecordType)recordType;
 
+/// Creates a record using an ID that you provide.
+///
+/// - Parameters:
+///   - recordType: A string that represents the type of record that you want to create. You can't change the record type after initialization. You define the record types that your app supports and use them to distinguish between records with different types of data. This parameter must not be `nil` or contain an empty string.
+///
+///     A record type must consist of one or more alphanumeric characters and must start with a letter. CloudKit permits the use of underscores, but not spaces.
+///   - recordID: The ID to assign to the record. When creating the ID, you can specify the zone where you want to store the record. You should provide a value that is unique across all records and you may not provide `nil`.
+///
+/// - Returns: An initialized record object.
+///
+/// Use this method to initialize a new record object with the specified ID. The newly created record contains no data.
+///
+/// Upon creation, record objects exist only in memory on the local device. Save the record using a ``CKModifyRecordsOperation`` object or by using the ``CKDatabase/save(_:completionHandler:)-3tatz`` method of ``CKDatabase`` to transfer the record's contents to the server.
 - (instancetype)initWithRecordType:(CKRecordType)recordType recordID:(CKRecordID *)recordID;
+
+/// Creates a record in the specified zone.
+///
+/// - Parameters:
+///   - recordType: A string that represents the type of record that you want to create. You can't change the record type after initialization. You define the record types that your app supports and use them to distinguish between records with different types of data. This parameter must not be `nil` or contain an empty string.
+///
+///     A record type must consist of one or more alphanumeric characters and must start with a letter. CloudKit permits the use of underscores, but not spaces.
+///   - zoneID: The ID of the record zone where you want to store the record.
+///
+/// - Returns: An initialized record object.
+///
+/// Use this method to initialize a new record object in the specified record zone.
+///
+/// Upon creation, the new record contains no data and exists only in memory on the local device. Save the record using a ``CKModifyRecordsOperation`` object or by using the ``CKDatabase/save(_:completionHandler:)-3tatz`` method of ``CKDatabase`` to transfer the record's contents to the server.
 - (instancetype)initWithRecordType:(CKRecordType)recordType zoneID:(CKRecordZoneID *)zoneID;
 
+/// The value that your app defines to identify the type of record.
+///
+/// Use this value to differentiate between different record types in your app. The value is primarily for your benefit, so choose record types that represent the data in the corresponding records.
+///
+/// CloudKit provides two system-defined record types:
+///
+/// | Record Type | Description |
+/// |---|---|
+/// | ``CKRecordTypeUserRecord-49k30`` | Identifies records that represent users. |
+/// | ``CKRecordTypeShare-8b6yt`` | Identifies records that the user shares. |
 @property (readonly, copy) CKRecordType recordType;
+
+/// The unique ID of the record.
+///
+/// The system sets the ID of a new record at initialization time. If you use the ``CKRecord/init(recordType:recordID:)`` method to initialize the record, the ID derives from the ``CKRecord/ID`` object you provide. In all other cases, the record generates a UUID and bases its ID on that value. The ID of a record never changes during its lifetime.
+///
+/// When you save a new record object to the server, the server validates the uniqueness of the record, but returns an error only if the save policy calls for it. Specifically, it returns an error when the save policy is ``CKModifyRecordsOperation/RecordSavePolicy/ifServerRecordUnchanged``, which is the default. For all other save policies, the server overwrites the contents of the existing record.
 @property (readonly, copy) CKRecordID *recordID;
 
-/*! Change tags are updated by the server to a unique value every time a record is modified.  A different change tag necessarily means that the contents of the record are different. */
+/// The server change token for the record.
+///
+/// When you fetch a record from the server, you get the current version of that record as it exists on the server. However, at any time after you fetch a record, other users might save a newer version of it to the server. Every time CloudKit saves a record, the server updates the record's change token to a new value. When you save your copy of the record, the server compares your record's token with the token on the server. If the two tokens match, the server interprets that you modified the latest version of the record and that it can apply your changes immediately. If the two tokens don't match, the server checks your app's save policy to determine how to proceed.
+///
+/// In your own code, you can use change tokens to distinguish between two different versions of the same record.
+///
+/// - Note: In some situations, setting a record as the parent of another record can cause the `recordChangeTag` to update on the parent record. This usually occurs when you save the child record.
 @property (nullable, readonly, copy) NSString *recordChangeTag;
 
-/*! This is a User Record recordID, identifying the user that created this record. */
+/// The ID of the user who creates the record.
+///
+/// Use this property's value to retrieve the user record for the user who creates this record. Every user of the app has a unique user record that is empty by default. Apps can add data to the user record on behalf of the user, but don't store sensitive data in it.
 @property (nullable, readonly, copy) CKRecordID *creatorUserRecordID;
+
+/// The time when CloudKit first saves the record to the server.
+///
+/// The creation date reflects the time when CloudKit creates a record on the server with the current record's ID. For new instances of this class, the value of this property is initially `nil`. When you save the record to the server, the value updates with the creation date for the record.
 @property (nullable, readonly, copy) NSDate *creationDate;
 
-/*! This is a User Record recordID, identifying the user that last modified this record. */
+/// The ID of the user who most recently modified the record.
+///
+/// Use this property's value to retrieve the user record of the user who most recently modified this record. Every user of the app has a unique user record that is empty by default. Apps can add data to the user record on behalf of the user, but don't store sensitive data in it.
 @property (nullable, readonly, copy) CKRecordID *lastModifiedUserRecordID;
+
+/// The most recent time that CloudKit saved the record to the server.
+///
+/// The modification date reflects the most recent time that CloudKit saved a record with the current record's ID to the server. For new instances of this class, the value of this property is initially `nil`. When you save the record to the server, the value updates with the modification date for the record.
 @property (nullable, readonly, copy) NSDate *modificationDate;
 
-/*! @discussion In addition to @c objectForKey: and @c setObject:forKey:, dictionary-style subscripting (@c record[key] and @code record[key] = value @endcode) can be used to get and set values.
- *  Acceptable value object classes are:
- *  - CKReference
- *  - CKAsset
- *  - CLLocation
- *  - NSData
- *  - NSDate
- *  - NSNumber
- *  - NSString
- *  - NSArray containing objects of any of the types above
- *
- *  Any other classes will result in an exception with name @c NSInvalidArgumentException.
- *
- *  Whenever possible, value objects will be copied when set on a record.
- *
- *  Field keys starting with '_' are reserved. Attempting to set a key prefixed with a '_' will result in an error.
- *
- *  Key names roughly match C variable name restrictions. They must begin with an ASCII letter and can contain ASCII letters and numbers and the underscore character.
- *  The maximum key length is 255 characters.
- */
+/// Returns the object that the record stores for the specified key.
+///
+/// - Parameters:
+///   - key: The string that identifies a field in the record. A key must consist of one or more alphanumeric characters and must start with a letter. CloudKit permits the use of underscores, but not spaces.
+///
+/// - Returns: The object for the specified key, or `nil` if no such key exists in the record.
+///
+/// New records don't contain any keys or values. Values are always one of the data types in <doc:CKRecord#Supported-Data-Types>.
+///
+/// You access the fields of a `CKRecord` object the same way you access key-value pairs in a dictionary. The `CKRecord` class defines the ``CKRecord/objectForKey:`` and ``CKRecord/setObject:forKey:`` methods for getting and setting values. It also supports dictionary index notation. The following example shows how to use both techniques to set a `firstName` field and retrieve a `lastName` field from a record:
+///
+/// ```objc
+/// // Equivalent ways to get a value.
+/// id value = [myRecord objectForKey:@"hiredAt"];
+/// value = myRecord[@"hiredAt"];
+/// ```
 - (nullable __kindof id<CKRecordValue>)objectForKey:(CKRecordFieldKey)key;
+
+/// Stores an object in the record using the specified key.
+///
+/// - Parameters:
+///   - object: The object to store using the specified key. The value you provide must be an instance of one the data types in <doc:CKRecord#Supported-Data-Types>. You receive an error if you use a data type that CloudKit doesn't support. If you specify `nil`, CloudKit removes any object that the record associates with the key.
+///   - key: The key to associate with `object`. Use this key to retrieve the value later. A key must consist of one or more alphanumeric characters and must start with a letter. CloudKit permits the use of underscores, but not spaces. Avoid using a key that matches the name of any property of `CKRecord`.
+///
+/// If the specified key already exists in the record, CloudKit deletes its previous value and replaces it with the one in the `object` parameter. This change affects only the local copy of the record. You must save the record to the server again before the change becomes available to other clients.
+///
+/// If the type of the `object` parameter differs from the type of the object that's on the server, you encounter an error when you attempt to save this record to the server. For example, if the current value is an <doc://com.apple.documentation/documentation/foundation/nsstring> object, you receive an error if you change the value to an <doc://com.apple.documentation/documentation/foundation/nsnumber> object and save the record.
+///
+/// You access the fields of a `CKRecord` object the same way you access key-value pairs in a dictionary. The `CKRecord` class defines the ``CKRecord/objectForKey:`` and ``CKRecord/setObject:forKey:`` methods for getting and setting values. It also supports dictionary index notation. The following example shows how to use both techniques to set a `firstName` field and get a `lastName` field from a record:
+///
+/// ```objc
+/// // Equivalent ways to set a value.
+/// [myRecord setObject:[NSDate date] forKey:@"hiredAt"];
+/// myRecord[@"hiredAt"] = [NSDate date];
+/// ```
 - (void)setObject:(nullable __kindof id<CKRecordValue>)object forKey:(CKRecordFieldKey)key;
+
+/// Returns an array of the record's keys.
+///
+/// - Returns: An array of keys, or an empty array if the record doesn't contain any keys.
+///
+/// The array contains only those keys with values that aren't `nil`.
 - (NSArray<CKRecordFieldKey> *)allKeys;
 
-/*! @abstract A special property that returns an array of token generated from all the string field values in the record.
- *
- *  @discussion These tokens have been normalized for the current locale, so they are suitable for performing full-text searches.
- */
+/// Returns an array of strings to use for full-text searches of the field's string-based values.
+///
+/// - Returns: An array of strings that contains data from the record's string-based fields.
+///
+/// When performing your own full-text searches, you can use this method to get a list of strings for your search. The method acts only on keys with string values. It breaks each value string apart at whitespace boundaries, creates new strings for each word, adds the new strings to an array, and returns the array. This tokenized version of the record's string values makes it easier to do string-based comparisons of individual words.
 - (NSArray<NSString *> *)allTokens;
 
+/// Returns the object that the record stores for the specified key.
+///
+/// - Parameters:
+///   - key: The string that identifies a field in the record. A key must consist of one or more alphanumeric characters and must start with a letter. CloudKit permits the use of underscores, but not spaces.
+///
+/// - Returns: The object for the specified key, or `nil` if no such key exists in the record.
+///
+/// ## Discussion
+///
+/// - Important: Don't call this method directly. The presence of this method is necessary to support subscripting syntax for record objects.
 - (nullable __kindof id<CKRecordValue>)objectForKeyedSubscript:(CKRecordFieldKey)key;
+
+/// Stores an object in the record using the specified key.
+///
+/// - Parameters:
+///   - object: The object to store using the specified key. It must be one of the data types in <doc:CKRecord#Supported-Data-Types>. You receive an error if you use a data type that CloudKit doesn't support. If you specify `nil`, CloudKit removes any object that the record associates with the key.
+///   - key: The key to associate with `object`. Use this key to retrieve the value later. A key must consist of one or more alphanumeric characters and must start with a letter. CloudKit permits the use of underscores, but not spaces. Avoid using a key that matches the name of any property of `CKRecord`.
+///
+/// ## Discussion
+///
+/// - Important: Don't call this method directly. The presence of this method is necessary to support subscripting syntax for record objects.
 - (void)setObject:(nullable __kindof id<CKRecordValue>)object forKeyedSubscript:(CKRecordFieldKey)key;
 
-/*! A list of keys that have been modified on the local CKRecord instance */
+/// Returns an array of keys with recent changes to their values.
+///
+/// - Returns: An array of keys with changed values since downloading or saving the record. If there aren't any changed keys, this method returns an empty array.
 - (NSArray<CKRecordFieldKey> *)changedKeys;
 
-/*! @discussion @c CKRecord supports @c NSSecureCoding.  When you invoke @c encodeWithCoder: on a @c CKRecord, it encodes all its values.  Including the record values you've set.
- *  If you want to store a @c CKRecord instance locally, AND you're already storing the record values locally, that's overkill.  In that case, you can use @c encodeSystemFieldsWithCoder:.  This will encode all parts of a @c CKRecord except the record keys / values you have access to via the @c changedKeys and @c objectForKey: methods.
- *  If you use @c initWithCoder: to reconstitute a @c CKRecord you encoded via @c encodeSystemFieldsWithCoder:, then be aware that
- *  - any record values you had set on the original instance, but had not saved, will be lost
- *  - the reconstituted CKRecord's @c changedKeys will be empty
- */
+/// Encodes the record's system fields using the specified archiver.
+///
+/// - Parameters:
+///   - coder: An archiver object.
+///
+/// Use this method to encode the record's metadata that CloudKit provides. Every record has keys that the system defines that correspond to record metadata, such as the record ID, record type, creation date, and so on. This method encodes those keys in the specified archiver. This method doesn't include any keys you add to the record. It also doesn't encode the keys that the ``CKRecord/changedKeys`` method returns.
+///
+/// You might use this method when you want to store only the system metadata because you store the actual record data elsewhere.
 - (void)encodeSystemFieldsWithCoder:(NSCoder *)coder;
 
-/*! @discussion The share property on a record can be set by creating a share using @code -[CKShare initWithRootRecord:] @endcode.
- *
- *  The share property on a record will be removed when the corresponding CKShare is deleted from the server. Send this record in the same batch as the share delete and this record's share property will be updated.
- *
- *  Sharing is only supported in zones with the @c CKRecordZoneCapabilitySharing capability. The default zone does not support sharing.
- *
- *  If any records have a parent reference to this record, they are implicitly shared alongside this record.
- *
- *  Note that records in a parent chain must only exist within one share. If a child record already has a share reference set then you will get a @c CKErrorAlreadyShared error if you try to share any of that record's parents.
- *
- *  Child records can be shared independently, even if they have a common parent.  For example:
- *  Record A has two child records, Record B and Record C.
- *      A
- *     / \
- *    B   C
- *
- *  These configurations are supported:
- *  - Record A part of Share 1, or
- *  - Record B part of Share 1, or
- *  - Record C part of Share 1, or
- *  - Record B part of Share 1, Record C part of Share 2
- *
- *  These configurations are not supported:
- *  Record A part of Share 1, Record B part of Share 2, or
- *    -- This is not allowed because Record B would then be in two shares; Share 1 by being Record A's child, and Share 2
- *  Record A part of Share 1, Record C part of Share 2, or
- *    -- This is not allowed because Record C would then be in two shares; Share 1 by being Record A's child, and Share 2
- *  Record A part of Share 1, Record B part of Share 2, Record C part of Share 3
- *    -- This is not allowed because both Record B and Record C would then each be in two shares.
- *
- *  Whenever possible, it is suggested that you construct your parent hierarchies such that you will only need to share the topmost record of that hierarchy.
- */
+/// A reference to the share object that determines the share status of the record.
+///
+/// CloudKit clears this property's value when it deletes the corresponding ``CKShare`` object on the server. Send this record in the same batch operation as the share object you're deleting, and this property updates accordingly.
+///
+/// CloudKit only supports sharing in zones with the `CKRecordZoneCapabilitySharing` capability. The default zone doesn't support sharing.
+///
+/// If any records have a parent reference to this record, CloudKit implicitly shares them along with this record.
+///
+/// - Note: Records in a hierarchy must only exist within one share. If a child record in a hierarchy already has a share reference, you get a `CKErrorAlreadyShared` error if you try to share any of that record's parents.
 @property (nullable, readonly, copy) CKReference *share API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
-/*! @abstract Use a parent reference to teach CloudKit about the hierarchy of your records.
- *
- *  @discussion When a record is shared, all children of that record are also shared.
- *
- *  A parent record reference must have @c CKReferenceActionNone set. You can create a separate reference with @c CKReferenceActionDeleteSelf if you would like your hierarchy cleaned up when the parent record is deleted.
- *
- *  The target of a parent reference must exist at save time - either already on the server, or part of the same @c CKModifyRecordsOperation batch.
- *
- *  You are encouraged to set up the @c parent relationships as part of normal record saves, even if you're not planning on sharing records at this time.
- *  This allows you to share and unshare a hierarchy of records at a later date by only modifying the "top level" record, setting or clearing its @c share reference.
- */
+/// A reference to the record's parent record.
+///
+/// Use parent references to inform CloudKit about the hierarchy of your records. CloudKit shares the hierarchy when a ``CKShare`` includes a referenced record. Add relationships between records as you create them, even if you don't plan to share them. This allows you to manage the sharing of a hierarchy by only modifying the root record's ``CKRecord/share`` reference.
+///
+/// To indicate that a record belongs to its parent, set this property to a reference that points to the parent record. The reference must use the ``CKRecord/ReferenceAction/none`` action or CloudKit throws an exception. The parent record must exist on the server when you save the child, or you must include the record in the same save operation. Otherwise, the operation fails.
 @property (nullable, copy) CKReference *parent API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
-/*! Convenience wrappers around creating a @c CKReference to a parent record. The resulting @c CKReference will have @code referenceAction = CKReferenceActionNone @endcode */
+/// Creates and sets a reference object for a parent from its record.
+///
+/// - Parameters:
+///   - parentRecord: A record that you want to set as the parent to this record.
+///
+/// This method creates and sets a ``CKRecord/Reference`` object that points to the record you provide. The resulting `CKReference` has an action of ``CKRecord/ReferenceAction/none``.
 - (void)setParentReferenceFromRecord:(nullable CKRecord *)parentRecord API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
+
+/// Creates and sets a reference object for a parent from the parent's record ID.
+///
+/// - Parameters:
+///   - parentRecordID: The ``CKRecord/ID`` object for the record that you want to set as this record's parent.
+///
+/// This method creates and sets a ``CKRecord/Reference`` object that points to the record you provide. The resulting `CKReference` has an action of ``CKRecord/ReferenceAction/none``.
 - (void)setParentReferenceFromRecordID:(nullable CKRecordID *)parentRecordID API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
 @end
@@ -193,24 +366,74 @@
 @interface CLLocation (CKRecordValue) <CKRecordValue>
 @end
 
-/*! Formalizes a protocol for getting and setting keys on a CKRecord.  Not intended to be used directly by client code */
+/// A protocol for managing the key-value pairs of a CloudKit record.
 API_AVAILABLE(macos(10.11), ios(9.0), watchos(3.0))
 @protocol CKRecordKeyValueSetting <NSObject>
+
+/// Returns the object that the record stores for the specified key.
+///
+/// - Parameters:
+///   - key: The string that identifies a field in the record. A key must consist of one or more alphanumeric characters and must start with a letter. CloudKit permits the use of underscores, but not spaces.
+///
+/// - Returns: The object for the specified key, or `nil` if no such key exists in the record.
 - (nullable __kindof id<CKRecordValue>)objectForKey:(CKRecordFieldKey)key;
+
+/// Stores an object in the record using the specified key.
+///
+/// - Parameters:
+///   - object: The object to store using the specified key. It must be one of the data types in <doc:CKRecord#Supported-Data-Types>. You receive an error if you use a data type that CloudKit doesn't support. If you specify `nil`, CloudKit removes any object that the record associates with the key.
+///   - key: The key to associate with `object`. Use this key to retrieve the value later. A key must consist of one or more alphanumeric characters and must start with a letter. CloudKit permits the use of underscores, but not spaces. Avoid using a key that matches the name of any property of `CKRecord`.
 - (void)setObject:(nullable __kindof id<CKRecordValue>)object forKey:(CKRecordFieldKey)key;
+
+/// Returns the object that the record stores for the specified key.
+///
+/// - Parameters:
+///   - key: The string that identifies a field in the record. A key must consist of one or more alphanumeric characters and must start with a letter. CloudKit permits the use of underscores, but not spaces.
+///
+/// - Returns: The object for the specified key, or `nil` if no such key exists in the record.
 - (nullable __kindof id<CKRecordValue>)objectForKeyedSubscript:(CKRecordFieldKey)key;
+
+/// Stores an object in the record using the specified key.
+///
+/// - Parameters:
+///   - object: The object to store using the specified key. It must be one of the data types in <doc:CKRecord#Supported-Data-Types>. You receive an error if you use a data type that CloudKit doesn't support. If you specify `nil`, CloudKit removes any object that the record associates with the key.
+///   - key: The key to associate with `object`. Use this key to retrieve the value later. A key must consist of one or more alphanumeric characters and must start with a letter. CloudKit permits the use of underscores, but not spaces. Avoid using a key that matches the name of any property of `CKRecord`.
 - (void)setObject:(nullable __kindof id<CKRecordValue>)object forKeyedSubscript:(CKRecordFieldKey)key;
+
+/// Returns an array of the record's keys.
+///
+/// - Returns: An array of keys, or an empty array if the record doesn't contain any keys.
 - (NSArray<CKRecordFieldKey> *)allKeys;
+
+/// Returns an array of keys with recent changes to their values.
+///
+/// - Returns: An array of keys with changed values since downloading or saving the record. If there aren't any changed keys, this method returns an empty array.
 - (NSArray<CKRecordFieldKey> *)changedKeys;
 @end
 
 API_AVAILABLE(macos(10.11), ios(9.0), watchos(3.0))
 @interface CKRecord (CKRecordKeyValueSettingConformance) <CKRecordKeyValueSetting>
 
-/*! Any values set here will be locally encrypted before being saved to the server and locally decrypted when fetched from the server. Encryption and decryption is handled by the CloudKit framework.
- * Key material necessary for decryption are available to the owner of the record, as well as any users that can access this record via a CKShare.
- * All CKRecordValue types can be set here except CKAsset and CKReference.
- */
+/// An object that manages the record's encrypted key-value pairs.
+///
+/// Use the object this property returns to read and write encrypted key-value pairs that you store on the record. You can encrypt values of any data type that CloudKit supports, except ``CKAsset``, which is encrypted by default, and ``CKRecord/Reference``, which isn't encrypted so it remains available for server-side use. Only encrypt new fields. CloudKit doesn't allow encryption on fields that already exist in your app's schema, or on records that you store in the public database.
+///
+/// - Note: CloudKit doesn't support indexes on encrypted fields. Don't include encrypted fields in your predicate or sort descriptors when fetching records with ``CKQuery`` and ``CKQueryOperation``.
+///
+/// CloudKit encrypts the fields' values on-device before saving them to iCloud, and decrypts the values only after fetching them from the server. When you enable Advanced Data Protection, the encryption keys are available exclusively to the record's owner and, if the user shares the record, that share's participants.
+///
+/// The following example shows how to use `encryptedValues` to encrypt and decrypt a string value:
+///
+/// ```swift
+/// let record = CKRecord(recordType: "Property")
+///
+/// // Encrypt the name of the property's owner.
+/// record.encryptedValues["ownerName"] = "Maria Ruiz"
+///
+/// // Decrypt the name of the property's owner, using the
+/// // appropriate data type, and assign it to a local variable.
+/// var clientName = record.encryptedValues["ownerName"] as? NSString
+/// ```
 @property (readonly, copy) NS_SWIFT_SENDABLE id<CKRecordKeyValueSetting> encryptedValues API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0));
                                                                                                      
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordID.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordID.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordID.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordID.h	2026-02-13 13:56:55
@@ -13,6 +13,29 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An object that uniquely identifies a record in a database.
+///
+/// A record ID object consists of a name string and a zone ID. The name string is an ASCII string that doesn't exceed 255 characters in length. When you create a record without specifying a record ID, the ID name string derives from a UUID and is, therefore, unique. When creating your own record ID objects, you can use names that have more meaning to your app or to the user, as long as each name is unique within the specified zone. For example, you might use a document name for the name string.
+///
+/// CloudKit uniques records by recordID within a specified database, but you can reuse record IDs in different databases. Each container has a public and a private database, and the private database is different for each unique user. This configuration provides for the reusing of record IDs in each user's private database, but ensures that only one record uses a specific record ID in the public database.
+///
+/// CloudKit generally creates record IDs when it first saves a new record, but you might manually instantiate instances of `CKRecordID` in  specific situations. For example, you must create an instance when saving a record in a zone other than the default zone. You also instantiate instances of `CKRecordID` when retrieving specific records from a database.
+///
+/// Don't subclass `CKRecordID`.
+///
+/// ### Interacting with Record IDs
+///
+/// After you create a `CKRecordID` object, interactions with that object typically involve creating a new record or retrieving an existing record from a database.
+///
+/// You might also use record IDs when you can't use a ``CKRecord/Reference`` object to refer to a record. References are only valid within a single zone of a database. To refer to objects outside of the current zone or database, save the strings in the record's `CKRecordID` and ``CKRecordZone/ID`` objects. When you want to retrieve the record later, use those strings to recreate the record and zone ID objects so that you can fetch the record.
+///
+/// #### Creating Record IDs for New Records
+///
+/// To assign a custom record ID to a new record, you must create the `CKRecordID` object first. You need to know the intended name and zone information for that record, which might also require creating a ``CKRecordZone/ID`` object. After creating the record ID object, initialize your new record using its ``CKRecord/init(recordType:recordID:)`` method.
+///
+/// #### Using Record IDs to Fetch Records
+///
+/// Use a record ID to fetch the corresponding ``CKRecord`` object from a database quickly. You perform the fetch operation using a ``CKFetchRecordsOperation`` object or the ``CKDatabase/fetch(withRecordID:completionHandler:)`` method of the ``CKDatabase`` class. In both cases, CloudKit returns the record asynchronously using the handler you provide.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 NS_SWIFT_SENDABLE
@@ -21,14 +44,33 @@
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
-/*! Record names must be 255 characters or less. Most UTF-8 characters are valid. */
-
-/*! Creates a record ID in the default zone */
+/// Creates a new record ID with the specified name in the default zone.
+///
+/// - Parameters:
+///   - recordName: The name that identifies the record. The string must contain only ASCII characters, must not exceed 255 characters, and must not start with an underscore. If you specify an empty string for this parameter, the method throws an exception.
+///
+/// - Returns: An initialized record ID object.
+///
+/// Use this method when you're creating or searching for records in the default zone.
 - (instancetype)initWithRecordName:(NSString *)recordName;
 
+/// Creates a new record ID with the specified name and zone information.
+///
+/// - Parameters:
+///   - recordName: The name that identifies the record. The string must contain only ASCII characters, must not exceed 255 characters, and must not start with an underscore. If you specify an empty string for this parameter, the method throws an exception.
+///   - zoneID: The ID of the zone where you want to store the record. This parameter must not be `nil`.
+///
+/// - Returns: An initialized record ID object.
+///
+/// Use this method when you create or search for records in a zone other than the default zone. The value in the `zoneID` parameter must represent a zone that already exists in the database. If the record zone doesn't exist, save the corresponding ``CKRecordZone`` object to the database before attempting to save any ``CKRecord`` objects in that zone.
 - (instancetype)initWithRecordName:(NSString *)recordName zoneID:(CKRecordZoneID *)zoneID NS_DESIGNATED_INITIALIZER;
 
+/// The unique name of the record.
+///
+/// For share records that manage a shared record zone, this property's value is always ``CKRecordNameZoneWideShare``.
 @property (readonly, copy, nonatomic) NSString *recordName;
+
+/// The ID of the zone that contains the record.
 @property (readonly, copy, nonatomic) CKRecordZoneID *zoneID;
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordZone.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordZone.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordZone.h	2025-11-12 06:00:28
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordZone.h	2026-02-13 13:17:09
@@ -13,14 +13,26 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// The capabilities that a record zone supports.
 typedef NS_OPTIONS(NSUInteger, CKRecordZoneCapabilities) {
-    /// This zone supports `CKFetchRecordZoneChangesOperation`
+    /// A capability for fetching only the changed records from a zone.
+    ///
+    /// This capability makes the creation of offline caches more efficient. Instead of fetching the entire record every time, use ``CKFetchRecordZoneChangesOperation`` to fetch only the changed values, and use the data it returns to update your cache. This minimizes the amount of data you receive from the server.
     CKRecordZoneCapabilityFetchChanges   = 1 << 0,
-    /// Batched changes to this zone happen atomically
+
+    /// A capability that allows atomic changes of multiple records.
+    ///
+    /// When you use a ``CKModifyRecordsOperation`` object to save records, if the server is unable to save the changes for one record, it doesn't save the changes for any of the records. Combining this capability with the ``CKModifyRecordsOperation/RecordSavePolicy/ifServerRecordUnchanged`` policy of the operation object prevents your app from overwriting changes to a group of records if one or more of the records on the server has recent changes.
     CKRecordZoneCapabilityAtomic         = 1 << 1,
-    /// Records in this zone can be shared
+
+    /// A capability for sharing a specific hierarchy of records.
+    ///
+    /// CloudKit allows you to share record hierarchies from custom record zones that you create in the user's private database. For more information, see <doc:shared-records>.
     CKRecordZoneCapabilitySharing        API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0)) = 1 << 2,
-    /// This zone supports a single `CKShare` record that shares all records in the zone
+
+    /// A capability for sharing the entire contents of a record zone.
+    ///
+    /// CloudKit allows you to share custom record zones that you create in the user's private database. For more information, see <doc:shared-records>.
     CKRecordZoneCapabilityZoneWideSharing API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0)) = 1 << 3,
 } API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0));
 
@@ -37,45 +49,107 @@
     /// Note that:
     /// - Record zones using per-zone encryption only support zone-wide sharing.
     /// - Encryption scope can only be assigned at zone creation and cannot be changed for the lifetime of the zone.
-    /// - The server will not return zones using per-zone encryption to device OS versions older than the corresponding API availability version.
-    /// - An older OS trying to overwrite an existing zone using per-zone encryption due to a naming collision will result in a `.serverRejectedRequest` error.
-    /// - On device OS upgrade, your application is responsible for fetching database changes via `CKFetchDatabaseChangesOperation` with a nil sync token to ensure it has
+    /// - The server does not return zones using per-zone encryption to device OS versions older than the corresponding API availability version.
+    /// - An older OS trying to overwrite an existing zone using per-zone encryption due to a naming collision results in a `.serverRejectedRequest` error.
+    /// - On device OS upgrade, your application is responsible for fetching database changes via `CKFetchDatabaseChangesOperation` with a nil sync token to verify it has
     /// received all the zones available to it from the server.
     CKRecordZoneEncryptionScopePerZone,
 };
 
+/// The default record zone's name.
+///
+/// Use this value when you need to refer to the default zone by name, such as when creating a zone ID. The default zone has no special capabilities.
 CK_EXTERN NSString * const CKRecordZoneDefaultName API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0));
 
+/// A database partition that contains related records.
+///
+/// Zones are an important part of how you organize your data. The public and private databases each have a single default zone. In the private database, you can use ``CKRecordZone`` objects to create additional custom zones as necessary. Use custom zones to arrange and encapsulate groups of related records in the private database. Custom zones support other capabilities too, such as the ability to write multiple records as a single atomic transaction.
+///
+/// Treat each custom zone as a single unit of data that is separate from every other zone in the database. You can add records inside the zone. You can also create links between the records inside a zone by using the ``CKRecord/Reference`` class. However, the ``CKRecord/Reference`` class doesn't support cross-zone linking, so each reference object must point to a record in the same zone as the current record.
+///
+/// Use the ``CKRecordZone`` class as-is and don't subclass it.
+///
+/// ### Creating a Custom Record Zone
+///
+/// Generally, you use instances of this class to create and manage custom zones. Although you can use this class to retrieve a database's default zone, most operations act on records in the default zone by default, so you rarely need to specify it explicitly.
+///
+/// To create a custom zone, use ``CKRecordZone`` to create the zone object, and then save that zone to the user's private database using a ``CKModifyRecordZonesOperation`` object. You can't save any records in the zone until you save it to the database. When creating records, explicitly specify the zone ID if you want the records to reside in a specific zone; otherwise, they save to the default zone. You can't create custom zones in a public database.
+///
+/// After creating a `CKRecordZone` object and saving it to the database, you don't interact with the object much. Instead, most interactions occur with its corresponding ``ID`` object, which you use to refer to the zone when creating records.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
-CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
+CK_SUBCLASSING_DEPRECATED
 // NS_SWIFT_SENDABLE on macos(14.0), ios(17.0), tvos(17.0), watchos(10.0)
 @interface CKRecordZone : NSObject <NSSecureCoding, NSCopying>
 
+/// Returns the default record zone.
+///
+/// Always use this method to retrieve the default zone for a database. You can use the returned object to specify the default zone for either the public or private database of a container. You don't need to save the returned zone object before using it. The owner of the zone is ``CKOwnerDefaultName``, which corresponds to the current user.
+///
+/// The default zone of a database is a convenient place to store and access records. If you don't explicitly assign a zone to a record, CloudKit puts the record in the default zone.
+///
+/// The disadvantage of using the default zone for storing records is that it doesn't have any special capabilities. You can't save a group of records to iCloud atomically in the default zone. Similarly, you can't use a ``CKFetchRecordChangesOperation`` object on records in the default zone.
 + (CKRecordZone *)defaultRecordZone;
 
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
+
+/// Creates a record zone object with the specified zone name.
+///
+/// - Parameters:
+///   - zoneName: The name of the new zone. Zone names inside a user's private database are unique, consist of up to 255 ASCII characters, and don't start with an underscore. One way to satisfy the uniqueness of zone names is to create a string from a Universally Unique Identifier (UUID), but you can also use other techniques.
+///
+///     If this parameter is `nil` or is an empty string, the method throws an exception.
+///
+/// - Returns: The new custom zone.
+///
+/// Use this method to create a new record zone. The new zone has the name you provide and the zone's owner is the current user. After creating the zone, save it to the server using a ``CKModifyRecordZonesOperation`` object or the ``CKDatabase/save(_:completionHandler:)-32ffr`` method of ``CKDatabase``. You must save the zone to the server before you attempt to save any records to that zone.
+///
+/// Don't use this method to create a `CKRecordZone` object that corresponds to a zone that already exists in the database. If the zone exists, fetch it using a ``CKFetchRecordZonesOperation`` object or the ``CKDatabase/fetch(withRecordZoneID:completionHandler:)`` method of ``CKDatabase``.
 - (instancetype)initWithZoneName:(NSString *)zoneName;
+
+/// Creates a record zone object with the specified zone ID.
+///
+/// - Parameters:
+///   - zoneID: The ID for the new zone. This parameter must not be `nil`.
+///
+/// - Returns: The custom record zone.
+///
+/// Use this method when you want to create a new record zone from the information in a zone ID. After creating the zone, save it to the server using a ``CKModifyRecordZonesOperation`` object or the ``CKDatabase/save(_:completionHandler:)-32ffr`` method of ``CKDatabase``.
+///
+/// Don't use this method to create a ``CKRecordZone`` object that corresponds to a zone that already exists in the database. If the zone exists, fetch it using a ``CKFetchRecordZonesOperation`` object or the ``CKDatabase/fetch(withRecordZoneID:completionHandler:)`` method of ``CKDatabase``.
 - (instancetype)initWithZoneID:(CKRecordZoneID *)zoneID;
 
+/// The unique ID of the zone.
+///
+/// The zone ID contains the name of the zone and the name of the user who owns the zone. Use this property to access both of those values.
 @property (readonly, copy) CKRecordZoneID *zoneID;
 
-/// Capabilities on locally-created record zones are not valid until the record zone is saved. Capabilities on record zones fetched from the server are valid.
+/// The capabilities that the zone supports.
+///
+/// The server determines the capabilities of the zone and sets the value of this property when you save the record zone. Always check this property before performing tasks that require a specific capability.
+///
+/// Default zones don't support any special capabilities. Custom zones in a private database support the options that ``CKRecordZone/Capabilities`` provides.
 @property (readonly, assign) CKRecordZoneCapabilities capabilities;
 
-/// The share property on a record zone will only be set on zones fetched from the server and only if a
-/// corresponding zone-wide share record for the zone exists on the server.
+/// A reference to the record zone's share record.
 ///
-/// You can create a zone-wide share for a zone using `-[CKShare initWithRecordZoneID:]`.
+/// CloudKit sets this property only for fetched record zones that contain a share record; otherwise, it's `nil`.
 ///
-/// Zone-wide sharing is only supported in zones with the `CKRecordZoneCapabilityZoneWideSharing` sharing capability.
-/// You cannot share a zone if it already contains shared records.
+/// To share a record zone, create a share record using the ``CKShare/init(recordZoneID:)`` method and then save it to the server. Shared record zones must have the ``CKRecordZone/Capabilities/zoneWideSharing`` capability, which CloudKit enables by default for new custom record zones in the user's private database.
+///
+/// A record zone, and the records it contains, can take part in only a single share. CloudKit returns an error if you attempt to share an already-shared record zone, or if that record zone contains previously shared records.
+///
+/// Record zone sharing errors include the following:
+///
+/// - ``CKError/Code/serverRecordChanged``, which CloudKit returns if you try to share an already-shared record zone.
+/// - ``CKError/Code/serverRejectedRequest``, which CloudKit returns if you try to share a record hierarchy from an already-shared record zone.
+/// - ``CKError/Code/invalidArguments``, which CloudKit returns if you try to share a record zone that contains one or more shared hierarchies.
 @property (nullable, readonly, copy) CKReference *share API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0));
 
-/// The encryption scope determines the granularity at which encryption keys are stored within the zone.
+/// The encryption scope determines the granularity at which CloudKit stores encryption keys within the zone.
 ///
 /// Zone encryption scope defaults to `CKRecordZoneEncryptionScopePerRecord` and can only be modified before zone creation. Attempting to change the encryption
-/// scope of an existing zone is invalid and will result in an error.
+/// scope of an existing zone is invalid and results in an error.
 ///
 /// Zones using `CKRecordZoneEncryptionScopePerZone` can only use zone-wide sharing and are not compatible with older device OS versions. Refer to `CKRecordZoneEncryptionScope` for more info.
 @property (assign) CKRecordZoneEncryptionScope encryptionScope API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordZoneID.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordZoneID.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordZoneID.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKRecordZoneID.h	2026-02-13 10:44:53
@@ -11,18 +11,53 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An object that uniquely identifies a record zone in a database.
+///
+/// Zones are a mechanism for grouping related records together. You create zone ID objects when you want to fetch an existing zone object or create a new zone with a specific name.
+///
+/// A record zone ID distinguishes one zone from another by a name string and the ID of the user who creates the zone. You should specify ASCII strings that don't exceed 255 characters. When creating your own record zone ID objects, you can use names that have more meaning to your app or to the user, providing each zone name is unique within the specified database. You should set the owner name to the current user name or the name of another user. Get the current user name from ``CKCurrentUserDefaultName`` or by calling ``CKContainer/fetchUserRecordID(completionHandler:)``.
+///
+/// When creating new record zones, make the name string in the record zone ID unique in the target database. Public databases don't support custom zones, and only the user who owns the database can create zones in private databases.
+///
+/// Don't create subclasses of this class.
+///
+/// ### Interacting with Record Zone IDs
+///
+/// After you create a record zone ID, interactions with it typically include:
+///
+/// - Creating a ``CKRecord/ID`` object so that you can fetch or create records in that zone.
+/// - Retrieving an existing ``CKRecordZone`` object from the database.
+///
+/// You don't need to create a record zone ID to create a record zone. The ``CKRecordZone`` class has initialization methods that create a record zone ID using the name string you provide.
+///
+/// #### Creating Record Zone IDs for Records
+///
+/// To create a new record in a custom zone, create a record zone ID that specifies the zone name. Use the record zone ID to create a ``CKRecord/ID``, and then use the record ID to create the record.
+///
+/// #### Fetching a Record Zone Object from the Database
+///
+/// To fetch a record zone from the database, use a ``CKFetchRecordZonesOperation`` object or the ``CKDatabase/fetch(withRecordZoneID:completionHandler:)`` method of ``CKDatabase``. Both techniques accept a record zone ID that you provide and retrieve the corresponding record zone object asynchronously. If you use the operation object, you can retrieve multiple record zones at the same time.
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 // NS_SWIFT_SENDABLE on macos(13.3), macCatalyst(16.4), ios(16.4), tvos(16.4), watchos(9.4)
 @interface CKRecordZoneID : NSObject <NSSecureCoding, NSCopying>
 
-/*! Zone names must be 255 characters or less. Most UTF-8 characters are valid. */
-
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
+
+/// Creates a record zone ID with the specified name and owner.
+///
+/// - Parameters:
+///   - zoneName: The name that identifies the record zone. Zone names consist of up to 255 ASCII characters, and don't start with an underscore. To specify the default zone of the current database, use ``CKRecordZoneDefaultName-8mfij``. This parameter must not be `nil` or an empty string.
+///   - ownerName: The user who creates the record zone. To specify the current user, use ``CKCurrentUserDefaultName``. If you provide `nil` or an empty string for this parameter, the method throws an exception.
+///
+/// - Returns: A new record zone ID.
 - (instancetype)initWithZoneName:(NSString *)zoneName ownerName:(NSString *)ownerName NS_DESIGNATED_INITIALIZER;
 
+/// The unique name of the record zone.
 @property (readonly, copy, nonatomic) NSString *zoneName;
+
+/// The ID of the user who owns the record zone.
 @property (readonly, copy, nonatomic) NSString *ownerName;
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKReference.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKReference.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKReference.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKReference.h	2026-02-13 10:50:35
@@ -13,16 +13,102 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
-/*! @enum CKReferenceAction
- *  @constant CKReferenceActionNone When the referred record is deleted, this record is unchanged, and has a dangling pointer
- *  @constant CKReferenceActionDeleteSelf When the referred record is deleted then this record is also deleted
- */
+/// Constants that indicate the behavior when deleting a referenced record.
 typedef NS_ENUM(NSUInteger, CKReferenceAction) {
+    /// A reference action that has no cascading behavior.
+    ///
+    /// No action occurs when you delete a record that the current record references. Deleting a parent record doesn't delete that record's children. The `CKReference` object still contains the ID of the deleted record and doesn't update.
     CKReferenceActionNone       = 0,
+
+    /// A reference action that cascades deletions.
+    ///
+    /// CloudKit deletes any records that contain `CKReference` objects pointing to the current record. The deletion of the additional records can trigger further deletions as the action cascades. The deletions are asynchronous in the default zone and immediate in a custom zone.
     CKReferenceActionDeleteSelf = 1,
 } API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0));
 
 
+/// A relationship between two records in a record zone.
+///
+/// A `CKReference` object creates a many-to-one relationship between records in your database. Each reference object stores information about the one record that is the target of the reference. You then save the reference object in the fields of one or more records to create a link from those records to the target. You may only create references between records within the same zone of the same database.
+///
+/// References create a stronger relationship between records than just saving the ID of a record as a string. Specifically, you can use references to create an ownership model between two records. When the reference object's action is ``CKRecord/ReferenceAction/deleteSelf``, the target of the reference—that is, the record in the reference's ``recordID`` property—becomes the owner of the source record. Deleting the target (owner) record deletes all its source records. The deletion of any owned records can trigger further deletions if those records are the owners of other records. If a record contains two or more `CKReference` objects with an action of ``CKRecord/ReferenceAction/deleteSelf``, CloudKit deletes the record when it deletes any of the objects it references.
+///
+/// - Note: It is permissible to create circular owning references for a set of records.
+///
+/// To save multiple records that contain references between them, save the target records first or save all the records in one batch operation using ``CKModifyRecordsOperation``.
+///
+/// ### Interacting with Reference Objects
+///
+/// You use reference objects to create strong links between two records and to search for related fields. When you create new records, you create reference objects and assign them to fields of your records. The only other time you create reference objects is when you build a search predicate to search for related records.
+///
+/// #### Linking to Another Record
+///
+/// To link records together and create a strong relationship between them, create a new `CKReference` object, initialize it with the owner record, and assign that reference object to a field of the owned record. When you design the relationships among your own records, make the owner the more important of two related records. The owner record rarely depends on any records that point to it. The owner record is also the one that you typically fetch first from the database.
+///
+/// - Important: There is a hard limit to the number of references with a ``CKRecord/ReferenceAction/deleteSelf`` action that any one record can have. This limit is 750 references, and any attempt to exceed it results in an error from the server.
+///
+/// The figure below shows an example of a relationship between a to-do list record and a set of item records that represent individual items to complete. The to-do list is the primary record, or owner, in the relationship because it represents the entire to-do list, including all items on the list. As a result, each item record has a field that contains a `CKReference` object that points to the owning to-do list record.
+///
+/// ![A figure that shows the relationship between a parent record and its children.](media-1965777)
+///
+/// The following code sample shows how to create the reference object for each item record and configure it to point at the list record:
+///
+/// @TabNavigator {
+///     @Tab("Swift") {
+///         ```swift
+///         itemRecord["owningList"] = CKReference(record: listRecord, action: .deleteSelf)
+///         ```
+///     }
+///     @Tab("Objective-C") {
+///         ```objc
+///         CKReference* ref = [[CKReference alloc] initWithRecord:listRecord action:CKReferenceActionDeleteSelf];
+///         itemRecord[@"owningList"] = ref;
+///         ```
+///     }
+/// }
+///
+/// An ownership type of organization is useful even if one object doesn't explicitly own another. Ownership helps establish the relationships between records and how you search for them in the database. Ownership doesn't require the deletion of the owned records when you delete their owner record. You can prevent such deletions by specifying the ``CKRecord/ReferenceAction/none`` action when you create a `CKReference` object.
+///
+/// - Note: When you're creating a `CKReference` between two objects and you have both objects in memory, be sure to fetch the object on the receiving end of the relationship. This is due to the creation of the `CKReference` between the two objects altering the ``CKRecord/recordChangeTag`` of the receiving object on the server.
+///
+/// #### Searching for Related Records
+///
+/// When you want to find records for a single owner object, you create a `CKReference` object and use it to build your search predicate. When you use reference objects in search predicates, the search code looks only at the ID value in the reference object. It matches the ID in records of the specified type with the ID you provide in the `CKReference` object.
+///
+/// The code sample below shows how to use a reference object to construct a query for the records in the figure above. The `listID` variable is a placeholder for the record ID of the list with the items you want to retrieve. The predicate tells the query object to search the `owningList` field of the target records and compare the reference object there with the one in the `recordToMatch` variable. Executing the query operation object returns the matching records asynchronously to the completion block you provide.
+///
+/// @TabNavigator {
+///     @Tab("Swift") {
+///         ```swift
+///         // Match item records with an owningList field that points to the specified list record.
+///         let listID = listRecord.recordID
+///         let recordToMatch = CKReference(recordID: listID, action: .deleteSelf)
+///         let predicate = NSPredicate(format: "owningList == %@", recordToMatch)
+///         // Create the query object.
+///         let query = CKQuery(recordType: "Item", predicate: predicate)
+///         let queryOp = CKQueryOperation(query: query)
+///         queryOp.queryCompletionBlock = { (cursor, error) in
+///             // Process the results…
+///         }
+///         // Add the CKQueryOperation to a queue to execute it and process the results asynchronously.
+///         ```
+///     }
+///     @Tab("Objective-C") {
+///         ```objc
+///         // Match item records with an owningList field that points to the specified list record.
+///         CKReference* recordToMatch = [[CKReference alloc] initWithRecordID:listID
+///                                                                     action:CKReferenceActionDeleteSelf];
+///         NSPredicate* predicate = [NSPredicate predicateWithFormat:@"owningList == %@", recordToMatch];
+///         // Create the query object.
+///         CKQuery* query = [[CKQuery alloc] initWithRecordType:@"Item" predicate:predicate];
+///         CKQueryOperation *queryOp = [[CKQueryOperation alloc] initWithQuery:query];
+///         [queryOp setQueryCompletionBlock:^(CKQueryCursor *nextCursor, NSError *error) {
+///             // Process the results…
+///         }];
+///         // Add the CKQueryOperation to a queue to execute it and process the results asynchronously.
+///         ```
+///     }
+/// }
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 NS_SWIFT_SENDABLE
@@ -31,15 +117,40 @@
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
-/*! @discussion It is acceptable to relate two records that have not yet been uploaded to the server. Those records must be uploaded to the server in the same operation if using an action other than `CKReferenceActionNone`.
- *
- *  If a record references a record that does not exist on the server and is not in the current save operation it will result in an error if using an action other than `CKReferenceActionNone`.
- */
+/// Creates a reference object that points to the record with the specified ID.
+///
+/// - Parameters:
+///   - recordID: The ID of the target record. This method throws an exception if you specify `nil` for this parameter.
+///   - action: The ownership option use between the target record and any records that incorporate this reference object. If you specify the ``CKRecord/ReferenceAction/deleteSelf`` option, the record that the `recordID` parameter references becomes the owner of (or acts as the parent of) any objects that use this reference object. For a list of possible values, see ``CKRecord/ReferenceAction``.
+///
+/// - Returns: An initialized reference object that points to the specified record.
+///
+/// Use this method when you have only the ID of the record for the target of a link. You might use this method if you save only the ID of the record to a local data cache.
+///
+/// When you create a reference object for use in a search predicate, the predicate ignores the value in the `action` parameter. Search predicates use only the ID of the record during their comparison.
 - (instancetype)initWithRecordID:(CKRecordID *)recordID action:(CKReferenceAction)action NS_DESIGNATED_INITIALIZER;
+
+/// Creates a reference object that points to the specified record object.
+///
+/// - Parameters:
+///   - record: The target record of the reference.
+///   - action: The ownership options to use for the records. If you specify the ``CKRecord/ReferenceAction/deleteSelf`` option, the object that the `recordID` parameter references becomes the owner of (or acts as the parent of) any objects that use this reference object. For a list of possible values, see ``CKRecord/ReferenceAction``.
+///
+/// - Returns: An initialized reference object that points to the specified record.
+///
+/// Use this method to initialize a reference to a local record object. You can reference a local record that you create, or one that you fetch from the server.
+///
+/// When you create a reference object for use in a search predicate, the predicate ignores the value in the `action` parameter. Search predicates use only the ID of the record during their comparison.
 - (instancetype)initWithRecord:(CKRecord *)record action:(CKReferenceAction)action;
 
+/// The ownership behavior for the records.
+///
+/// The value in this property determines which action, if any, to take when deleting the target of the reference object — that is, the object that the ``CKRecord/Reference/recordID`` property points to. When this property is ``CKRecord/ReferenceAction/deleteSelf``, deleting the target object deletes any records that contain that reference in one of their fields. When this property is ``CKRecord/ReferenceAction/none``, deleting the target object doesn't delete any additional objects.
 @property (readonly, assign, nonatomic) CKReferenceAction referenceAction;
 
+/// The ID of the referenced record.
+///
+/// Use the ID in this property to fetch the record on the other end of the link.
 @property (readonly, copy, nonatomic) CKRecordID *recordID;
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKServerChangeToken.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKServerChangeToken.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKServerChangeToken.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKServerChangeToken.h	2026-02-13 10:44:53
@@ -9,6 +9,39 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An opaque token that represents a specific point in a database's history.
+///
+/// CloudKit uses server change tokens to record significant events in a database's history, such as record creation, modification, and deletion. Using change tokens helps reduce the cost of a fetch operation — both the time to execute the fetch and the overall number of records it returns.
+///
+/// You don't create change tokens. Instead, ``CKFetchDatabaseChangesOperation`` and ``CKFetchRecordZoneChangesOperation`` provide them during their execution and when they complete. Cache each token as you receive it, overwriting any previous token for the database or record zone you're fetching from. Then, pass the cached token with your next fetch and CloudKit returns only the changes that occur after that point. Don't infer any behavior or order from a token's contents.
+///
+/// The change tokens that ``CKFetchDatabaseChangesOperation`` provides aren't compatible with ``CKFetchRecordZoneChangesOperation`` and vice versa, so segregate them in your cache.
+///
+/// Change tokens conform to <doc://com.apple.documentation/documentation/foundation/nssecurecoding> and are safe to cache on-disk, as the following example shows:
+///
+/// ```swift
+/// func writeToken(_ token: CKServerChangeToken, to url: URL) throws {
+///     // Use a keyed archiver to securely encode the provided token.
+///     let coder = NSKeyedArchiver(requiringSecureCoding: true)
+///     coder.encode(token, forKey: "token")
+///
+///     // Write the encoded data to disk. The caller provides the
+///     // location as a file URL.
+///     let data = coder.encodedData
+///     try data.write(to: url)
+/// }
+///
+/// func readToken(at url: URL) throws -> CKServerChangeToken? {
+///     // Create a Data instance with the contents of the file at
+///     // the provided URL.
+///     let data = try Data(contentsOf: url)
+///
+///     // Use a keyed unarchiver to decode the token and return
+///     // it to the caller.
+///     let coder = try NSKeyedUnarchiver(forReadingFrom: data)
+///     return coder.decodeObject(of: CKServerChangeToken.self, forKey: "token")
+/// }
+/// ```
 API_AVAILABLE(macos(10.10), ios(8.0), watchos(3.0))
 // This class should not be subclassed. If it is, Sendable may no longer apply.
 NS_SWIFT_SENDABLE
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShare.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShare.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShare.h	2025-11-09 04:34:57
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShare.h	2026-02-13 10:44:52
@@ -18,94 +18,181 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// The system type that identifies a share record.
 CK_EXTERN CKRecordType const CKRecordTypeShare API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
-/*! A zone-wide CKShare always uses the record name @c CKRecordNameZoneWideShare.
- *  You can use this to fetch the @c CKShare record for the zone with a @c CKFetchRecordsOperation.
- */
+/// The name of a share record that manages a shared record zone.
+///
+/// When you create an instance of ``CKShare`` for sharing a record zone, CloudKit automatically assigns this constant as the ``CKRecord/ID/recordName`` element of the share record's ``CKRecord/recordID``. After you save the share record to iCloud, you can fetch it by reconstructing the record ID using this constant, as the following example shows:
+///
+/// ```swift
+/// func fetchShare(
+///     forZone zone: CKRecordZone,
+///     completion: @escaping (Result<CKShare, any Error>) -> Void
+/// ) {
+///     let database = CKContainer.default().privateCloudDatabase
+///
+///     // Use the 'CKRecordNameZoneWideShare' constant to create the record ID.
+///     let recordID = CKRecord.ID(recordName: CKRecordNameZoneWideShare,
+///                                zoneID: zone.zoneID)
+///
+///     // Fetch the share record from the specified record zone.
+///     database.fetch(withRecordID: recordID) { share, error in
+///         if let error = error {
+///             // If the fetch fails, inform the caller.
+///             completion(.failure(error))
+///         } else if let share = share as? CKShare {
+///             // Otherwise, pass the fetched share record to the
+///             // completion handler.
+///             completion(.success(share))
+///         } else {
+///             fatalError("Unable to fetch record with ID: \(recordID)")
+///         }
+///     }
+/// }
+/// ```
 CK_EXTERN NSString * const CKRecordNameZoneWideShare API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0));
 
-/*! Predefined keys in the @c CKRecordTypeShare schema.  They're used by the out of process UI flow to send a share, and as part of the share acceptance flow.  These are optional */
-
-/*! Value is a string.  Example for a recipe sharing app: "Pot Roast" */
+/// The system field key for the share's title.
+///
+/// This predefined key is part of the `CKRecordTypeShare` schema. The out of process UI flow uses this key to send a share, and as part of the share acceptance flow. It is an optional value on a `CKShare` record.
 CK_EXTERN CKRecordFieldKey const CKShareTitleKey API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
-/*! Value is a data blob suitable to pass into @code -[NSImage imageWithData:] or -[UIImage imageWithData:] @endcode */
+
+/// The system field key for the share's thumbnail image data.
+///
+/// This predefined key is part of the `CKRecordTypeShare` schema.  It is used by the out of process UI flow to send a share, and as part of the share acceptance flow.  It is an optional value on a `CKShare` record.
 CK_EXTERN CKRecordFieldKey const CKShareThumbnailImageDataKey API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
-/*! Value is a string representing a UTI.  Example for a recipe sharing app: "com.mycompany.recipe" */
+
+/// The system field key for the share's type.
+///
+/// This predefined key is part of the `CKRecordTypeShare` schema.  It is used by the out of process UI flow to send a share, and as part of the share acceptance flow.  It is an optional value on a `CKShare` record.
 CK_EXTERN CKRecordFieldKey const CKShareTypeKey API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
-/*! @class CKShare
- *
- *  @discussion Like CKRecords, CKShares can store arbitrary key-value pairs.  They are modified and fetched in the same manner.
- *  A share, its root record, and its root record's children records will only appear in a participant's CKFetchRecordChangesOperation's results after the share has been accepted by that participant.
- *  Clients have access to the share (and optionally the root record) before accepting a share, via the CKShareMetadata object.  Note that in order to access a root record before accepting a share, you must run a CKFetchShareMetadataOperation requesting the root record.
- *  A CKShare will appear in a CKFetchRecordChangesOperation's results set whenever the participant list is updated.  For that reason, you shouldn't place heavy key-value pairs in it.
- */
-
+/// A specialized record type that manages a collection of shared records.
+///
+/// A share is a specialized record type that facilitates the sharing of one or more records with many participants. You store shareable records in a custom record zone in the user's private database. As you create records in that zone, they become eligible for record zone sharing. If you want to share a specific hierarchy of related records, rather than the entire record zone, set each record's ``CKRecord/parent`` property to define the relationship with its parent. CloudKit infers the shared hierarchy using only the ``CKRecord/parent`` property, and ignores any custom reference fields.
+///
+/// You create a share with either the ID of the record zone to share, or the root record, which defines the point in a record hierarchy where you want to start sharing. CloudKit shares all the records in the record zone, or every record in the hierarchy below the root. If you set the root record's ``CKRecord/parent`` property, CloudKit ignores it. A record can take part in only a single share. This applies to every record in the shared record zone or hierarchy. If a record is participating in another share, any attempt to save the share fails, and CloudKit returns an ``CKError/alreadyShared`` error.
+///
+/// Use ``CKModifyRecordsOperation`` to save the share to the server. The initial set of records the share includes must exist on the server or be part of the same save operation to succeed. CloudKit then updates the share's ``url`` property. Use <doc://com.apple.documentation/documentation/uikit/uicloudsharingcontroller> to present options to the user for sharing the URL. Otherwise, distribute the URL to any participants you add to the share. You can allow anyone with the URL to take part in the share by setting ``publicPermission`` to a value more permissive than ``ParticipantPermission/none``.
+///
+/// - Important: You must add the <doc://com.apple.documentation/documentation/bundleresources/information-property-list/cksharingsupported> key to your app's `Info.plist` file with a value of `true`. This allows the system to launch your app when a user taps or clicks the URL.
+///
+/// After CloudKit saves the share, a participant can fetch its corresponding metadata, which includes a reference to the share, information about the user's participation, and, for shared hierarchies, the root record's record ID. Create an instance of ``CKFetchShareMetadataOperation`` using the share's URL and add it to the container's queue to execute it. The operation returns an instance of ``Metadata`` for each URL you provide. This is only applicable if you manually process share acceptance. If a user receives the share URL and taps or clicks it, CloudKit automatically processes their participation.
+///
+/// To determine the configuration of a fetched share, inspect the ``CKRecord/ID/recordName`` property of its ``CKRecord/recordID``. If the value is ``CKRecordNameZoneWideShare``, the share is managing a shared record zone; otherwise, it's managing a shared record hierarchy.
+///
+/// ```swift
+/// let isZoneWide = (metadata.share.recordID.recordName == CKRecordNameZoneWideShare)
+/// ```
+///
+/// CloudKit limits the number of participants in a share to 100, and each participant must have an active iCloud account. You don't create participants. Instead, use <doc://com.apple.documentation/documentation/uikit/uicloudsharingcontroller> to manage a share's participants and their permissions. Alternatively, create an instance of ``CKUserIdentity/LookupInfo`` for each user. Provide the user's email address or phone number, and use ``CKFetchShareParticipantsOperation`` to fetch the corresponding participants. CloudKit queries iCloud for corresponding accounts as part of the operation. If it doesn't find an account, the server updates the participant's ``Participant/userIdentity`` to reflect that by setting the ``CKUserIdentity/hasiCloudAccount`` property to <doc://com.apple.documentation/documentation/swift/false>. CloudKit associates the participant with their iCloud account when they accept the share if they launch the process by tapping or clicking the share URL.
+///
+/// Participants with write permissions can modify or delete any record that you include in the share. However, only the owner can delete a shared hierarchy's root record. If a participant attempts to delete the share, CloudKit removes the participant. The share remains active for all other participants. If the owner deletes a share that manages a record hierarchy, CloudKit sets the root record's ``CKRecord/share`` property to `nil`. CloudKit deletes the share if the owner of the shared heirarchy deletes its root record.
+///
+/// You can customize the title and image the system displays when initiating a share or accepting an invitation to participate. You can also provide a custom UTI to indicate the content of the shared records. Use the keys that ``SystemFieldKey`` defines, as the following example shows:
+///
+/// ```swift
+/// let share = CKShare(rootRecord: album)
+///
+/// // Configure the share so the system displays the album's
+/// // name and cover when the user initiates sharing or accepts
+/// // an invitation to participate.
+/// share[CKShare.SystemFieldKey.title] = album["name"]
+/// if let cover = album["cover"] as? UIImage, let data = cover.pngData() {
+///     share[CKShare.SystemFieldKey.thumbnailImageData] = data
+/// }
+/// // Include a custom UTI that describes the share's content.
+/// share[CKShare.SystemFieldKey.shareType] = "com.example.app.album"
+/// ```
 API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
 // This class should not be subclassed. If it is, Sendable may no longer apply.
 // NS_SWIFT_SENDABLE on macos(14.0), ios(17.0), tvos(17.0), watchos(10.0)
 @interface CKShare : CKRecord <NSSecureCoding, NSCopying>
 
-/*! When saving a newly created CKShare, you must save the share and its rootRecord in the same CKModifyRecordsOperation batch. */
+/// Creates a new share for the specified record.
+///
+/// - Parameters:
+///   - rootRecord: The record to share.
+///
+/// When saving a newly created ``CKShare``, you save both the share and its ``CKShare/Metadata/rootRecord`` in the same ``CKModifyRecordsOperation`` batch.
 - (instancetype)initWithRootRecord:(CKRecord *)rootRecord;
+
+/// Creates a new share for the specified record and record ID.
+///
+/// - Parameters:
+///   - rootRecord: The record to share.
+///   - shareID: The ``CKRecord/ID`` for the share.
+///
+/// When saving a newly created ``CKShare``, you save both the share and its ``CKShare/Metadata/rootRecord`` in the same ``CKModifyRecordsOperation`` batch.
 - (instancetype)initWithRootRecord:(CKRecord *)rootRecord shareID:(CKRecordID *)shareID NS_DESIGNATED_INITIALIZER;
 
-/*! Creates a zone-wide @c CKShare.  A zone-wide @c CKShare can only exist in a zone with sharing capability @c CKRecordZoneCapabilityZoneWideSharing.
- * Only one such share can exist in a zone at a time.
- *
- * All records in this zone will appear in a participant's @c CKFetchRecordZoneChangesOperation results in the shared database after the
- * share has been accepted by the participant.
- *
- * Since these shares do not have an associated root record, @c shouldFetchRootRecord and @c rootRecordDesiredKeys are always ignored when
- * running a @c CKFetchShareMetadataOperation on a zone-wide share URL. Additionally, @c rootRecordID on the resulting @c CKShareMetadata is
- * always absent.
- */
+/// Creates a new share for the specified record zone.
+///
+/// - Parameters:
+///   - recordZoneID: The ID of the record zone to share.
+///
+/// A shared record zone must have the ``CKRecordZone/Capabilities/zoneWideSharing`` capability. Custom record zones that you create in the user's private database have this capability by default. A record zone, and the records it contains, can take part in only a single share.
+///
+/// After accepting a share invite, CloudKit adds the records of the shared record zone to a new zone in the participant's shared database. Use ``CKFetchDatabaseChangesOperation`` to fetch the ID of the new record zone. Then configure ``CKFetchRecordZoneChangesOperation`` with that record zone ID and execute the operation to fetch the records.
+///
+/// If you use ``CKFetchShareMetadataOperation`` to fetch the metadata for a shared record zone, the operation ignores the ``CKFetchShareMetadataOperation/shouldFetchRootRecord`` and ``CKFetchShareMetadataOperation/rootRecordDesiredKeys-3xrex`` properties because, unlike a shared record hierarchy, a record zone doesn't have a nominated root record.
 - (instancetype)initWithRecordZoneID:(CKRecordZoneID *)recordZoneID NS_DESIGNATED_INITIALIZER API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0));
 
+/// Creates a share from a serialized instance.
+///
+/// - Parameters:
+///   - aDecoder: The coder to use when deserializing the share.
+///
+/// When saving a newly created ``CKShare``, you must save the share and its ``CKShare/Metadata/rootRecord`` in the same ``CKModifyRecordsOperation`` batch.
 - (instancetype)initWithCoder:(NSCoder *)aDecoder NS_DESIGNATED_INITIALIZER;
 
-/*! @abstract Defines what permission a user has when not explicitly added to the share.
- *
- *  @discussion Shares with @c publicPermission more permissive than @c CKShareParticipantPermissionNone can be joined by any user with access to the share's shareURL.
- *  By default, public permission is @c CKShareParticipantPermissionNone.
- *  Changing the public permission to @c CKShareParticipantPermissionReadOnly or @c CKShareParticipantPermissionReadWrite will result in all pending participants being removed.  Already-accepted participants will remain on the share.
- *  Changing the public permission to @c CKShareParticipantPermissionNone will result in all participants being removed from the share.  You may subsequently choose to call @c addParticipant: before saving the share, those participants will be added to the share.
- */
+/// The permission for anyone with access to the share's URL.
+///
+/// Setting this property's value to be more permissive than ``CKShare/ParticipantPermission/none`` allows any user with the share's URL to join. CloudKit removes all public participants when you save the share if you set the property's value to ``CKShare/ParticipantPermission/none``.
+///
+/// The default value is ``CKShare/ParticipantPermission/none``
 @property (assign) CKShareParticipantPermission publicPermission;
 
-/*! @abstract A URL that can be used to invite participants to this share.
- *
- *  @discussion Only available after share record has been saved to the server.  This url is stable, and is tied to the rootRecord.  That is, if you share a rootRecord, delete the share, and re-share the same rootRecord via a newly created share, that newly created share's url will be identical to the prior share's url
- */
+/// The Uniform Resource Locator (URL) for inviting participants to the share.
+///
+/// This property is only available after saving a share record to the server. This URL is stable and persists across shares and reshares of the same root record.
 @property (nullable, readonly, copy) NSURL *URL;
 
-/*! @abstract All participants on the share that the current user has permissions to see.
- *
- *  @discussion At the minimum that will include the owner and the current user.
- */
+/// An array that contains the share's participants.
+///
+/// The property's value contains all of the share's participants that the current user has permissions to see. At a minimum, it includes the share's owner and the current user.
 @property (readonly, copy) NSArray<CKShareParticipant *> *participants;
 
-/*! Convenience methods for fetching special users from the participant array */
+/// The participant that represents the share's owner.
 @property (readonly, copy) CKShareParticipant *owner;
+
+/// The participant that represents the current user.
 @property (nullable, readonly, copy) CKShareParticipant *currentUserParticipant;
 
-/*! @discussion If a participant with a matching userIdentity already exists, then that existing participant's properties will be updated; no new participant will be added.
- *  A ``CKShareParticipant`` instance that has already been added to one ``CKShare`` cannot be added to another, unless it is removed from the first ``CKShare`` through `removeParticipant`.
- *  In order to modify the list of participants, a share must have publicPermission set to @c CKShareParticipantPermissionNone.  That is, you cannot mix-and-match private users and public users in the same share.
- *  @see CKShareParticipantRole
- */
+/// Adds a participant to the share.
+///
+/// - Parameters:
+///   - participant: The participant to add to the share.
+///
+/// If a participant with a matching ``CKShare/Participant/userIdentity`` already exists in the share, the system updates the existing participant's properties and doesn't add a new participant.
+///
+/// To modify the list of participants, a share's ``CKShare/publicPermission`` must be ``CKShare/ParticipantPermission/none``. You can't mix and match public and private users in the same share. You can only add certain participant types with this API. See ``CKShare/Participant`` for more information.
 - (void)addParticipant:(CKShareParticipant *)participant;
 
-/*! @discussion It's not allowed to call `removeParticipant` on a ``CKShare`` with a ``CKShareParticipant`` that has never been added to that share through `addParticipant`.
- */
+/// Removes a participant from the share.
+///
+/// - Parameters:
+///   - participant: The participant to remove from the share.
+///
+/// To modify the list of participants, a share's ``CKShare/publicPermission`` must be ``CKShare/ParticipantPermission/none``. You can't mix and match public and private users in the same share. You can only add certain participant types with this API. See ``CKShare/Participant`` for more information.
 - (void)removeParticipant:(CKShareParticipant *)participant;
 
-/// Invitation URLs that can be used by any receiver to claim the associated participantID and join the share.
+/// Invitation URLs that any receiver can use to claim the associated participantID and join the share.
 ///
 /// Only available after a share record has been saved to the server for participants created via ``CKShareParticipant/oneTimeURLParticipant``.
 /// One-time URLs are stable, and tied to the associated participantIDs as long as the participant is part of the share.
-/// Typically, a recipient user invited via their handle is provided a ``URL`` directly by the share's owner.
+/// Typically, a share owner provides a ``URL`` directly to a user invited via their handle.
 /// However, any user can also use a one-time URL in the same manner to fetch share metadata and accept the share.
 /// After share acceptance, the one-time URL becomes functionally equivalent to the regular ``URL``.
 ///
@@ -113,7 +200,7 @@
 ///   - participantID: The ``CKShareParticipant/participantID`` corresponding to the ``CKShareParticipant/oneTimeURLParticipant`` added to the share.
 - (nullable NSURL *)oneTimeURLForParticipantID:(NSString *)participantID API_AVAILABLE(macos(15.0), ios(18.0), tvos(18.0), watchos(11.0), visionos(2.0)) NS_REFINED_FOR_SWIFT;
 
-/*! These superclass-provided initializers are not allowed for CKShare */
+// These superclass-provided initializers are not allowed for CKShare.
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 - (instancetype)initWithRecordType:(CKRecordType)recordType NS_UNAVAILABLE;
@@ -122,8 +209,8 @@
 
 /// A list of all uninvited users who have requested access to this share.
 ///
-/// When share access requests are allowed, uninvited users can request to join the share.
-/// All pending access requests appear in this array. Each requester is returned with name components
+/// When an originator or administrator allows share access requests, uninvited users can request to join the share.
+/// All pending access requests appear in this array. CloudKit returns each requester with name components
 /// and either an email or phone number.
 ///
 /// Either share owners or administrators can respond to these access requests.
@@ -136,36 +223,36 @@
 ///     - Add the resulting participant to the share.
 ///
 /// - **Deny Requesters:**
-///     - Use ``CloudKit/CKShare/denyRequesters:`` to remove the requester from the requesters list.
+///     - Use ``CloudKit/CKShare/denyRequesters(_:)`` to remove the requester from the requesters list.
 ///
 /// - **Block Requesters:**
-///     - Use ``CloudKit/CKShare/blockRequesters:`` to block requesters.
+///     - Use ``CloudKit/CKShare/blockRequesters(_:)`` to block requesters.
 ///     - Blocking a requester prevents them from sending future access requests to the share.
 @property (readonly, copy) NSArray<CKShareAccessRequester *> *requesters CKSHARE_REQUEST_ACCESS_INTERFACES_AVAILABILITY;
 
 /// A list of users blocked from requesting access to this share.
 ///
-/// Identities remain in this list until an owner or administrator calls ``CloudKit/CKShare/unblockIdentities:``.
+/// Identities remain in this list until an owner or administrator calls ``CloudKit/CKShare/unblockIdentities(_:)``.
 @property (readonly, copy) NSArray<CKShareBlockedIdentity *> *blockedIdentities CKSHARE_REQUEST_ACCESS_INTERFACES_AVAILABILITY;
 
 /// Indicates whether uninvited users can request access to this share.
 ///
-/// By default, this property is set to `NO`. When set to `YES`, uninvited users can request
-/// access to the share if they discover the share URL. When set to `NO`, the server prevents uninvited users
+/// By default, this property is `NO`. When this property is `YES`, uninvited users can request
+/// access to the share if they discover the share URL. When this property is `NO`, the server prevents uninvited users
 /// from requesting access and does not indicate whether the share exists.
 ///
-/// Only the share owner or an administrator can modify this property. Attempts by other participants
-/// to modify this property result in an exception.
+/// Only the share owner or an administrator can modify this property. If another participant attempts to modify
+/// this property, CloudKit throws an exception.
 @property (readwrite, assign) BOOL allowsAccessRequests CKSHARE_REQUEST_ACCESS_INTERFACES_AVAILABILITY;
 
 /// Denies access requests from specified users.
 ///
-/// Use this method to deny pending access requests from uninvited users. Denied requesters are removed
+/// Use this method to deny pending access requests from uninvited users. CloudKit removes denied requesters
 /// from the ``CloudKit/CKShare/requesters`` array. To persist the changes, save the share to the server
 /// after calling this method.
 ///
 /// After denial, requesters can still submit new access requests unless explicitly blocked using
-/// ``CloudKit/CKShare/blockRequesters:``.
+/// ``CloudKit/CKShare/blockRequesters(_:)``.
 ///
 /// Only the share owner or an administrator can invoke this method. Attempts by other participants
 /// result in an exception.
@@ -188,8 +275,8 @@
 
 /// Unblocks previously blocked users, allowing them to request access again.
 ///
-/// Use this method to remove specified identities from the ``CloudKit/CKShare/blockedIdentities`` array.
-/// Unblocked identities can request access again if access requests are enabled.
+/// Use this method to remove specified identities from the ``CKShare/blockedIdentities`` array.
+/// Unblocked identities can request access again if the ``CKShare/allowsAccessRequests`` is enabled.
 ///
 /// To persist this change, save the share to the server after calling this method.
 ///
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareAccessRequester.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareAccessRequester.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareAccessRequester.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareAccessRequester.h	2026-02-13 10:44:52
@@ -35,7 +35,7 @@
 
 #if !TARGET_OS_TV
 
-/// A displayable `CNContact` representing the requester.
+/// A displayable CNContact representing the requester.
 ///
 /// If the requester doesn't exist in the user's contacts or is not accessible, returns a newly created `CNContact`.
 /// This provides formatted requester information suitable for display in the application's UI.
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareBlockedIdentity.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareBlockedIdentity.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareBlockedIdentity.h	2025-11-09 04:37:40
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareBlockedIdentity.h	2026-02-13 10:44:54
@@ -29,7 +29,7 @@
 
 #if !TARGET_OS_TV
 
-/// A displayable `CNContact` representing the blocked user.
+/// A displayable CNContact representing the blocked user.
 ///
 /// If the blocked identity does not exist in the user's contacts or is not accessible, returns a newly created `CNContact`.
 /// This provides formatted blocked identity information suitable for display in the application's UI.
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareMetadata.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareMetadata.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareMetadata.h	2025-11-09 04:37:39
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareMetadata.h	2026-02-13 13:56:55
@@ -12,29 +12,71 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// An object that describes a shared record's metadata.
+///
+/// A share's metadata is an intermediary object that provides access to the share, its owner, and, for a shared record hierarchy, its root record. Metadata also includes details about the current user's participation in the share.
+///
+/// You don't create metadata. CloudKit provides it to your app when the user taps or clicks a share's ``CKShare/url``, such as in an email or a message. The method CloudKit calls varies by platform and app configuration, and includes the following:
+///
+/// - For a scene-based iOS app in a running or suspended state, CloudKit calls the <doc://com.apple.documentation/documentation/uikit/uiwindowscenedelegate/windowscene(_:userdidacceptcloudkitsharewith:)> method on your window scene delegate.
+/// - For a scene-based iOS app that's not running, the system launches your app in response to the tap or click, and calls the <doc://com.apple.documentation/documentation/uikit/uiscenedelegate/scene(_:willconnectto:options:)> method on your scene delegate. The `connectionOptions` parameter contains the metadata. Use its <doc://com.apple.documentation/documentation/uikit/uiscene/connectionoptions/cloudkitsharemetadata> property to access it.
+/// - For an iOS app that doesn't use scenes, CloudKit calls your app delegate's <doc://com.apple.documentation/documentation/uikit/uiapplicationdelegate/application(_:userdidacceptcloudkitsharewith:)> method.
+/// - For a macOS app, CloudKit calls your app delegate's <doc://com.apple.documentation/documentation/appkit/nsapplicationdelegate/application(_:userdidacceptcloudkitsharewith:)> method.
+/// - For a watchOS app, CloudKit calls the <doc://com.apple.documentation/documentation/watchkit/wkextensiondelegate/userdidacceptcloudkitshare(with:)> method on your watch extension delegate.
+///
+/// Respond by checking the ``participantStatus`` of the provided metadata. If the status is `pending`, use ``CKAcceptSharesOperation`` to accept participation in the share. You can also fetch metadata independent of this flow using ``CKFetchShareMetadataOperation``.
+///
+/// For a shared record hierarchy, the ``hierarchicalRootRecordID`` property contains the ID of the share's root record. When using ``CKFetchShareMetadataOperation`` to fetch metadata, you can include the entire root record by setting the operation's ``CKFetchShareMetadataOperation/shouldFetchRootRecord`` property to <doc://com.apple.documentation/documentation/swift/true>. CloudKit then populates the ``rootRecord`` property before it returns the metadata. You can further customize this behavior using the operation's ``CKFetchShareMetadataOperation/rootRecordDesiredKeys-3xrex`` property to specify which fields to return. This functionality isn't applicable for a shared record zone because, unlike a shared record hierarchy, it doesn't have a nominated root record.
+///
+/// The participant properties provide the current user's acceptance status, permissions, and role. Use these values to determine what functionality to provide to the user. For example, only display editing controls for accepted participants with `readWrite` permissions.
 API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
 CK_SUBCLASSING_DEPRECATED // should not be subclassed, or Sendable may no longer apply
 // NS_SWIFT_SENDABLE on macos(14.0), ios(17.0), tvos(17.0), watchos(10.0)
 @interface CKShareMetadata : NSObject <NSCopying, NSSecureCoding>
 
-- (instancetype)init CK_UNAVAILABLE("Obtain `CKShareMetadata` from ``CKFetchShareMetadataOperation`` or platform-specific scene / app delegate callbacks.");
-+ (instancetype)new CK_UNAVAILABLE("Obtain `CKShareMetadata` from ``CKFetchShareMetadataOperation`` or platform-specific scene / app delegate callbacks.");
+- (instancetype)init CK_UNAVAILABLE("Obtain `CKShareMetadata` from `CKFetchShareMetadataOperation` or platform-specific scene / app delegate callbacks.");
++ (instancetype)new CK_UNAVAILABLE("Obtain `CKShareMetadata` from `CKFetchShareMetadataOperation` or platform-specific scene / app delegate callbacks.");
 
+/// The ID of the share's container.
 @property (readonly, copy) NSString *containerIdentifier;
+
+/// The share that owns the metadata.
 @property (readonly, copy) CKShare *share;
+
+/// The record ID of the shared hierarchy's root record.
+///
+/// CloudKit populates this property only for metadata that belongs to a shared record hierarchy. If the metadata is part of a shared record zone, the property is `nil`. This is because, unlike a shared record hierarchy, a shared record zone doesn't have a nominated root record.
 @property (nullable, readonly, copy) CKRecordID *hierarchicalRootRecordID API_AVAILABLE(macos(12.0), ios(15.0), tvos(15.0), watchos(8.0));
 
-/*! These properties reflect the participant properties of the user invoking CKFetchShareMetadataOperation */
+/// The share's participant role for the user who retrieves the metadata.
 @property (readonly, assign) CKShareParticipantRole participantRole API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0));
+
+/// The share's participation status for the user who retrieves the metadata.
 @property (readonly, assign) CKShareParticipantAcceptanceStatus participantStatus;
+
+/// The share's permissions for the user who retrieves the metadata.
 @property (readonly, assign) CKShareParticipantPermission participantPermission;
 
+/// The identity of the share's owner.
 @property (readonly, copy) CKUserIdentity *ownerIdentity;
 
-/*! This is only present if the share metadata was returned from a CKFetchShareMetadataOperation with shouldFetchRootRecord set to YES */  
+/// The share's root record.
+///
+/// This property contains the root record of the shared record hierarchy if you set the ``CKFetchShareMetadataOperation/shouldFetchRootRecord`` property of the operation that fetches the metadata to <doc://com.apple.documentation/documentation/swift/true>. You can specify which fields CloudKit returns by setting the same operation's ``CKFetchShareMetadataOperation/rootRecordDesiredKeys-3xrex`` property.
+///
+/// The operation ignores the ``CKFetchShareMetadataOperation/shouldFetchRootRecord`` and ``CKFetchShareMetadataOperation/rootRecordDesiredKeys-3xrex`` properties when fetching a shared record zone's metadata because, unlike a shared record hierarchy, a record zone doesn't have a nominated root record.
 @property (nullable, readonly, copy) CKRecord *rootRecord;
 
+/// The share's participation type for the user who retrieves the metadata.
 @property (readonly, assign) CKShareParticipantType participantType API_OBSOLETED_WITH_REPLACEMENT("role", macos(10.12, 10.14, 16.0), ios(10.0, 12.0, 19.0), tvos(10.0, 12.0, 19.0), watchos(3.0, 5.0, 12.0));
+
+/// The record ID of the share's root record.
+///
+/// @DeprecationSummary {
+///     Use ``CKShare/Metadata/hierarchicalRootRecordID`` instead.
+/// }
+/// 
+/// CloudKit populates this property only for metadata that belongs to a shared record hierarchy. If the metadata is part of a shared record zone, the property returns `nil`. This is because, unlike a shared record hierarchy, a shared record zone doesn't have a nominated root record.
 @property (readonly, copy) CKRecordID *rootRecordID API_DEPRECATED_WITH_REPLACEMENT("hierarchicalRootRecordID", macos(10.12, 13.0), ios(10.0, 16.0), tvos(10.0, 16.0), watchos(3.0, 9.0));
 
 @end
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareParticipant.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareParticipant.h
--- /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareParticipant.h	2025-11-09 05:29:54
+++ /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareParticipant.h	2026-02-13 11:10:17
@@ -11,82 +11,139 @@
 
 NS_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+/// Constants that represent the status of a participant.
 typedef NS_ENUM(NSInteger, CKShareParticipantAcceptanceStatus) {
+    /// The participant's status is unknown.
     CKShareParticipantAcceptanceStatusUnknown,
+
+    /// The participant's acceptance of the share request is pending.
     CKShareParticipantAcceptanceStatusPending,
+
+    /// The participant accepted the share request.
     CKShareParticipantAcceptanceStatusAccepted,
+
+    /// The system removed the participant from the share.
     CKShareParticipantAcceptanceStatusRemoved,
 } API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
-/*! These permissions determine what share participants can do with records inside that share */
+/// Constants that represent the permissions to grant to a share participant.
 typedef NS_ENUM(NSInteger, CKShareParticipantPermission) {
+    /// The participant's permissions are unknown.
     CKShareParticipantPermissionUnknown,
+
+    /// The participant doesn't have any permissions for the share.
     CKShareParticipantPermissionNone,
+
+    /// The participant has read-only permissions for the share.
     CKShareParticipantPermissionReadOnly,
+
+    /// The participant has read-and-write permissions for the share.
     CKShareParticipantPermissionReadWrite,
 } API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0));
 
-/// Defines the participant role in a share:
-/// - `owner`: Can add private users.
-/// - `privateUser`: Can access the share.
-/// - `publicUser`: Self-added when accessing the share URL (owners cannot add public users).
-/// - `administrator`: Can add and remove participants and change their permissions.
-///
-/// Shares with ``CloudKit/CKShareParticipantRole/CKShareParticipantRoleAdministrator`` participants will be returned as read-only to devices running OS versions prior to this role being introduced.
-/// Administrator participants on these read-only shares will be returned as ``CloudKit/CKShareParticipantRole/CKShareParticipantRolePrivateUser``.
+/// Constants that represent the role of a share's participant.
 typedef NS_ENUM(NSInteger, CKShareParticipantRole) {
+    /// The participant's role is unknown.
     CKShareParticipantRoleUnknown = 0,
+
+    /// The participant is the share's owner.
+    ///
+    /// The owner of a share can invite private users.
     CKShareParticipantRoleOwner = 1,
+
+    /// The participant has the private role.
+    ///
+    /// A private user of a share can access the share.
     CKShareParticipantRolePrivateUser = 3,
+
+    /// The participant has the public role.
+    ///
+    /// A public user of a share is self-added when accessing the share URL.
     CKShareParticipantRolePublicUser = 4,
+    
+    /// The participant has the administrator role.
+    ///
+    /// An administrator of a share can add and remove participants and change their permissions.
+    ///
+    /// CloudKit returns shares with `administrator` participants as read-only to devices running OS versions prior to this role being introduced.
+    /// CloudKit returns administrator participants on such read-only shares as ``CloudKit/CKShareParticipantRole/CKShareParticipantRolePrivateUser``.
     CKShareParticipantRoleAdministrator API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0)) = 2,
 } API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0));
 
+/// The role of a participant.
 typedef NS_ENUM(NSInteger, CKShareParticipantType) {
+    /// An unknown role.
     CKShareParticipantTypeUnknown = 0,
+
+    /// The type of an owner.
     CKShareParticipantTypeOwner = 1,
+
+    /// The type of a private user.
     CKShareParticipantTypePrivateUser = 3,
+
+    /// The type of a public owner.
     CKShareParticipantTypePublicUser = 4,
 } API_OBSOLETED_WITH_REPLACEMENT("CKShareParticipantRole", macos(10.12, 10.14, 16.0), ios(10.0, 12.0, 19.0), tvos(10.0, 12.0, 19.0), watchos(3.0, 5.0, 12.0));
 
+/// An object that describes a user's participation in a share.
+///
+/// Participants are a key element of sharing in CloudKit. A participant provides information about an iCloud user and their participation in a share, including their identity, acceptance status, permissions, and role.
+///
+/// The acceptance status determines the participant's visibilty of the shared records. Statuses are: `pending`, `accepted`, `removed`, and `unknown`. If the status is `pending`, use ``CKAcceptSharesOperation`` to accept the share. Upon acceptance, CloudKit makes the shared records available in the participant's shared database. The records remain accessible for as long as the participant's status is `accepted`.
+///
+/// You don't create participants. Use the share's ``CKShare/participants`` property to access its existing participants. Use <doc://com.apple.documentation/documentation/uikit/uicloudsharingcontroller> to manage the share's participants and their permissions. Alternatively, you can generate participants using ``CKFetchShareParticipantsOperation``. Participants must have an active iCloud account.
+///
+/// Anyone with the URL of a public share can become a participant in that share. Participants of a public share assume the `publicUser` role. For private shares, the owner manages the participants. An owner is any participant with the `owner` role. A participant of a private share can't accept the share unless the owner adds them first. Private share participants assume the `privateUser` role. CloudKit removes any pending participants if the owner changes the share's ``CKShare/publicPermission``. CloudKit removes all participants if the new permission is `none`.
+///
+/// Participants with write permissions can modify or delete any record that you include in the share. However, only the owner can delete a shared hierarchy's root record. If a participant attempts to delete the share, CloudKit removes the participant. The share remains active for all other participants.
 API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
 // This class should not be subclassed. If it is, Sendable may no longer apply.
 // NS_SWIFT_SENDABLE on macos(14.0), ios(17.0), tvos(17.0), watchos(10.0)
 @interface CKShareParticipant : NSObject <NSSecureCoding, NSCopying>
 
-/*! Use @c CKFetchShareParticipantsOperation to create a @c CKShareParticipant object */
+// Use CKFetchShareParticipantsOperation to create a CKShareParticipant object
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
+/// The identity of the participant.
+///
+/// This property contains a reference to the user identity for the share participant.
 @property (readonly, copy) CKUserIdentity *userIdentity;
 
-/*! The default participant role is @c CKShareParticipantRolePrivateUser. */
+/// The participant's role for the share.
 @property (assign) CKShareParticipantRole role API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0));
 
-/// The default participant type is ``CloudKit/CKShareParticipantType/CKShareParticipantTypePrivateUser``.
+/// The participant type.
+///
+/// The property controls the participant type for the share. For a list of possible values, see ``CKShareParticipantType``.
 @property (assign) CKShareParticipantType type API_OBSOLETED_WITH_REPLACEMENT("role", macos(10.12, 10.14, 16.0), ios(10.0, 12.0, 19.0), tvos(10.0, 12.0, 19.0), watchos(3.0, 5.0, 12.0));
 
+/// The current state of the user's acceptance of the share.
+///
+/// This property contains the current state of the participant's acceptance of the share. For a list of possible values, see ``CKShare/ParticipantAcceptanceStatus``.
 @property (readonly, assign) CKShareParticipantAcceptanceStatus acceptanceStatus;
 
-/*! The default permission for a new participant is @c CKShareParticipantPermissionReadOnly. */
+/// The participant's permission level for the share.
+///
+/// This property controls the permissions that the participant has for the share. For a list of possible values, see ``CKShare/ParticipantPermission``.
 @property (assign) CKShareParticipantPermission permission;
 
-/*! A unique identifier for this participant. */
+/// A unique identifier for this participant.
 @property (readonly, copy) NSString *participantID API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) NS_REFINED_FOR_SWIFT;
 
-/// Indicates whether the participant was originally a requester who was approved to join the share.
+/// Indicates whether the participant was originally a requester that an originator or administrator approved to join the share.
 @property (readonly, assign, nonatomic) BOOL isApprovedRequester API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
 
-/// The date and time when the participant was added to the share.
+/// The date and time when an originator or administrator added this participant to the share.
 ///
-/// This timestamp is set when the share is successfully saved to the server.
+/// CloudKit sets this timestamp when the share is successfully saved to the server.
 @property (nullable, readonly, copy, nonatomic) NSDate *dateAddedToShare API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
 
 /// Generate a unique URL for inviting a participant without knowing their handle
 ///
-/// When a participant's email address / phone number / userRecordID isn't known up-front, a ``CKShareParticipant/oneTimeURLParticipant`` can be added
-/// to the share. Once the share is saved, a custom invitation link or one-time URL is available for the added participant via ``CKShare/oneTimeURLForParticipantID:``.
-/// This custom link can be used by any recipient user to fetch share metadata and accept the share.
+/// When a participant's email address / phone number / userRecordID isn't known up-front, you can add a ``CKShareParticipant/oneTimeURLParticipant``
+/// to the share. Once you save the share, you can get a custom invitation link or one-time URL for the added participant via ``CKShare/oneTimeURL(for:)``.
+/// Any recipient user can use this custom link to fetch share metadata and accept the share.
 ///
 /// Note that a one-time URL participant in the ``ParticipantAcceptanceStatus/pending`` state has empty ``CKUserIdentity/nameComponents``
 /// and a nil ``CKUserIdentity/lookupInfo``.
diff -ruN /Applications/Xcode_26.3.0.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.framework/Headers/CKShareRequestAccessOperation.h /Applications/Xcode_26.4.0-beta2.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/CloudKit.fram