import type { NobjcObject } from "objc-js";
import type { _NSArchiver } from "./NSArchiver.js";
import type { _NSArray } from "./NSArray.js";
import type { _NSClassDescription } from "./NSClassDescription.js";
import type { _NSCoder } from "./NSCoder.js";
import type { _NSData } from "./NSData.js";
import type { _NSDictionary } from "./NSDictionary.js";
import type { _NSError } from "./NSError.js";
import type { _NSFileManager } from "./NSFileManager.js";
import type { _NSIndexSet } from "./NSIndexSet.js";
import type { _NSInvocation } from "./NSInvocation.js";
import type { _NSKeyValueSharedObserversSnapshot } from "./NSKeyValueSharedObserversSnapshot.js";
import type { _NSKeyedArchiver } from "./NSKeyedArchiver.js";
import type { _NSMethodSignature } from "./NSMethodSignature.js";
import type { _NSMutableArray } from "./NSMutableArray.js";
import type { _NSMutableOrderedSet } from "./NSMutableOrderedSet.js";
import type { _NSMutableSet } from "./NSMutableSet.js";
import type { _NSPortCoder } from "./NSPortCoder.js";
import type { _NSScriptObjectSpecifier } from "./NSScriptObjectSpecifier.js";
import type { _NSSet } from "./NSSet.js";
import type { _NSString } from "./NSString.js";
import type { _NSThread } from "./NSThread.js";
import type { _NSURL } from "./NSURL.js";
import type { NSKeyValueChange } from "./NSKeyValueChange.js";
import type { NSKeyValueObservingOptions } from "./NSKeyValueObservingOptions.js";
import type { NSKeyValueSetMutationKind } from "./NSKeyValueSetMutationKind.js";
export declare class _NSObject extends NobjcObject {
    static load(): void;
    static initialize(): void;
    static new(): _NSObject;
    static allocWithZone$(zone: NobjcObject): _NSObject;
    static alloc(): _NSObject;
    static copyWithZone$(zone: NobjcObject): NobjcObject;
    static mutableCopyWithZone$(zone: NobjcObject): NobjcObject;
    static instancesRespondToSelector$(aSelector: string): boolean;
    static conformsToProtocol$(protocol: NobjcObject): boolean;
    static instanceMethodForSelector$(aSelector: string): NobjcObject;
    static instanceMethodSignatureForSelector$(aSelector: string): _NSMethodSignature;
    static isSubclassOfClass$(aClass: NobjcObject): boolean;
    static resolveClassMethod$(sel: string): boolean;
    static resolveInstanceMethod$(sel: string): boolean;
    static hash(): number;
    static superclass(): NobjcObject;
    static class(): NobjcObject;
    static description(): _NSString;
    static debugDescription(): _NSString;
    static version(): number;
    static setVersion$(aVersion: number): void;
    static cancelPreviousPerformRequestsWithTarget$selector$object$(aTarget: NobjcObject, aSelector: string, anArgument: NobjcObject | null): void;
    static cancelPreviousPerformRequestsWithTarget$(aTarget: NobjcObject): void;
    /**
     * Methods that were deprecated in Mac OS 10.4.
     * @deprecated Legacy KVC API
     */
    static useStoredAccessor(): boolean;
    /**
     * Return a set of key paths for properties whose values affect the value of the keyed property. When an observer for the key is registered with an instance of the receiving class, KVO itself automatically observes all of the key paths for the same instance, and sends change notifications for the key to the observer when the value for any of those key paths changes. The default implementation of this method searches the receiving class for a method whose name matches the pattern +keyPathsForValuesAffecting<Key>, and returns the result of invoking that method if it is found. So, any such method must return an NSSet too. If no such method is found, an NSSet that is computed from information provided by previous invocations of the now-deprecated +setKeys:triggerChangeNotificationsForDependentKey: method is returned, for backward binary compatibility. This method and KVO's automatic use of it comprise a dependency mechanism that you can use instead of sending -willChangeValueForKey:/-didChangeValueForKey: messages for dependent, computed, properties. You can override this method when the getter method of one of your properties computes a value to return using the values of other properties, including those that are located by key paths. Your override should typically invoke super and return a set that includes any members in the set that result from doing that (so as not to interfere with overrides of this method in superclasses). You can't really override this method when you add a computed property to an existing class using a category, because you're not supposed to override methods in categories. In that case, implement a matching +keyPathsForValuesAffecting<Key> to take advantage of this mechanism.
     */
    static keyPathsForValuesAffectingValueForKey$(key: _NSString): _NSSet;
    /**
     * Return YES if the key-value observing machinery should automatically invoke -willChangeValueForKey:/-didChangeValueForKey:, -willChange:valuesAtIndexes:forKey:/-didChange:valuesAtIndexes:forKey:, or -willChangeValueForKey:withSetMutation:usingObjects:/-didChangeValueForKey:withSetMutation:usingObjects: whenever instances of the class receive key-value coding messages for the key, or mutating key-value coding-compliant methods for the key are invoked. Return NO otherwise. Starting in Mac OS 10.5, the default implementation of this method searches the receiving class for a method whose name matches the pattern +automaticallyNotifiesObserversOf<Key>, and returns the result of invoking that method if it is found. So, any such method must return BOOL too. If no such method is found YES is returned.
     */
    static automaticallyNotifiesObserversForKey$(key: _NSString): boolean;
    /**
     * A method that was deprecated in Mac OS 10.5, in favor of using +keyPathsForValuesAffectingValueForKey:. Registers the fact that invocations of -willChangeValueForKey:/-didChangeValueForKey:, -willChange:valuesAtIndexes:forKey:/-didChange:valuesAtIndexes:forKey:, and -willChangeValueForKey:withSetMutation:usingObjects:/-didChangeValueForKey:withSetMutation:usingObjects: for any key in the passed-in array should also send notifications for the dependent key.
     * @deprecated Use +keyPathsForValuesAffectingValueForKey instead
     */
    static setKeys$triggerChangeNotificationsForDependentKey$(keys: _NSArray, dependentKey: _NSString): void;
    /**
     * Implemented by classes to substitute new instances for the receiving instance during encoding. The returned object will be encoded instead of the receiver (if different). This method is called only if no replacement mapping for the object has been set up in the archiver yet (for example, due to a previous call of replacementObjectForKeyedArchiver: to that object). This method returns the result of [self replacementObjectForArchiver:nil] by default, NOT -replacementObjectForCoder: as might be expected. This is a concession to source compatibility.
     */
    static classFallbacksForKeyedArchiver(): _NSArray;
    static classForKeyedUnarchiver(): NobjcObject;
    /**
     * Return YES if -valueForKey:, -setValue:forKey:, -mutableArrayValueForKey:, -storedValueForKey:, -takeStoredValue:forKey:, and -takeValue:forKey: may directly manipulate instance variables when sent to instances of the receiving class, NO otherwise. The default implementation of this property returns YES.
     */
    static accessInstanceVariablesDirectly(): boolean;
    isEqual$(object_: NobjcObject): boolean;
    class(): NobjcObject;
    self(): _NSObject;
    performSelector$(aSelector: string): NobjcObject;
    performSelector$withObject$(aSelector: string, object_: NobjcObject): NobjcObject;
    performSelector$withObject$withObject$(aSelector: string, object1: NobjcObject, object2: NobjcObject): NobjcObject;
    isProxy(): boolean;
    isKindOfClass$(aClass: NobjcObject): boolean;
    isMemberOfClass$(aClass: NobjcObject): boolean;
    conformsToProtocol$(aProtocol: NobjcObject): boolean;
    respondsToSelector$(aSelector: string): boolean;
    /**
     * **Do not call.** objc-js uses ARC — object lifetimes are managed automatically. Calling `retain()` will leak memory.
     */
    retain(): _NSObject;
    /**
     * **Do not call.** objc-js uses ARC — object lifetimes are managed automatically. Calling `release()` risks a double-free crash.
     */
    release(): void;
    /**
     * **Do not call.** objc-js uses ARC — object lifetimes are managed automatically. Calling `autorelease()` is unnecessary and unsafe.
     */
    autorelease(): _NSObject;
    /**
     * **Do not use.** objc-js uses ARC — manual reference counting is not applicable. The value returned by this method is meaningless.
     */
    retainCount(): number;
    zone(): NobjcObject;
    init(): _NSObject;
    /**
     * **Do not call.** objc-js uses ARC — objects are deallocated automatically when the JavaScript garbage collector collects the wrapper.
     */
    dealloc(): void;
    /** @deprecated */
    finalize(): void;
    copy(): NobjcObject;
    mutableCopy(): NobjcObject;
    methodForSelector$(aSelector: string): NobjcObject;
    doesNotRecognizeSelector$(aSelector: string): void;
    forwardingTargetForSelector$(aSelector: string): NobjcObject;
    forwardInvocation$(anInvocation: _NSInvocation): void;
    methodSignatureForSelector$(aSelector: string): _NSMethodSignature;
    replacementObjectForCoder$(coder: _NSCoder): NobjcObject | null;
    awakeAfterUsingCoder$(coder: _NSCoder): NobjcObject | null;
    /**
     * Given that an error alert has been presented document-modally to the user, and the user has chosen one of the error's recovery options, attempt recovery from the error, and send the selected message to the specified delegate. The option index is an index into the error's array of localized recovery options. The method selected by didRecoverSelector must have the same signature as: - (void)didPresentErrorWithRecovery:(BOOL)didRecover contextInfo:(void *)contextInfo; The value passed for didRecover must be YES if error recovery was completely successful, NO otherwise.
     */
    attemptRecoveryFromError$optionIndex$delegate$didRecoverSelector$contextInfo$(error: _NSError, recoveryOptionIndex: number, delegate: NobjcObject | null, didRecoverSelector: string | null, contextInfo: Uint8Array | null): void;
    /**
     * Given that an error alert has been presented applicaton-modally to the user, and the user has chosen one of the error's recovery options, attempt recovery from the error, and return YES if error recovery was completely successful, NO otherwise. The recovery option index is an index into the error's array of localized recovery options.
     */
    attemptRecoveryFromError$optionIndex$(error: _NSError, recoveryOptionIndex: number): boolean;
    performSelector$withObject$afterDelay$inModes$(aSelector: string, anArgument: NobjcObject | null, delay: number, modes: _NSArray): void;
    performSelector$withObject$afterDelay$(aSelector: string, anArgument: NobjcObject | null, delay: number): void;
    /** @deprecated Use NSURLConnection instead */
    URL$resourceDataDidBecomeAvailable$(sender: _NSURL, newBytes: _NSData): void;
    /** @deprecated Use NSURLConnection instead */
    URLResourceDidFinishLoading$(sender: _NSURL): void;
    /** @deprecated Use NSURLConnection instead */
    URLResourceDidCancelLoading$(sender: _NSURL): void;
    /** @deprecated Use NSURLConnection instead */
    URL$resourceDidFailLoadingWithReason$(sender: _NSURL, reason: _NSString): void;
    /** @deprecated Handler API no longer supported */
    fileManager$shouldProceedAfterError$(fm: _NSFileManager, errorInfo: _NSDictionary): boolean;
    /** @deprecated Handler API no longer supported */
    fileManager$willProcessPath$(fm: _NSFileManager, path: _NSString): void;
    /**
     * Given a key that identifies an attribute or to-one relationship, return the attribute value or the related object. Given a key that identifies a to-many relationship, return an immutable array or an immutable set that contains all of the related objects. The default implementation of this method does the following: 1. Searches the class of the receiver for an accessor method whose name matches the pattern -get<Key>, -<key>, or -is<Key>, in that order. If such a method is found it is invoked. If the type of the method's result is an object pointer type the result is simply returned. If the type of the result is one of the scalar types supported by NSNumber conversion is done and an NSNumber is returned. Otherwise, conversion is done and an NSValue is returned (new in Mac OS 10.5: results of arbitrary type are converted to NSValues, not just NSPoint, NSRange, NSRect, and NSSize). 2 (introduced in Mac OS 10.7). Otherwise (no simple accessor method is found), searches the class of the receiver for methods whose names match the patterns -countOf<Key> and -indexIn<Key>OfObject: and -objectIn<Key>AtIndex: (corresponding to the primitive methods defined by the NSOrderedSet class) and also -<key>AtIndexes: (corresponding to -[NSOrderedSet objectsAtIndexes:]). If a count method and an indexOf method and at least one of the other two possible methods are found, a collection proxy object that responds to all NSOrderedSet methods is returned. Each NSOrderedSet message sent to the collection proxy object will result in some combination of -countOf<Key>, -indexIn<Key>OfObject:, -objectIn<Key>AtIndex:, and -<key>AtIndexes: messages being sent to the original receiver of -valueForKey:. If the class of the receiver also implements an optional method whose name matches the pattern -get<Key>:range: that method will be used when appropriate for best performance. 3. Otherwise (no simple accessor method or set of ordered set access methods is found), searches the class of the receiver for methods whose names match the patterns -countOf<Key> and -objectIn<Key>AtIndex: (corresponding to the primitive methods defined by the NSArray class) and (introduced in Mac OS 10.4) also -<key>AtIndexes: (corresponding to -[NSArray objectsAtIndexes:]). If a count method and at least one of the other two possible methods are found, a collection proxy object that responds to all NSArray methods is returned. Each NSArray message sent to the collection proxy object will result in some combination of -countOf<Key>, -objectIn<Key>AtIndex:, and -<key>AtIndexes: messages being sent to the original receiver of -valueForKey:. If the class of the receiver also implements an optional method whose name matches the pattern -get<Key>:range: that method will be used when appropriate for best performance. 4 (introduced in Mac OS 10.4). Otherwise (no simple accessor method or set of ordered set or array access methods is found), searches the class of the receiver for a threesome of methods whose names match the patterns -countOf<Key>, -enumeratorOf<Key>, and -memberOf<Key>: (corresponding to the primitive methods defined by the NSSet class). If all three such methods are found a collection proxy object that responds to all NSSet methods is returned. Each NSSet message sent to the collection proxy object will result in some combination of -countOf<Key>, -enumeratorOf<Key>, and -memberOf<Key>: messages being sent to the original receiver of -valueForKey:. 5. Otherwise (no simple accessor method or set of collection access methods is found), if the receiver's class' +accessInstanceVariablesDirectly property returns YES, searches the class of the receiver for an instance variable whose name matches the pattern _<key>, _is<Key>, <key>, or is<Key>, in that order. If such an instance variable is found, the value of the instance variable in the receiver is returned, with the same sort of conversion to NSNumber or NSValue as in step 1. 6. Otherwise (no simple accessor method, set of collection access methods, or instance variable is found), invokes -valueForUndefinedKey: and returns the result. The default implementation of -valueForUndefinedKey: raises an NSUndefinedKeyException, but you can override it in your application. Compatibility notes: - For backward binary compatibility, an accessor method whose name matches the pattern -_get<Key>, or -_<key> is searched for between steps 1 and 3. If such a method is found it is invoked, with the same sort of conversion to NSNumber or NSValue as in step 1. KVC accessor methods whose names start with underscores were deprecated as of Mac OS 10.3 though. - The behavior described in step 5 is a change from Mac OS 10.2, in which the instance variable search order was <key>, _<key>. - For backward binary compatibility, -handleQueryWithUnboundKey: will be invoked instead of -valueForUndefinedKey: in step 6, if the implementation of -handleQueryWithUnboundKey: in the receiver's class is not NSObject's.
     */
    valueForKey$(key: _NSString): NobjcObject | null;
    /**
     * Given a value and a key that identifies an attribute, set the value of the attribute. Given an object and a key that identifies a to-one relationship, relate the object to the receiver, unrelating the previously related object if there was one. Given a collection object and a key that identifies a to-many relationship, relate the objects contained in the collection to the receiver, unrelating previously related objects if there were any. The default implementation of this method does the following: 1. Searches the class of the receiver for an accessor method whose name matches the pattern -set<Key>:. If such a method is found the type of its parameter is checked. If the parameter type is not an object pointer type but the value is nil -setNilValueForKey: is invoked. The default implementation of -setNilValueForKey: raises an NSInvalidArgumentException, but you can override it in your application. Otherwise, if the type of the method's parameter is an object pointer type the method is simply invoked with the value as the argument. If the type of the method's parameter is some other type the inverse of the NSNumber/NSValue conversion done by -valueForKey: is performed before the method is invoked. 2. Otherwise (no accessor method is found), if the receiver's class' +accessInstanceVariablesDirectly property returns YES, searches the class of the receiver for an instance variable whose name matches the pattern _<key>, _is<Key>, <key>, or is<Key>, in that order. If such an instance variable is found and its type is an object pointer type the value is retained and the result is set in the instance variable, after the instance variable's old value is first released. If the instance variable's type is some other type its value is set after the same sort of conversion from NSNumber or NSValue as in step 1. 3. Otherwise (no accessor method or instance variable is found), invokes -setValue:forUndefinedKey:. The default implementation of -setValue:forUndefinedKey: raises an NSUndefinedKeyException, but you can override it in your application. Compatibility notes: - For backward binary compatibility with -takeValue:forKey:'s behavior, a method whose name matches the pattern -_set<Key>: is also recognized in step 1. KVC accessor methods whose names start with underscores were deprecated as of Mac OS 10.3 though. - For backward binary compatibility, -unableToSetNilForKey: will be invoked instead of -setNilValueForKey: in step 1, if the implementation of -unableToSetNilForKey: in the receiver's class is not NSObject's. - The behavior described in step 2 is different from -takeValue:forKey:'s, in which the instance variable search order is <key>, _<key>. - For backward binary compatibility with -takeValue:forKey:'s behavior, -handleTakeValue:forUnboundKey: will be invoked instead of -setValue:forUndefinedKey: in step 3, if the implementation of -handleTakeValue:forUnboundKey: in the receiver's class is not NSObject's.
     */
    setValue$forKey$(value: NobjcObject | null, key: _NSString): void;
    /**
     * Given a pointer to a value pointer, a key that identifies an attribute or to-one relationship, and a pointer to an NSError pointer, return a value that is suitable for use in subsequent -setValue:forKey: messages sent to the same receiver. If no validation is necessary, return YES without altering *ioValue or *outError. If validation is necessary and possible, return YES after setting *ioValue to an object that is the validated version of the original value, but without altering *outError. If validation is necessary but not possible, return NO after setting *outError to an NSError that encapsulates the reason that validation was not possible, but without altering *ioValue. The sender of the message is never given responsibility for releasing ioValue or outError. The default implementation of this method searches the class of the receiver for a validator method whose name matches the pattern -validate<Key>:error:. If such a method is found it is invoked and the result is returned. If no such method is found, YES is returned.
     */
    validateValue$forKey$error$(ioValue: NobjcObject | null, inKey: _NSString, outError: NobjcObject | null): boolean;
    /**
     * Given a key that identifies an _ordered_ to-many relationship, return a mutable array that provides read-write access to the related objects. Objects added to the mutable array will become related to the receiver, and objects removed from the mutable array will become unrelated. The default implementation of this method recognizes the same simple accessor methods and array accessor methods as -valueForKey:'s, and follows the same direct instance variable access policies, but always returns a mutable collection proxy object instead of the immutable collection that -valueForKey: would return. It also: 1. Searches the class of the receiver for methods whose names match the patterns -insertObject:in<Key>AtIndex: and -removeObjectFrom<Key>AtIndex: (corresponding to the two most primitive methods defined by the NSMutableArray class), and (introduced in Mac OS 10.4) also -insert<Key>:atIndexes: and -remove<Key>AtIndexes: (corresponding to -[NSMutableArray insertObjects:atIndexes:] and -[NSMutableArray removeObjectsAtIndexes:). If at least one insertion method and at least one removal method are found each NSMutableArray message sent to the collection proxy object will result in some combination of -insertObject:in<Key>AtIndex:, -removeObjectFrom<Key>AtIndex:, -insert<Key>:atIndexes:, and -remove<Key>AtIndexes: messages being sent to the original receiver of -mutableArrayValueForKey:. If the class of the receiver also implements an optional method whose name matches the pattern -replaceObjectIn<Key>AtIndex:withObject: or (introduced in Mac OS 10.4) -replace<Key>AtIndexes:with<Key>: that method will be used when appropriate for best performance. 2. Otherwise (no set of array mutation methods is found), searches the class of the receiver for an accessor method whose name matches the pattern -set<Key>:. If such a method is found each NSMutableArray message sent to the collection proxy object will result in a -set<Key>: message being sent to the original receiver of -mutableArrayValueForKey:. 3. Otherwise (no set of array mutation methods or simple accessor method is found), if the receiver's class' +accessInstanceVariablesDirectly property returns YES, searches the class of the receiver for an instance variable whose name matches the pattern _<key> or <key>, in that order. If such an instance variable is found, each NSMutableArray message sent to the collection proxy object will be forwarded to the instance variable's value, which therefore must typically be an instance of NSMutableArray or a subclass of NSMutableArray. 4. Otherwise (no set of array mutation methods, simple accessor method, or instance variable is found), returns a mutable collection proxy object anyway. Each NSMutableArray message sent to the collection proxy object will result in a -setValue:forUndefinedKey: message being sent to the original receiver of -mutableArrayValueForKey:. The default implementation of -setValue:forUndefinedKey: raises an NSUndefinedKeyException, but you can override it in your application. Performance note: the repetitive -set<Key>: messages implied by step 2's description are a potential performance problem. For better performance implement insertion and removal methods that fulfill the requirements for step 1 in your KVC-compliant class. For best performance implement a replacement method too.
     */
    mutableArrayValueForKey$(key: _NSString): _NSMutableArray;
    /**
     * Given a key that identifies an _ordered_ and uniquing to-many relationship, return a mutable ordered set that provides read-write access to the related objects. Objects added to the mutable ordered set will become related to the receiver, and objects removed from the mutable ordered set will become unrelated. The default implementation of this method recognizes the same simple accessor methods and ordered set accessor methods as -valueForKey:'s, and follows the same direct instance variable access policies, but always returns a mutable collection proxy object instead of the immutable collection that -valueForKey: would return. It also: 1. Searches the class of the receiver for methods whose names match the patterns -insertObject:in<Key>AtIndex: and -removeObjectFrom<Key>AtIndex: (corresponding to the two most primitive methods defined by the NSMutableOrderedSet class), and also -insert<Key>:atIndexes: and -remove<Key>AtIndexes: (corresponding to -[NSMutableOrderedSet insertObjects:atIndexes:] and -[NSMutableOrderedSet removeObjectsAtIndexes:). If at least one insertion method and at least one removal method are found each NSMutableOrderedSet message sent to the collection proxy object will result in some combination of -insertObject:in<Key>AtIndex:, -removeObjectFrom<Key>AtIndex:, -insert<Key>:atIndexes:, and -remove<Key>AtIndexes: messages being sent to the original receiver of -mutableOrderedSetValueForKey:. If the class of the receiver also implements an optional method whose name matches the pattern -replaceObjectIn<Key>AtIndex:withObject: or -replace<Key>AtIndexes:with<Key>: that method will be used when appropriate for best performance. 2. Otherwise (no set of ordered set mutation methods is found), searches the class of the receiver for an accessor method whose name matches the pattern -set<Key>:. If such a method is found each NSMutableOrderedSet message sent to the collection proxy object will result in a -set<Key>: message being sent to the original receiver of -mutableOrderedSetValueForKey:. 3. Otherwise (no set of ordered set mutation methods or simple accessor method is found), if the receiver's class' +accessInstanceVariablesDirectly property returns YES, searches the class of the receiver for an instance variable whose name matches the pattern _<key> or <key>, in that order. If such an instance variable is found, each NSMutableOrderedSet message sent to the collection proxy object will be forwarded to the instance variable's value, which therefore must typically be an instance of NSMutableOrderedSet or a subclass of NSMutableOrderedSet. 4. Otherwise (no set of ordered set mutation methods, simple accessor method, or instance variable is found), returns a mutable collection proxy object anyway. Each NSMutableOrderedSet message sent to the collection proxy object will result in a -setValue:forUndefinedKey: message being sent to the original receiver of -mutableOrderedSetValueForKey:. The default implementation of -setValue:forUndefinedKey: raises an NSUndefinedKeyException, but you can override it in your application. Performance note: the repetitive -set<Key>: messages implied by step 2's description are a potential performance problem. For better performance implement insertion and removal methods that fulfill the requirements for step 1 in your KVC-compliant class. For best performance implement a replacement method too.
     */
    mutableOrderedSetValueForKey$(key: _NSString): _NSMutableOrderedSet;
    /**
     * Given a key that identifies an _unordered_ and uniquing to-many relationship, return a mutable set that provides read-write access to the related objects. Objects added to the mutable set will become related to the receiver, and objects removed from the mutable set will become unrelated. The default implementation of this method recognizes the same simple accessor methods and set accessor methods as -valueForKey:'s, and follows the same direct instance variable access policies, but always returns a mutable collection proxy object instead of the immutable collection that -valueForKey: would return. It also: 1. Searches the class of the receiver for methods whose names match the patterns -add<Key>Object: and -remove<Key>Object: (corresponding to the two primitive methods defined by the NSMutableSet class) and also -add<Key>: and -remove<Key>: (corresponding to -[NSMutableSet unionSet:] and -[NSMutableSet minusSet:]). If at least one addition method and at least one removal method are found each NSMutableSet message sent to the collection proxy object will result in some combination of -add<Key>Object:, -remove<Key>Object:, -add<Key>:, and -remove<Key>: messages being sent to the original receiver of -mutableSetValueForKey:. If the class of the receiver also implements an optional method whose name matches the pattern -intersect<Key>: or -set<Key>: that method will be used when appropriate for best performance. 2. Otherwise (no set of set mutation methods is found), searches the class of the receiver for an accessor method whose name matches the pattern -set<Key>:. If such a method is found each NSMutableSet message sent to the collection proxy object will result in a -set<Key>: message being sent to the original receiver of -mutableSetValueForKey:. 3. Otherwise (no set of set mutation methods or simple accessor method is found), if the receiver's class' +accessInstanceVariablesDirectly property returns YES, searches the class of the receiver for an instance variable whose name matches the pattern _<key> or <key>, in that order. If such an instance variable is found, each NSMutableSet message sent to the collection proxy object will be forwarded to the instance variable's value, which therefore must typically be an instance of NSMutableSet or a subclass of NSMutableSet. 4. Otherwise (no set of set mutation methods, simple accessor method, or instance variable is found), returns a mutable collection proxy object anyway. Each NSMutableSet message sent to the collection proxy object will result in a -setValue:forUndefinedKey: message being sent to the original receiver of -mutableSetValueForKey:. The default implementation of -setValue:forUndefinedKey: raises an NSUndefinedKeyException, but you can override it in your application. Performance note: the repetitive -set<Key>: messages implied by step 2's description are a potential performance problem. For better performance implement methods that fulfill the requirements for step 1 in your KVC-compliant class.
     */
    mutableSetValueForKey$(key: _NSString): _NSMutableSet;
    /**
     * Key-path-taking variants of like-named methods. The default implementation of each parses the key path enough to determine whether or not it has more than one component (key path components are separated by periods). If so, -valueForKey: is invoked with the first key path component as the argument, and the method being invoked is invoked recursively on the result, with the remainder of the key path passed as an argument. If not, the like-named non-key-path-taking method is invoked.
     */
    valueForKeyPath$(keyPath: _NSString): NobjcObject | null;
    setValue$forKeyPath$(value: NobjcObject | null, keyPath: _NSString): void;
    validateValue$forKeyPath$error$(ioValue: NobjcObject | null, inKeyPath: _NSString, outError: NobjcObject | null): boolean;
    mutableArrayValueForKeyPath$(keyPath: _NSString): _NSMutableArray;
    mutableOrderedSetValueForKeyPath$(keyPath: _NSString): _NSMutableOrderedSet;
    mutableSetValueForKeyPath$(keyPath: _NSString): _NSMutableSet;
    /**
     * Given that an invocation of -valueForKey: would be unable to get a keyed value using its default access mechanism, return the keyed value using some other mechanism. The default implementation of this method raises an NSUndefinedKeyException. You can override it to handle properties that are dynamically defined at run-time.
     */
    valueForUndefinedKey$(key: _NSString): NobjcObject | null;
    /**
     * Given that an invocation of -setValue:forKey: would be unable to set the keyed value using its default mechanism, set the keyed value using some other mechanism. The default implementation of this method raises an NSUndefinedKeyException. You can override it to handle properties that are dynamically defined at run-time.
     */
    setValue$forUndefinedKey$(value: NobjcObject | null, key: _NSString): void;
    /**
     * Given that an invocation of -setValue:forKey: would be unable to set the keyed value because the type of the parameter of the corresponding accessor method is an NSNumber scalar type or NSValue structure type but the value is nil, set the keyed value using some other mechanism. The default implementation of this method raises an NSInvalidArgumentException. You can override it to map nil values to something meaningful in the context of your application.
     */
    setNilValueForKey$(key: _NSString): void;
    /**
     * Given an array of keys, return a dictionary containing the keyed attribute values, to-one-related objects, and/or collections of to-many-related objects. Entries for which -valueForKey: returns nil have NSNull as their value in the returned dictionary.
     */
    dictionaryWithValuesForKeys$(keys: _NSArray): _NSDictionary;
    /**
     * Given a dictionary containing keyed attribute values, to-one-related objects, and/or collections of to-many-related objects, set the keyed values. Dictionary entries whose values are NSNull result in -setValue:nil forKey:key messages being sent to the receiver.
     */
    setValuesForKeysWithDictionary$(keyedValues: _NSDictionary): void;
    /** @deprecated Legacy KVC API */
    storedValueForKey$(key: _NSString): NobjcObject | null;
    /** @deprecated Legacy KVC API */
    takeStoredValue$forKey$(value: NobjcObject | null, key: _NSString): void;
    /**
     * Methods that were deprecated in Mac OS 10.3. Use the new, more consistently named, methods declared above instead.
     * @deprecated Legacy KVC API
     */
    takeValue$forKey$(value: NobjcObject | null, key: _NSString): void;
    /** @deprecated Legacy KVC API */
    takeValue$forKeyPath$(value: NobjcObject | null, keyPath: _NSString): void;
    /** @deprecated Legacy KVC API */
    handleQueryWithUnboundKey$(key: _NSString): NobjcObject | null;
    /** @deprecated Legacy KVC API */
    handleTakeValue$forUnboundKey$(value: NobjcObject | null, key: _NSString): void;
    /** @deprecated Legacy KVC API */
    unableToSetNilForKey$(key: _NSString): void;
    /** @deprecated Legacy KVC API */
    valuesForKeys$(keys: _NSArray): _NSDictionary;
    /** @deprecated Legacy KVC API */
    takeValuesFromDictionary$(properties: _NSDictionary): void;
    /**
     * Given that the receiver has been registered as an observer of the value at a key path relative to an object, be notified of a change to that value. The change dictionary always contains an NSKeyValueChangeKindKey entry whose value is an NSNumber wrapping an NSKeyValueChange (use -[NSNumber unsignedIntegerValue]). The meaning of NSKeyValueChange depends on what sort of property is identified by the key path: - For any sort of property (attribute, to-one relationship, or ordered or unordered to-many relationship) NSKeyValueChangeSetting indicates that the observed object has received a -setValue:forKey: message, or that the key-value coding-compliant set method for the key has been invoked, or that a -willChangeValueForKey:/-didChangeValueForKey: pair has otherwise been invoked. - For an _ordered_ to-many relationship, NSKeyValueChangeInsertion, NSKeyValueChangeRemoval, and NSKeyValueChangeReplacement indicate that a mutating message has been sent to the array returned by a -mutableArrayValueForKey: message sent to the object, or sent to the ordered set returned by a -mutableOrderedSetValueForKey: message sent to the object, or that one of the key-value coding-compliant array or ordered set mutation methods for the key has been invoked, or that a -willChange:valuesAtIndexes:forKey:/-didChange:valuesAtIndexes:forKey: pair has otherwise been invoked. - For an _unordered_ to-many relationship (introduced in Mac OS 10.4), NSKeyValueChangeInsertion, NSKeyValueChangeRemoval, and NSKeyValueChangeReplacement indicate that a mutating message has been sent to the set returned by a -mutableSetValueForKey: message sent to the object, or that one of the key-value coding-compliant set mutation methods for the key has been invoked, or that a -willChangeValueForKey:withSetMutation:usingObjects:/-didChangeValueForKey:withSetMutation:usingObjects: pair has otherwise been invoked. For any sort of property, the change dictionary contains an NSKeyValueChangeNewKey entry if NSKeyValueObservingOptionNew was specified at observer registration time, it's the right kind of change, and this isn't a prior notification. The change dictionary contains an NSKeyValueChangeOldKey if NSKeyValueObservingOptionOld was specified and it's the right kind of change. See the comments for the NSKeyValueObserverNotification informal protocol methods for what the values of those entries can be. For an _ordered_ to-many relationship, the change dictionary always contains an NSKeyValueChangeIndexesKey entry whose value is an NSIndexSet containing the indexes of the inserted, removed, or replaced objects, unless the change is an NSKeyValueChangeSetting. If NSKeyValueObservingOptionPrior (introduced in Mac OS 10.5) was specified at observer registration time, and this notification is one being sent prior to a change as a result, the change dictionary contains an NSKeyValueChangeNotificationIsPriorKey entry whose value is an NSNumber wrapping YES (use -[NSNumber boolValue]). context is always the same pointer that was passed in at observer registration time.
     */
    observeValueForKeyPath$ofObject$change$context$(keyPath: _NSString | null, object_: NobjcObject | null, change: _NSDictionary | null, context: Uint8Array | null): void;
    /**
     * Register or deregister as an observer of the value at a key path relative to the receiver. The options determine what is included in observer notifications and when they're sent, as described above, and the context is passed in observer notifications as described above. You should use -removeObserver:forKeyPath:context: instead of -removeObserver:forKeyPath: whenever possible because it allows you to more precisely specify your intent. When the same observer is registered for the same key path multiple times, but with different context pointers each time, -removeObserver:forKeyPath: has to guess at the context pointer when deciding what exactly to remove, and it can guess wrong.
     */
    addObserver$forKeyPath$options$context$(observer: _NSObject, keyPath: _NSString, options: NSKeyValueObservingOptions, context: Uint8Array | null): void;
    removeObserver$forKeyPath$context$(observer: _NSObject, keyPath: _NSString, context: Uint8Array | null): void;
    removeObserver$forKeyPath$(observer: _NSObject, keyPath: _NSString): void;
    /**
     * Given a key that identifies a property (attribute, to-one relationship, or ordered or unordered to-many relationship), send -observeValueForKeyPath:ofObject:change:context: notification messages of kind NSKeyValueChangeSetting to each observer registered for the key, including those that are registered with other objects using key paths that locate the keyed value in this object. Invocations of these methods must always be paired. The change dictionaries in notifications resulting from use of these methods contain optional entries if requested at observer registration time: - The NSKeyValueChangeOldKey entry, if present, contains the value returned by -valueForKey: at the instant that -willChangeValueForKey: is invoked (or an NSNull if -valueForKey: returns nil). - The NSKeyValueChangeNewKey entry, if present, contains the value returned by -valueForKey: at the instant that -didChangeValueForKey: is invoked (or an NSNull if -valueForKey: returns nil).
     */
    willChangeValueForKey$(key: _NSString): void;
    didChangeValueForKey$(key: _NSString): void;
    /**
     * Given a key that identifies an _ordered_ to-many relationship, send -observeValueForKeyPath:ofObject:change:context: notification messages of the passed-in change kind to each observer registered for the key, including those that are registered with other objects using key paths that locate the keyed value in this object. The passed-in kind must be NSKeyValueChangeInsertion, NSKeyValueChangeRemoval, or NSKeyValueChangeReplacement. The passed-in index set must be the indexes of the objects being inserted, removed, or replaced. Invocations of these methods must always be paired, with identical arguments. The change dictionaries in notifications resulting from use of these methods contain optional entries if requested at observer registration time: - The NSKeyValueChangeOldKey entry, if present (only for NSKeyValueChangeRemoval and NSKeyValueChangeReplacement), contains an array of the indexed objects from the array returned by -valueForKey: at the instant that -willChangeValueForKey:valuesAtIndexes:forKey: is invoked. - The NSKeyValueChangeNewKey entry, if present (only for NSKeyValueChangeInsertion and NSKeyValueChangeReplacement), contains an array of the indexed objects from the array returned by -valueForKey: at the instant that -didChangeValueForKey:valuesAtIndexes:forKey: is invoked.
     */
    willChange$valuesAtIndexes$forKey$(changeKind: NSKeyValueChange, indexes: _NSIndexSet, key: _NSString): void;
    didChange$valuesAtIndexes$forKey$(changeKind: NSKeyValueChange, indexes: _NSIndexSet, key: _NSString): void;
    /**
     * Given a key that identifies an _unordered_ to-many relationship, send -observeValueForKeyPath:ofObject:change:context: notification messages to each observer registered for the key, including those that are registered with other objects using key paths that locate the keyed value in this object. The passed-in mutation kind corresponds to an NSMutableSet method. The passed-in set must contain the set that would be passed to the corresponding NSMutableSet method. Invocations of these methods must always be paired, with identical arguments. The value of the NSKeyValueChangeKindKey entry in change dictionaries in notifications resulting from use of these methods depends on the passed-in mutationKind value: - NSKeyValueUnionSetMutation -> NSKeyValueChangeInsertion - NSKeyValueMinusSetMutation -> NSKeyValueChangeRemoval - NSKeyValueIntersectSetMutation -> NSKeyValueChangeRemoval - NSKeyValueSetSetMutation -> NSKeyValueChangeReplacement The change dictionaries may also contain optional entries: - The NSKeyValueChangeOldKey entry, if present (only for for NSKeyValueChangeRemoval and NSKeyValueChangeReplacement), contains the set of objects that were removed. - The NSKeyValueChangeNewKey entry, if present (only for NSKeyValueChangeInsertion and NSKeyValueChangeReplacement), contains the set of objects that were added.
     */
    willChangeValueForKey$withSetMutation$usingObjects$(key: _NSString, mutationKind: NSKeyValueSetMutationKind, objects: _NSSet): void;
    didChangeValueForKey$withSetMutation$usingObjects$(key: _NSString, mutationKind: NSKeyValueSetMutationKind, objects: _NSSet): void;
    /**
     * Register shared observations. A shared observation collection might be shared between multiple observables to minimise registration work. Shared observers remain registered throughout the object's lifetime and do not need to be removed using `removeObserver:`. An observable may only have one set of shared observations. Subsequent calls to this method will replace existing shared observations. - Parameter sharedObservers: shared observer collection that was initialized with the class of this object - Invariant: `sharedObserers` was initialized with the class of this object - Throws: Exception if the class of the receiving observable object does not match the class with which `sharedObserers` was initialized.
     */
    setSharedObservers$(sharedObservers: _NSKeyValueSharedObserversSnapshot | null): void;
    /**
     * Implemented by classes to substitute a new class for instances during encoding. The object will be encoded as if it were a member of the returned class. The results of this method are overridden by the archiver class and instance name<->class encoding tables. If nil is returned, the result of this method is ignored. This method returns the result of [self classForArchiver] by default, NOT -classForCoder as might be expected. This is a concession to source compatibility.
     */
    replacementObjectForKeyedArchiver$(archiver: _NSKeyedArchiver): NobjcObject | null;
    performSelectorOnMainThread$withObject$waitUntilDone$modes$(aSelector: string, arg: NobjcObject | null, wait: boolean, array: _NSArray | null): void;
    performSelectorOnMainThread$withObject$waitUntilDone$(aSelector: string, arg: NobjcObject | null, wait: boolean): void;
    /** equivalent to the first method with kCFRunLoopCommonModes */
    performSelector$onThread$withObject$waitUntilDone$modes$(aSelector: string, thr: _NSThread, arg: NobjcObject | null, wait: boolean, array: _NSArray | null): void;
    performSelector$onThread$withObject$waitUntilDone$(aSelector: string, thr: _NSThread, arg: NobjcObject | null, wait: boolean): void;
    /** equivalent to the first method with kCFRunLoopCommonModes */
    performSelectorInBackground$withObject$(aSelector: string, arg: NobjcObject | null): void;
    /** @deprecated replacementObjectForCoder: */
    replacementObjectForArchiver$(archiver: _NSArchiver): NobjcObject | null;
    /** @deprecated Use NSXPCConnection instead */
    replacementObjectForPortCoder$(coder: _NSPortCoder): NobjcObject | null;
    inverseForRelationshipKey$(relationshipKey: _NSString): _NSString | null;
    /**
     * Given an object specifier return the specified object or objects in the receiving container. This might successfully return an object, an array of objects, or nil, depending on the kind of object specifier. Because nil is a valid value, failure is signaled by sending the object specifier -setEvaluationError: before returning. Your override doesn't also have to invoke any of the NSScriptCommand error signaling methods, though it can, to record very specific error information. The NSUnknownKeySpecifierError and NSInvalidIndexSpecifierError numbers are special, in that Cocoa may continue evaluating an outer specifier if they're encountered, for the convenience of scripters.
     */
    scriptingValueForSpecifier$(objectSpecifier: _NSScriptObjectSpecifier): NobjcObject | null;
    /**
     * Create one or more scripting objects to be inserted into the relationship identified by the key by copying the passed-in value, set the properties in the copied object or objects, and return it or them. The value is, for example, derived from the receivers of a Duplicate command. Its type must match the type of the property identified by the key. For example, if the property is an ordered to-many relationship, the value will always be an array of objects to be copied, and an array of objects must therefore be returned. The properties are derived from the "with properties" parameter of a Duplicate command. When this method is invoked by Cocoa neither the value nor the properties will have yet been coerced using scripting key-value coding's -coerceValue:forKey: method. In .sdef-declared scriptability the types of the passed-in objects reliably match the relevant .sdef declarations however.
     */
    copyScriptingValue$forKey$withProperties$(value: NobjcObject, key: _NSString, properties: _NSDictionary): NobjcObject | null;
    /**
     * Create a new instance of a scriptable class to be inserted into the relationship identified by the key, set the contentsValue and properties of it, and return it. Or return nil for failure. The contentsValue and properties are derived from the "with contents" and "with properties" parameters of a Make command. The contentsValue may be nil. When this method is invoked by Cocoa neither the contentsValue nor the properties will have yet been coerced using scripting key-value coding's -coerceValue:forKey: method. In .sdef-declared scriptability the types of the passed-in objects reliably match the relevant .sdef declarations however.
     */
    newScriptingObjectOfClass$forValueForKey$withContentsValue$properties$(objectClass: NobjcObject, key: _NSString, contentsValue: NobjcObject | null, properties: _NSDictionary): NobjcObject | null;
    /**
     * Return the indexed object in the value of the to-many relationship identified by the key. The default implementation of this method searches the class of the receiver for a method whose name matches the pattern -valueIn<Key>AtIndex: and invokes it if one is found. If no such method is found an exception is thrown. (In general. Other things may also be done for backward binary compatibility.) If your application requires Mac OS 10.4 or newer you can ignore this method. Fulfilling the more modern requirements of KVC-compliance established by -[NSObject(NSKeyValueCoding) valueForKey:] is enough to make Cocoa's scripting support work for the keyed relationship.
     */
    valueAtIndex$inPropertyWithKey$(index: number, key: _NSString): NobjcObject | null;
    /**
     * Return the named object in the value of the to-many relationship identified by the key. The default implementation of this method searches the class of the receiver for a method whose name matches the pattern -valueIn<Key>WithName: and invokes it if one is found. The declared type of the method's parameter must be NSString *. If no such method is found an exception is thrown. Cocoa's scripting support uses this method during the evaluation of NSNameSpecifiers if it's overridden or a -valueIn<Key>WithName: method is implemented for the key in question. You can take advantage of this to optimize the evaluation of name specifiers. (Doing this is less frequently useful than doing the equivalent thing for unique IDs.) If you don't then Cocoa does a linear search of all of the related objects.
     */
    valueWithName$inPropertyWithKey$(name: _NSString, key: _NSString): NobjcObject | null;
    /**
     * Return the uniquely dentified object in the value of the to-many relationship identified by the key. uniqueID must be either an NSNumber or an NSString. The default implementation of this method searches the class of the receiver for a method whose name matches the pattern -valueIn<Key>WithUniqueID: and invokes it if one is found. The declared type of the unique ID parameter must be id, NSNumber *, NSString *, or one of the scalar types that is supported by NSNumber. If no such method is found an exception is thrown. Cocoa's scripting support uses this method during the evaluation of NSUniqueIDSpecifiers if it's overridden or a -valueIn<Key>WithUniqueID: method is implemented for the key in question. You can take advantage of this to optimize the evaluation of unique ID specifiers. If you don't then Cocoa just does a linear search of all of the related objects.
     */
    valueWithUniqueID$inPropertyWithKey$(uniqueID: NobjcObject, key: _NSString): NobjcObject | null;
    /**
     * Insert, remove, or replace the indexed object in the value of the to-many relationship identified by the key. The default implementations of these methods search the class of the receiver for a method whose name matches the pattern -insertIn<Key>:atIndex:, -removeFrom<Key>AtIndex:, or -replaceIn<Key>:atIndex:, respectively, and invokes it if one is found. If no such method is found an exception is thrown. (In general. Other things may also be done for backward binary compatibility.) If your application requires Mac OS 10.4 or newer you can ignore these methods. Fulfilling the more modern requirements of KVC-compliance established by -[NSObject(NSKeyValueCoding) mutableArrayValueForKey:] is enough to make Cocoa's scripting support work for the keyed relationship.
     */
    insertValue$atIndex$inPropertyWithKey$(value: NobjcObject, index: number, key: _NSString): void;
    removeValueAtIndex$fromPropertyWithKey$(index: number, key: _NSString): void;
    replaceValueAtIndex$inPropertyWithKey$withValue$(index: number, key: _NSString, value: NobjcObject): void;
    /**
     * Insert the object into the value of the to-many relationship identified by the key, at a location that makes sense for a scripted Make command with no "at" parameter (either the beginning or the end, typically). The default implementation of this method searches the class of the receiver for a method whose name matches the pattern -insertIn<Key>: and invokes it if one is found. In an application with .scriptSuite/.scriptTerminology-declared scriptability, NSCreateCommand may invoke this method if the to-many relationship's .scriptSuite declaration has a LocationRequiredToCreate = NO entry, and its default implementation throws an exception if no -insertIn<Key>: method is found. In an application with .sdef-declared scriptability, NSCreateCommand may invoke this method for any to-many relationship, and (starting in Mac OS 10.5) its default implementation never throws an exception. It inserts the new object at either the beginning or the end of the relationship, depending on the value of the "insert-at-beginning" attribute of the <cocoa> subelement of the declaring <element> element.
     */
    insertValue$inPropertyWithKey$(value: NobjcObject, key: _NSString): void;
    /**
     * If the keyed property is an attribute or to-one relationship, coerce the object into an object suitable for setting as the value of the property and return that object. If the keyed property is a to-many relationship, coerce the object into an object suitable for inserting in the value of the property and return that object. The default implementation of this method searches the class of the receiver for a method whose name matches the pattern -coerceValueFor<Key>: and invokes it if one is found. If no such method is found and the application's scriptability is not .sdef-declared then it sends a -coerceValue:toClass: message to [NSScriptCoercionHandler sharedCoercionHandler].
     */
    coerceValue$forKey$(value: NobjcObject | null, key: _NSString): NobjcObject | null;
    /**
     * Overridden by objects that can provide a fully specified object specifier to themselves within an app.
     */
    indicesOfObjectsByEvaluatingObjectSpecifier$(specifier: _NSScriptObjectSpecifier): _NSArray | null;
    isEqualTo$(object_: NobjcObject | null): boolean;
    /** Implemented using isEqual:. Returns NO if receiver is nil. */
    isLessThanOrEqualTo$(object_: NobjcObject | null): boolean;
    /** Implemented using compare. Returns NO if receiver is nil. */
    isLessThan$(object_: NobjcObject | null): boolean;
    /** Implemented using compare. Returns NO if receiver is nil. */
    isGreaterThanOrEqualTo$(object_: NobjcObject | null): boolean;
    /** Implemented using compare. Returns NO if receiver is nil. */
    isGreaterThan$(object_: NobjcObject | null): boolean;
    /** Implemented using compare. Returns NO if receiver is nil. */
    isNotEqualTo$(object_: NobjcObject | null): boolean;
    /** Implemented using compare. Returns NO if receiver is nil. */
    doesContain$(object_: NobjcObject): boolean;
    /**
     * Returns nil if receiver is not an NSArray or if array doesn't contain object. This operator is not working against the database.
     */
    isLike$(object_: _NSString): boolean;
    /**
     * argument should be a string using simple shell wildcards (* and ?). (e.g. "Stev*" or "N?XT"). Returns NO if receiver is not an NSString.
     */
    isCaseInsensitiveLike$(object_: _NSString): boolean;
    /**
     * If the object1 implements the appropriate one of these methods for the comparison operation, these methods will be used. If object1 does not implement the appropriate one of these, and object2 the inverted version, and the comparison operator is one of the first five, then the comparison operator is inverted (ie scriptingIsGreaterThan: -> scriptingIsLessThanOrEqualTo:). If neither object1 or object2 implement the appropriate one of these selectors, we will fall back on trying to use standard EOQualifier-type methods like isEqualto:, isGreaterThan:, etc... for the first five.
     */
    scriptingIsEqualTo$(object_: NobjcObject): boolean;
    scriptingIsLessThanOrEqualTo$(object_: NobjcObject): boolean;
    scriptingIsLessThan$(object_: NobjcObject): boolean;
    scriptingIsGreaterThanOrEqualTo$(object_: NobjcObject): boolean;
    scriptingIsGreaterThan$(object_: NobjcObject): boolean;
    scriptingBeginsWith$(object_: NobjcObject): boolean;
    scriptingEndsWith$(object_: NobjcObject): boolean;
    scriptingContains$(object_: NobjcObject): boolean;
    hash(): number;
    superclass(): NobjcObject;
    description(): _NSString;
    debugDescription(): _NSString;
    classForCoder(): NobjcObject;
    autoContentAccessingProxy(): NobjcObject;
    /**
     * Take or return a pointer that identifies information about all of the observers that are registered with the receiver, the options that were used at registration-time, etc. The default implementation of these methods store observation info in a global dictionary keyed by the receivers' pointers. For improved performance, you can override these methods to store the opaque data pointer in an instance variable. Overrides of these methods must not attempt to send Objective-C messages to the passed-in observation info, including -retain and -release.
     */
    observationInfo(): NobjcObject;
    setObservationInfo$(value: Uint8Array): void;
    classForKeyedArchiver(): NobjcObject | null;
    /** @deprecated replacementObjectForCoder: */
    classForArchiver(): NobjcObject | null;
    /** @deprecated Use NSXPCConnection instead */
    classForPortCoder(): NobjcObject;
    classDescription(): _NSClassDescription;
    attributeKeys(): _NSArray;
    toOneRelationshipKeys(): _NSArray;
    toManyRelationshipKeys(): _NSArray;
    /**
     * Given an NSString-keyed dictionary, set one or more scriptable properties of the object. The valid keys for the dictionary include the keys for writable properties and contents in the .sdef declaration (or non-read-only Attributes and ToOneRelationships in the .scriptSuite declaration) of the object's class and its scripting superclasses, and no others. In other words, invokers of this method must have already done any necessary validation to ensure that the properties dictionary includes nothing but entries for declared, settable attributes and to-one relationships. Implementations of this method are not expected to check the validity of keys in the passed-in dictionary, but must be able accept dictionaries that do not contain entries for every scriptable property. The values of the dictionary are Objective-C objects.
     */
    scriptingProperties(): _NSDictionary | null;
    setScriptingProperties$(value: _NSDictionary | null): void;
    /**
     * Return the four character code identifying the receiver's class in Apple events.
     */
    classCode(): number;
    /** Return the Objective-C name of the receiver's class. */
    className(): _NSString;
    objectSpecifier(): _NSScriptObjectSpecifier | null;
}
