import type { NobjcObject } from "objc-js";
import type { _NSManagedObjectID } from "./NSManagedObjectID.js";
import type { _NSPersistentContainer } from "./NSPersistentContainer.js";
import type { _NSPersistentStore } from "./NSPersistentStore.js";
import type { _CKContainer } from "../CloudKit/CKContainer.js";
import type { _CKRecord } from "../CloudKit/CKRecord.js";
import type { _CKRecordID } from "../CloudKit/CKRecordID.js";
import type { _CKRecordZoneID } from "../CloudKit/CKRecordZoneID.js";
import type { _CKShare } from "../CloudKit/CKShare.js";
import type { _NSArray } from "../Foundation/NSArray.js";
import type { _NSDictionary } from "../Foundation/NSDictionary.js";
import type { _NSError } from "../Foundation/NSError.js";
import type { _NSSet } from "../Foundation/NSSet.js";
import type { NSPersistentCloudKitContainerSchemaInitializationOptions } from "./NSPersistentCloudKitContainerSchemaInitializationOptions.js";
export declare class _NSPersistentCloudKitContainer extends _NSPersistentContainer {
    static alloc(): _NSPersistentCloudKitContainer;
    static new(): _NSPersistentCloudKitContainer;
    init(): _NSPersistentCloudKitContainer;
    /**
     * This method creates a set of representative CKRecord instances for all stores in the container that use Core Data with CloudKit and uploads them to CloudKit. These records are "fully saturated" in that they have a representative value set for every field Core Data might serialize for the given managed object model. After records are successfully uploaded the schema will be visible in the CloudKit dashboard and the representative records will be deleted. This method returns YES if these operations succeed, or NO and the underlying error if they fail. Note: This method also validates the managed object model in use for a store, so a validation error may be returned if the model is not valid for use with CloudKit.
     */
    initializeCloudKitSchemaWithOptions$error$(options: NSPersistentCloudKitContainerSchemaInitializationOptions, error: NobjcObject | null): boolean;
    /**
     * These methods provide access to the underlying CKRecord, or CKRecordID, backing a given NSManagedObjectID.
     */
    recordForManagedObjectID$(managedObjectID: _NSManagedObjectID): _CKRecord | null;
    recordsForManagedObjectIDs$(managedObjectIDs: _NSArray): _NSDictionary;
    recordIDForManagedObjectID$(managedObjectID: _NSManagedObjectID): _CKRecordID | null;
    recordIDsForManagedObjectIDs$(managedObjectIDs: _NSArray): _NSDictionary;
    /**
     * canUpdateRecordForManagedObjectWithID / canDeleteRecordForManagedObjectWithID indicate whether or not a given object assigned the provided NSManagedObjectID is mutable with respect to the instance of CKRecord that backs it with CloudKit. In order for canUpdateRecordForManagedObjectWithID / canDeleteRecordForManagedObjectWithID to return YES, -[NSPersistentCloudKitContainer canModifyManagedObjectsInStore] must also be YES. Returns YES if any of the following conditions are true: - The provided objectID is a temporary objectID - The provided objectID is assigned to a store not backed by a CKDatabase - The provided objectID is assigned to a store backed by the Private CKDatabase - The provided objectID is assigned to a store backed by the Public CKDatabase AND one of the following conditions is met: - The object has yet to be uploaded to CloudKit (it will be assigned to the current user) - The object has already been uploaded to CloudKit and is owned (indicated by CKRecord.creatorUserRecordID) by the current user
     */
    canUpdateRecordForManagedObjectWithID$(objectID: _NSManagedObjectID): boolean;
    canDeleteRecordForManagedObjectWithID$(objectID: _NSManagedObjectID): boolean;
    /**
     * canModifyManagedObjectsInStore indicates whether or not a given store is mutable when used with CloudKit. This method return YES if the current user has write permissions to the CKDatabase that backs the store. For example: - When using the Public database, devices without an iCloud account can read data but not write any. - When using the Private database, this method always returns YES, even if no iCloud account is present on the device.
     */
    canModifyManagedObjectsInStore$(store: _NSPersistentStore): boolean;
    /**
     * Accept a sharing invitation with the given share metadata. The provided persistent store must be configured to use the Shared database scope. If provided the completion block will be invoked once all operations required to accept the share invitations have finished with the resulting CKShareMetadata objects or with an error if one occurs.
     */
    acceptShareInvitationsFromMetadata$intoPersistentStore$completion$(metadata: _NSArray, persistentStore: _NSPersistentStore, completion: ((acceptedShareMetadatas: _NSArray, acceptOperationError: _NSError) => void) | null): void;
    /**
     * Purges a zone from the CKDatabase associated with the given persistent store (or all active CKDatabases in the persistent cloud container's stores). If provided the completion block will be invoked once per store with the result of the purge operation.
     */
    purgeObjectsAndRecordsInZoneWithID$inPersistentStore$completion$(zoneID: _CKRecordZoneID, persistentStore: _NSPersistentStore | null, completion: ((purgedZoneID: _CKRecordZoneID, purgeError: _NSError) => void) | null): void;
    /**
     * Saves the given CKShare object to the persistent cloud container's metadata in the provided persistent store. If provided the completion block will be invoked once the share has been saved to the corresponding CKDatabase with the result of the operation.
     */
    persistUpdatedShare$inPersistentStore$completion$(share: _CKShare, persistentStore: _NSPersistentStore, completion: ((persistedShare: _CKShare, persistedShareError: _NSError) => void) | null): void;
    /**
     * Fetches a set of CKShareParticipant objects from the CKDatabase associated with the given persistent store. The completion block will be invoked with the result of the CKFetchShareParticipantsOperation and the retrieved participants (if any).
     */
    fetchParticipantsMatchingLookupInfos$intoPersistentStore$completion$(lookupInfos: _NSArray, persistentStore: _NSPersistentStore, completion: ((fetchedParticipants: _NSArray, fetchError: _NSError) => void) | null): void;
    /**
     * Returns the associated CKShare object for a given managed object. If the object's backing CKRecord resides in a CKRecordZone that is currently shared a CKShare will be returned. If the object is not associated with a shared record zone, or the object has not yet been exported to CloudKit (and it's zone is not known), it will not have an entry in the resulting dictionary.
     */
    fetchSharesMatchingObjectIDs$error$(objectIDs: _NSArray, error: NobjcObject | null): _NSDictionary | null;
    /**
     * Fetches all known CKShare records in the given persistent store (or all persistent stores in the persistent cloud container if none is set). This method does not to any network work to attempt to discover additional zones or shares in the CKDatabase that is associated with the persistent store.
     */
    fetchSharesInPersistentStore$error$(persistentStore: _NSPersistentStore | null, error: NobjcObject | null): _NSArray | null;
    /**
     * Use this method to share a set of managed objects to either a new CKShare or an existing one if specified as the 'share' parameter. - managedObjects - the set of objects to be shared. A deep traversal will be performed among the objects and any related objects will also be shared. - share - The existing share in which to share the objects, or nil if a new one should be created for them - completion - A completion block when the share is created and the objects are assigned to it (not necessarily when the objects have been exported to the share) This method will fail if: 1. Any of the objects in 'managedObjects' or those discovered by traversal are already shared 2. Any of the objects in 'managedObjects' are from persistent stores which do not support sharing (for example those using CKDatabaseScopePublic) 3. The current device conditions do not support sharing, for example if there is no CloudKit account on the device, or if NSPersistentCloudKitContainer has failed to initialize. The completion block is meant to be used directly with UICloudSharingController's preparation block completion handler.
     */
    shareManagedObjects$toShare$completion$(managedObjects: _NSArray, share: _CKShare | null, completion: ((sharedObjectIDs: _NSSet, share: _CKShare, cloudKitContainer: _CKContainer, sharingError: _NSError) => void) | null): void;
}
