import type { NobjcObject } from "objc-js";
import type { _NSArray } from "../Foundation/NSArray.js";
import type { _NSDictionary } from "../Foundation/NSDictionary.js";
import type { _NSObject } from "../Foundation/NSObject.js";
import type { _NSSet } from "../Foundation/NSSet.js";
import type { _NSString } from "../Foundation/NSString.js";
import type { _NSEntityDescription } from "./NSEntityDescription.js";
import type { _NSFetchRequest } from "./NSFetchRequest.js";
import type { _NSFetchRequestResult } from "./NSFetchRequestResult.js";
import type { _NSManagedObjectContext } from "./NSManagedObjectContext.js";
import type { _NSManagedObjectID } from "./NSManagedObjectID.js";
import type { NSKeyValueSetMutationKind } from "../Foundation/NSKeyValueSetMutationKind.js";
import type { NSSnapshotEventType } from "./NSSnapshotEventType.js";
export declare class _NSManagedObject extends _NSObject {
    static alloc(): _NSManagedObject;
    static new(): _NSManagedObject;
    init(): _NSManagedObject;
    /**
     * The Entity represented by this subclass. This method is only legal to call on subclasses of NSManagedObject that represent a single entity in the model.
     */
    static entity(): _NSEntityDescription;
    /**
     * A new fetch request initialized with the Entity represented by this subclass. This property's getter is only legal to call on subclasses of NSManagedObject that represent a single entity in the model.
     */
    static fetchRequest(): _NSFetchRequest;
    /**
     * Similarly, transient attributes may be individually flagged as not dirtying the object by adding +(BOOL)contextShouldIgnoreChangesFor<key> where <key> is the property name.
     */
    static contextShouldIgnoreUnmodeledPropertyChanges(): boolean;
    /** The designated initializer. */
    initWithEntity$insertIntoManagedObjectContext$(entity: _NSEntityDescription, context: _NSManagedObjectContext | null): _NSManagedObject;
    /**
     * Returns a new object, inserted into managedObjectContext. This method is only legal to call on subclasses of NSManagedObject that represent a single entity in the model.
     */
    initWithContext$(moc: _NSManagedObjectContext): _NSManagedObject;
    /**
     * returns a Boolean indicating if the relationship for the specified key is a fault. If a value of NO is returned, the resulting relationship is a realized object; otherwise the relationship is a fault. If the specified relationship is a fault, calling this method does not result in the fault firing.
     */
    hasFaultForRelationshipNamed$(key: _NSString): boolean;
    /**
     * returns an array of objectIDs for the contents of a relationship. to-one relationships will return an NSArray with a single NSManagedObjectID. Optional relationships may return an empty NSArray. The objectIDs will be returned in an NSArray regardless of the type of the relationship.
     */
    objectIDsForRelationshipNamed$(key: _NSString): _NSArray;
    /** read notification */
    willAccessValueForKey$(key: _NSString | null): void;
    /**
     * read notification (together with willAccessValueForKey used to maintain inverse relationships, to fire faults, etc.) - each read access has to be wrapped in this method pair (in the same way as each write access has to be wrapped in the KVO method pair)
     */
    didAccessValueForKey$(key: _NSString | null): void;
    /** KVO change notification */
    willChangeValueForKey$(key: _NSString): void;
    didChangeValueForKey$(key: _NSString): void;
    willChangeValueForKey$withSetMutation$usingObjects$(inKey: _NSString, inMutationKind: NSKeyValueSetMutationKind, inObjects: _NSSet): void;
    didChangeValueForKey$withSetMutation$usingObjects$(inKey: _NSString, inMutationKind: NSKeyValueSetMutationKind, inObjects: _NSSet): void;
    /**
     * invoked after a fetch or after unfaulting (commonly used for computing derived values from the persisted properties)
     */
    awakeFromFetch(): void;
    /**
     * invoked after an insert (commonly used for initializing special default/initial settings)
     */
    awakeFromInsert(): void;
    /** Callback for undo, redo, and other multi-property state resets */
    awakeFromSnapshotEvents$(flags: NSSnapshotEventType): void;
    /**
     * Callback before delete propagation while the object is still alive. Useful to perform custom propagation before the relationships are torn down or reconfigure KVO observers.
     */
    prepareForDeletion(): void;
    /**
     * commonly used to compute persisted values from other transient/scratchpad values, to set timestamps, etc. - this method can have "side effects" on the persisted values
     */
    willSave(): void;
    /** commonly used to notify other objects after a save */
    didSave(): void;
    /**
     * invoked automatically by the Core Data framework before receiver is converted (back) to a fault. This method is the companion of the -didTurnIntoFault method, and may be used to (re)set state which requires access to property values (for example, observers across keypaths.) The default implementation does nothing.
     */
    willTurnIntoFault(): void;
    /** commonly used to clear out additional transient values or caches */
    didTurnIntoFault(): void;
    /**
     * KVC - overridden to access generic dictionary storage unless subclasses explicitly provide accessors
     */
    valueForKey$(key: _NSString): NobjcObject | null;
    /**
     * KVC - overridden to access generic dictionary storage unless subclasses explicitly provide accessors
     */
    setValue$forKey$(value: NobjcObject | null, key: _NSString): void;
    /**
     * primitive methods give access to the generic dictionary storage from subclasses that implement explicit accessors like -setName/-name to add custom document logic
     */
    primitiveValueForKey$(key: _NSString): NobjcObject | null;
    setPrimitiveValue$forKey$(value: NobjcObject | null, key: _NSString): void;
    /**
     * returns a dictionary of the last fetched or saved keys and values of this object. Pass nil to get all persistent modeled properties.
     */
    committedValuesForKeys$(keys: _NSArray | null): _NSDictionary;
    /**
     * returns a dictionary with the keys and (new) values that have been changed since last fetching or saving the object (this is implemented efficiently without firing relationship faults)
     */
    changedValues(): _NSDictionary;
    changedValuesForCurrentEvent(): _NSDictionary;
    /** KVC */
    validateValue$forKey$error$(value: NobjcObject | null, key: _NSString, error: NobjcObject | null): boolean;
    validateForDelete$(error: NobjcObject | null): boolean;
    validateForInsert$(error: NobjcObject | null): boolean;
    validateForUpdate$(error: NobjcObject | null): boolean;
    /** identity */
    managedObjectContext(): _NSManagedObjectContext | null;
    entity(): _NSEntityDescription;
    objectID(): _NSManagedObjectID;
    /** state - methods */
    inserted(): boolean;
    updated(): boolean;
    deleted(): boolean;
    hasChanges(): boolean;
    /**
     * returns YES if any persistent properties do not compare isEqual to their last saved state. Relationship faults will not be unnecessarily fired. This differs from the existing -hasChanges method which is a simple dirty flag and also includes transient properties
     */
    hasPersistentChangedValues(): boolean;
    /**
     * this information is useful in many situations when computations are optional - this can be used to avoid growing the object graph unnecessarily (which allows to control performance as it can avoid time consuming fetches from databases)
     */
    fault(): boolean;
    /**
     * Allow developers to determine if an object is in a transitional phase when receiving a KVO notification. Returns 0 if the object is fully initialized as a managed object and not transitioning to or from another state
     */
    faultingState(): number;
}
export interface _NSManagedObject extends _NSFetchRequestResult {
}
