objcjs-types 0.1.0 → 0.2.1

package/dist/Foundation/NSObject.d.ts

@@ -46,7 +46,7 @@ export declare class _NSObject extends NobjcObject {
     static debugDescription(): _NSString;
     static version(): number;
     static setVersion$(aVersion: number): void;
-    static cancelPreviousPerformRequestsWithTarget$selector$object$(aTarget: NobjcObject, aSelector: string, anArgument: NobjcObject): 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.
@@ -117,18 +117,18 @@ export declare class _NSObject extends NobjcObject {
     forwardingTargetForSelector$(aSelector: string): NobjcObject;
     forwardInvocation$(anInvocation: _NSInvocation): void;
     methodSignatureForSelector$(aSelector: string): _NSMethodSignature;
-    replacementObjectForCoder$(coder: _NSCoder): NobjcObject;
-    awakeAfterUsingCoder$(coder: _NSCoder): NobjcObject;
+    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, didRecoverSelector: string | null, contextInfo: Uint8Array | null): void;
+    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, delay: number, modes: _NSArray): void;
-    performSelector$withObject$afterDelay$(aSelector: string, anArgument: NobjcObject, delay: number): void;
+    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 */
@@ -144,15 +144,15 @@ export declare class _NSObject extends NobjcObject {
     /**
      * 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;
+    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, key: _NSString): void;
+    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, inKey: _NSString, outError: NobjcObject): boolean;
+    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.
      */
@@ -168,20 +168,20 @@ export declare class _NSObject extends NobjcObject {
     /**
      * 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;
-    setValue$forKeyPath$(value: NobjcObject, keyPath: _NSString): void;
-    validateValue$forKeyPath$error$(ioValue: NobjcObject, inKeyPath: _NSString, outError: NobjcObject): boolean;
+    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;
+    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, key: _NSString): void;
+    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.
      */
@@ -195,20 +195,20 @@ export declare class _NSObject extends NobjcObject {
      */
     setValuesForKeysWithDictionary$(keyedValues: _NSDictionary): void;
     /** @deprecated Legacy KVC API */
-    storedValueForKey$(key: _NSString): NobjcObject;
+    storedValueForKey$(key: _NSString): NobjcObject | null;
     /** @deprecated Legacy KVC API */
-    takeStoredValue$forKey$(value: NobjcObject, key: _NSString): void;
+    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, key: _NSString): void;
+    takeValue$forKey$(value: NobjcObject | null, key: _NSString): void;
     /** @deprecated Legacy KVC API */
-    takeValue$forKeyPath$(value: NobjcObject, keyPath: _NSString): void;
+    takeValue$forKeyPath$(value: NobjcObject | null, keyPath: _NSString): void;
     /** @deprecated Legacy KVC API */
-    handleQueryWithUnboundKey$(key: _NSString): NobjcObject;
+    handleQueryWithUnboundKey$(key: _NSString): NobjcObject | null;
     /** @deprecated Legacy KVC API */
-    handleTakeValue$forUnboundKey$(value: NobjcObject, key: _NSString): void;
+    handleTakeValue$forUnboundKey$(value: NobjcObject | null, key: _NSString): void;
     /** @deprecated Legacy KVC API */
     unableToSetNilForKey$(key: _NSString): void;
     /** @deprecated Legacy KVC API */
@@ -218,7 +218,7 @@ export declare class _NSObject extends NobjcObject {
     /**
      * 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, change: _NSDictionary | null, context: Uint8Array | null): void;
+    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.
      */
@@ -247,43 +247,43 @@ export declare class _NSObject extends NobjcObject {
     /**
      * 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;
-    performSelectorOnMainThread$withObject$waitUntilDone$modes$(aSelector: string, arg: NobjcObject, wait: boolean, array: _NSArray | null): void;
-    performSelectorOnMainThread$withObject$waitUntilDone$(aSelector: string, arg: NobjcObject, wait: boolean): void;
+    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, wait: boolean, array: _NSArray | null): void;
-    performSelector$onThread$withObject$waitUntilDone$(aSelector: string, thr: _NSThread, arg: NobjcObject, wait: boolean): void;
+    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): void;
+    performSelectorInBackground$withObject$(aSelector: string, arg: NobjcObject | null): void;
     /** @deprecated replacementObjectForCoder: */
-    replacementObjectForArchiver$(archiver: _NSArchiver): NobjcObject;
+    replacementObjectForArchiver$(archiver: _NSArchiver): NobjcObject | null;
     /** @deprecated Use NSXPCConnection instead */
-    replacementObjectForPortCoder$(coder: _NSPortCoder): NobjcObject;
+    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;
+    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;
+    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, properties: _NSDictionary): NobjcObject;
+    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;
+    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;
+    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;
+    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.
      */
@@ -297,22 +297,22 @@ export declare class _NSObject extends NobjcObject {
     /**
      * 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, key: _NSString): NobjcObject;
+    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): boolean;
+    isEqualTo$(object_: NobjcObject | null): boolean;
     /** Implemented using isEqual:. Returns NO if receiver is nil. */
-    isLessThanOrEqualTo$(object_: NobjcObject): boolean;
+    isLessThanOrEqualTo$(object_: NobjcObject | null): boolean;
     /** Implemented using compare. Returns NO if receiver is nil. */
-    isLessThan$(object_: NobjcObject): boolean;
+    isLessThan$(object_: NobjcObject | null): boolean;
     /** Implemented using compare. Returns NO if receiver is nil. */
-    isGreaterThanOrEqualTo$(object_: NobjcObject): boolean;
+    isGreaterThanOrEqualTo$(object_: NobjcObject | null): boolean;
     /** Implemented using compare. Returns NO if receiver is nil. */
-    isGreaterThan$(object_: NobjcObject): boolean;
+    isGreaterThan$(object_: NobjcObject | null): boolean;
     /** Implemented using compare. Returns NO if receiver is nil. */
-    isNotEqualTo$(object_: NobjcObject): boolean;
+    isNotEqualTo$(object_: NobjcObject | null): boolean;
     /** Implemented using compare. Returns NO if receiver is nil. */
     doesContain$(object_: NobjcObject): boolean;
     /**
@@ -345,9 +345,9 @@ export declare class _NSObject extends NobjcObject {
      */
     observationInfo(): NobjcObject;
     setObservationInfo$(value: Uint8Array): void;
-    classForKeyedArchiver(): NobjcObject;
+    classForKeyedArchiver(): NobjcObject | null;
     /** @deprecated replacementObjectForCoder: */
-    classForArchiver(): NobjcObject;
+    classForArchiver(): NobjcObject | null;
     /** @deprecated Use NSXPCConnection instead */
     classForPortCoder(): NobjcObject;
     classDescription(): _NSClassDescription;
@@ -362,7 +362,7 @@ export declare class _NSObject extends NobjcObject {
     /**
      * Return the four character code identifying the receiver's class in Apple events.
      */
-    classCode(): NobjcObject;
+    classCode(): number;
     /** Return the Objective-C name of the receiver's class. */
     className(): _NSString;
     objectSpecifier(): _NSScriptObjectSpecifier | null;

package/dist/Foundation/NSOperation.d.ts

@@ -26,8 +26,8 @@ export declare class _NSOperation extends _NSObject {
     queuePriority(): NSOperationQueuePriority;
     setQueuePriority$(value: NSOperationQueuePriority): void;
     /** @deprecated Not supported */
-    completionBlock(): NobjcObject;
-    setCompletionBlock$(value: NobjcObject): void;
+    completionBlock(): NobjcObject | null;
+    setCompletionBlock$(value: NobjcObject | null): void;
     /** @deprecated Not supported */
     threadPriority(): number;
     setThreadPriority$(value: number): void;

package/dist/Foundation/NSOperationQueue.d.ts

@@ -32,8 +32,8 @@ export declare class _NSOperationQueue extends _NSObject {
     setName$(value: _NSString | null): void;
     qualityOfService(): NSQualityOfService;
     setQualityOfService$(value: NSQualityOfService): void;
-    underlyingQueue(): NobjcObject;
-    setUnderlyingQueue$(value: NobjcObject): void;
+    underlyingQueue(): _NSObject | null;
+    setUnderlyingQueue$(value: _NSObject | null): void;
     /**
      * These two functions are inherently a race condition and should be avoided if possible
      * @deprecated access to operations is inherently a race condition, it should not be used. For barrier style behaviors please use addBarrierBlock: instead

package/dist/Foundation/NSOrderedCollectionChange.d.ts

@@ -5,12 +5,12 @@ export declare class _NSOrderedCollectionChange extends _NSObject {
     static alloc(): _NSOrderedCollectionChange;
     static new(): _NSOrderedCollectionChange;
     init(): _NSOrderedCollectionChange;
-    static changeWithObject$type$index$(anObject: NobjcObject, type: NSCollectionChangeType, index: number): _NSOrderedCollectionChange;
-    static changeWithObject$type$index$associatedIndex$(anObject: NobjcObject, type: NSCollectionChangeType, index: number, associatedIndex: number): _NSOrderedCollectionChange;
-    initWithObject$type$index$(anObject: NobjcObject, type: NSCollectionChangeType, index: number): _NSOrderedCollectionChange;
-    initWithObject$type$index$associatedIndex$(anObject: NobjcObject, type: NSCollectionChangeType, index: number, associatedIndex: number): _NSOrderedCollectionChange;
+    static changeWithObject$type$index$(anObject: NobjcObject | null, type: NSCollectionChangeType, index: number): _NSOrderedCollectionChange;
+    static changeWithObject$type$index$associatedIndex$(anObject: NobjcObject | null, type: NSCollectionChangeType, index: number, associatedIndex: number): _NSOrderedCollectionChange;
+    initWithObject$type$index$(anObject: NobjcObject | null, type: NSCollectionChangeType, index: number): _NSOrderedCollectionChange;
+    initWithObject$type$index$associatedIndex$(anObject: NobjcObject | null, type: NSCollectionChangeType, index: number, associatedIndex: number): _NSOrderedCollectionChange;
     /** The object that was inserted or removed, if recorded */
-    object(): NobjcObject;
+    object(): NobjcObject | null;
     /** The change type: insert or remove */
     changeType(): NSCollectionChangeType;
     /**

package/dist/Foundation/NSOrderedCollectionDifference.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
+import type { _NSFastEnumeration } from "./NSFastEnumeration.js";
 import type { _NSIndexSet } from "./NSIndexSet.js";
 import type { _NSObject } from "./NSObject.js";
 export declare class _NSOrderedCollectionDifference extends _NSObject {
@@ -9,8 +10,8 @@ export declare class _NSOrderedCollectionDifference extends _NSObject {
     /**
      * Creates a new difference representing the changes in the parameter. For clients interested in the difference between two collections, the collection's differenceFrom method should be used instead. To guarantee that instances are unambiguous and safe for compatible base states, this method requires that its parameter conform to the following requirements: 1) All insertion offsets are unique 2) All removal offsets are unique 3) All associated indexes match a change with the opposite parity.
      */
-    initWithChanges$(changes: NobjcObject): _NSOrderedCollectionDifference;
-    initWithInsertIndexes$insertedObjects$removeIndexes$removedObjects$additionalChanges$(inserts: _NSIndexSet, insertedObjects: _NSArray | null, removes: _NSIndexSet, removedObjects: _NSArray | null, changes: NobjcObject): _NSOrderedCollectionDifference;
+    initWithChanges$(changes: _NSArray): _NSOrderedCollectionDifference;
+    initWithInsertIndexes$insertedObjects$removeIndexes$removedObjects$additionalChanges$(inserts: _NSIndexSet, insertedObjects: _NSArray | null, removes: _NSIndexSet, removedObjects: _NSArray | null, changes: _NSArray): _NSOrderedCollectionDifference;
     initWithInsertIndexes$insertedObjects$removeIndexes$removedObjects$(inserts: _NSIndexSet, insertedObjects: _NSArray | null, removes: _NSIndexSet, removedObjects: _NSArray | null): _NSOrderedCollectionDifference;
     /** Create a new difference by mapping over this difference's members */
     differenceByTransformingChangesWithBlock$(block: NobjcObject): _NSOrderedCollectionDifference;
@@ -18,7 +19,9 @@ export declare class _NSOrderedCollectionDifference extends _NSObject {
      * Returns a difference that is the inverse of the receiver. In other words, given a valid difference `diff` the array `a` is equal to [[a arrayByApplyingDifference:diff] arrayByApplyingDifference:diff.inverseDifference] To revert a chronological sequence of diffs, apply their inverses in reverse order.
      */
     inverseDifference(): _NSOrderedCollectionDifference;
-    insertions(): NobjcObject;
-    removals(): NobjcObject;
+    insertions(): _NSArray;
+    removals(): _NSArray;
     hasChanges(): boolean;
 }
+export interface _NSOrderedCollectionDifference extends _NSFastEnumeration {
+}

package/dist/Foundation/NSOrderedSet.d.ts

@@ -1,8 +1,11 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
 import type { _NSCoder } from "./NSCoder.js";
+import type { _NSCopying } from "./NSCopying.js";
 import type { _NSEnumerator } from "./NSEnumerator.js";
+import type { _NSFastEnumeration } from "./NSFastEnumeration.js";
 import type { _NSIndexSet } from "./NSIndexSet.js";
+import type { _NSMutableCopying } from "./NSMutableCopying.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSOrderedCollectionDifference } from "./NSOrderedCollectionDifference.js";
 import type { _NSPredicate } from "./NSPredicate.js";
@@ -30,9 +33,9 @@ export declare class _NSOrderedSet extends _NSObject {
     objectAtIndex$(idx: number): NobjcObject;
     indexOfObject$(object_: NobjcObject): number;
     init(): _NSOrderedSet;
-    initWithObjects$count$(objects: NobjcObject, cnt: number): _NSOrderedSet;
+    initWithObjects$count$(objects: NobjcObject | null, cnt: number): _NSOrderedSet;
     initWithCoder$(coder: _NSCoder): _NSOrderedSet | null;
-    getObjects$range$(objects: NobjcObject, range: NSRange): void;
+    getObjects$range$(objects: NobjcObject | null, range: NSRange): void;
     objectsAtIndexes$(indexes: _NSIndexSet): _NSArray;
     isEqualToOrderedSet$(other: _NSOrderedSet): boolean;
     containsObject$(object_: NobjcObject): boolean;
@@ -53,11 +56,11 @@ export declare class _NSOrderedSet extends _NSObject {
     indexesOfObjectsWithOptions$passingTest$(opts: NSEnumerationOptions, predicate: NobjcObject): _NSIndexSet;
     indexesOfObjectsAtIndexes$options$passingTest$(s: _NSIndexSet, opts: NSEnumerationOptions, predicate: NobjcObject): _NSIndexSet;
     /** binary search */
-    indexOfObject$inSortedRange$options$usingComparator$(object_: NobjcObject, range: NSRange, opts: NSBinarySearchingOptions, cmp: number): number;
-    sortedArrayUsingComparator$(cmptr: number): _NSArray;
-    sortedArrayWithOptions$usingComparator$(opts: NSSortOptions, cmptr: number): _NSArray;
-    descriptionWithLocale$(locale: NobjcObject): _NSString;
-    descriptionWithLocale$indent$(locale: NobjcObject, level: number): _NSString;
+    indexOfObject$inSortedRange$options$usingComparator$(object_: NobjcObject, range: NSRange, opts: NSBinarySearchingOptions, cmp: NobjcObject): number;
+    sortedArrayUsingComparator$(cmptr: NobjcObject): _NSArray;
+    sortedArrayWithOptions$usingComparator$(opts: NSSortOptions, cmptr: NobjcObject): _NSArray;
+    descriptionWithLocale$(locale: NobjcObject | null): _NSString;
+    descriptionWithLocale$indent$(locale: NobjcObject | null, level: number): _NSString;
     initWithObject$(object_: NobjcObject): _NSOrderedSet;
     initWithObjects$(firstObj: NobjcObject): _NSOrderedSet;
     initWithOrderedSet$(set: _NSOrderedSet): _NSOrderedSet;
@@ -75,12 +78,8 @@ export declare class _NSOrderedSet extends _NSObject {
      */
     differenceFromOrderedSet$(other: _NSOrderedSet): _NSOrderedCollectionDifference;
     orderedSetByApplyingDifference$(difference: _NSOrderedCollectionDifference): _NSOrderedSet | null;
-    /**
-     * Return an ordered set containing the results of invoking -valueForKey: on each of the receiver's members. The returned ordered set might not have the same number of members as the receiver. The returned ordered set will not contain any elements corresponding to instances of -valueForKey: returning nil, nor will it contain duplicates.
-     */
-    valueForKey$(key: _NSString): NobjcObject;
     /** Invoke -setValue:forKey: on each of the receiver's members. */
-    setValue$forKey$(value: NobjcObject, key: _NSString): void;
+    setValue$forKey$(value: NobjcObject | null, key: _NSString): void;
     /**
      * NSOrderedSets are not observable, so these methods raise exceptions when invoked on NSOrderedSets. Instead of observing an ordered set, observe the ordered to-many relationship for which the ordered set is the collection of related objects.
      */
@@ -94,8 +93,8 @@ export declare class _NSOrderedSet extends _NSObject {
      */
     filteredOrderedSetUsingPredicate$(p: _NSPredicate): _NSOrderedSet;
     count(): number;
-    firstObject(): NobjcObject;
-    lastObject(): NobjcObject;
+    firstObject(): NobjcObject | null;
+    lastObject(): NobjcObject | null;
     reversedOrderedSet(): _NSOrderedSet;
     /**
      * These two methods return a facade object for the receiving ordered set, which acts like an immutable array or set (respectively). Note that while you cannot mutate the ordered set through these facades, mutations to the original ordered set will "show through" the facade and it will appear to change spontaneously, since a copy of the ordered set is not being made.
@@ -104,3 +103,5 @@ export declare class _NSOrderedSet extends _NSObject {
     set(): _NSSet;
     description(): _NSString;
 }
+export interface _NSOrderedSet extends _NSCopying, _NSMutableCopying, _NSFastEnumeration {
+}

package/dist/Foundation/NSOrthography.d.ts

@@ -1,6 +1,7 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
 import type { _NSCoder } from "./NSCoder.js";
+import type { _NSCopying } from "./NSCopying.js";
+import type { _NSDictionary } from "./NSDictionary.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSString } from "./NSString.js";
 export declare class _NSOrthography extends _NSObject {
@@ -8,8 +9,8 @@ export declare class _NSOrthography extends _NSObject {
     static new(): _NSOrthography;
     init(): _NSOrthography;
     static defaultOrthographyForLanguage$(language: _NSString): _NSOrthography;
-    static orthographyWithDominantScript$languageMap$(script: _NSString, map: NobjcObject): _NSOrthography;
-    initWithDominantScript$languageMap$(script: _NSString, map: NobjcObject): _NSOrthography;
+    static orthographyWithDominantScript$languageMap$(script: _NSString, map: _NSDictionary): _NSOrthography;
+    initWithDominantScript$languageMap$(script: _NSString, map: _NSDictionary): _NSOrthography;
     initWithCoder$(coder: _NSCoder): _NSOrthography | null;
     /**
      * languagesForScript: returns the list of languages for the specified script, and dominantLanguageForScript: returns the first item on that list.
@@ -20,7 +21,7 @@ export declare class _NSOrthography extends _NSObject {
      * These are the primitive properties which a subclass must implement. The dominantScript should be a script tag (such as Latn, Cyrl, and so forth) and the languageMap should be a dictionary whose keys are script tags and whose values are arrays of language tags (such as en, fr, de, and so forth).
      */
     dominantScript(): _NSString;
-    languageMap(): NobjcObject;
+    languageMap(): _NSDictionary;
     /**
      * The dominantLanguage is the first in the list of languages for the dominant script, allScripts includes the dominant script and all others appearing as keys in the language map, and allLanguages includes all languages appearing in the values of the language map.
      */
@@ -28,3 +29,5 @@ export declare class _NSOrthography extends _NSObject {
     allScripts(): _NSArray;
     allLanguages(): _NSArray;
 }
+export interface _NSOrthography extends _NSCopying {
+}

package/dist/Foundation/NSPersonNameComponents.d.ts

@@ -1,4 +1,6 @@
+import type { _NSCopying } from "./NSCopying.js";
 import type { _NSObject } from "./NSObject.js";
+import type { _NSSecureCoding } from "./NSSecureCoding.js";
 import type { _NSString } from "./NSString.js";
 export declare class _NSPersonNameComponents extends _NSObject {
     static alloc(): _NSPersonNameComponents;
@@ -32,3 +34,5 @@ export declare class _NSPersonNameComponents extends _NSObject {
     phoneticRepresentation(): _NSPersonNameComponents | null;
     setPhoneticRepresentation$(value: _NSPersonNameComponents | null): void;
 }
+export interface _NSPersonNameComponents extends _NSCopying, _NSSecureCoding {
+}

package/dist/Foundation/NSPersonNameComponentsFormatter.d.ts

@@ -26,7 +26,7 @@ export declare class _NSPersonNameComponentsFormatter extends _NSFormatter {
      * Convenience method on getObjectValue:forString:error:. Returns an NSPersonNameComponents object representing the name components found in the provided string.
      */
     personNameComponentsFromString$(string_: _NSString): _NSPersonNameComponents | null;
-    getObjectValue$forString$errorDescription$(obj: NobjcObject, string_: _NSString, error: NobjcObject): boolean;
+    getObjectValue$forString$errorDescription$(obj: NobjcObject | null, string_: _NSString, error: NobjcObject | null): boolean;
     /**
      * Specify the formatting style for the formatted string on an instance. ShortStyle will fall back to user preferences and language-specific defaults
      */

package/dist/Foundation/NSPointerArray.d.ts

@@ -1,7 +1,10 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
+import type { _NSCopying } from "./NSCopying.js";
+import type { _NSFastEnumeration } from "./NSFastEnumeration.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSPointerFunctions } from "./NSPointerFunctions.js";
+import type { _NSSecureCoding } from "./NSSecureCoding.js";
 import type { NSPointerFunctionsOptions } from "./NSPointerFunctionsOptions.js";
 export declare class _NSPointerArray extends _NSObject {
     static alloc(): _NSPointerArray;
@@ -24,7 +27,7 @@ export declare class _NSPointerArray extends _NSObject {
     /** construction */
     initWithOptions$(options: NSPointerFunctionsOptions): _NSPointerArray;
     initWithPointerFunctions$(functions: _NSPointerFunctions): _NSPointerArray;
-    pointerAtIndex$(index: number): NobjcObject;
+    pointerAtIndex$(index: number): NobjcObject | null;
     /** add pointer at index 'count' */
     addPointer$(pointer: Uint8Array | null): void;
     /** everything above index, including holes, slide lower */
@@ -46,3 +49,5 @@ export declare class _NSPointerArray extends _NSObject {
     setCount$(value: number): void;
     allObjects(): _NSArray;
 }
+export interface _NSPointerArray extends _NSFastEnumeration, _NSCopying, _NSSecureCoding {
+}

package/dist/Foundation/NSPointerFunctions.d.ts

@@ -1,4 +1,5 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSCopying } from "./NSCopying.js";
 import type { _NSObject } from "./NSObject.js";
 import type { NSPointerFunctionsOptions } from "./NSPointerFunctionsOptions.js";
 export declare class _NSPointerFunctions extends _NSObject {
@@ -9,23 +10,23 @@ export declare class _NSPointerFunctions extends _NSObject {
     /** construction */
     initWithOptions$(options: NSPointerFunctionsOptions): _NSPointerFunctions;
     /** pointer personality functions */
-    hashFunction(): NobjcObject;
-    setHashFunction$(value: NobjcObject): void;
-    isEqualFunction(): NobjcObject;
-    setIsEqualFunction$(value: NobjcObject): void;
-    sizeFunction(): NobjcObject;
-    setSizeFunction$(value: NobjcObject): void;
-    descriptionFunction(): NobjcObject;
-    setDescriptionFunction$(value: NobjcObject): void;
+    hashFunction(): NobjcObject | null;
+    setHashFunction$(value: NobjcObject | null): void;
+    isEqualFunction(): NobjcObject | null;
+    setIsEqualFunction$(value: NobjcObject | null): void;
+    sizeFunction(): NobjcObject | null;
+    setSizeFunction$(value: NobjcObject | null): void;
+    descriptionFunction(): NobjcObject | null;
+    setDescriptionFunction$(value: NobjcObject | null): void;
     /**
      * custom memory configuration
      * @deprecated Garbage collection no longer supported
      */
-    relinquishFunction(): NobjcObject;
-    setRelinquishFunction$(value: NobjcObject): void;
+    relinquishFunction(): NobjcObject | null;
+    setRelinquishFunction$(value: NobjcObject | null): void;
     /** @deprecated Garbage collection no longer supported */
-    acquireFunction(): NobjcObject;
-    setAcquireFunction$(value: NobjcObject): void;
+    acquireFunction(): NobjcObject | null;
+    setAcquireFunction$(value: NobjcObject | null): void;
     /**
      * GC used to require that read and write barrier functions be used when pointers are from GC memory
      * @deprecated Garbage collection no longer supported
@@ -36,3 +37,5 @@ export declare class _NSPointerFunctions extends _NSObject {
     usesWeakReadAndWriteBarriers(): boolean;
     setUsesWeakReadAndWriteBarriers$(value: boolean): void;
 }
+export interface _NSPointerFunctions extends _NSCopying {
+}

package/dist/Foundation/NSPort.d.ts

@@ -1,4 +1,6 @@
+import type { _NSCoding } from "./NSCoding.js";
 import type { _NSConnection } from "./NSConnection.js";
+import type { _NSCopying } from "./NSCopying.js";
 import type { _NSDate } from "./NSDate.js";
 import type { _NSMutableArray } from "./NSMutableArray.js";
 import type { _NSObject } from "./NSObject.js";
@@ -34,3 +36,5 @@ export declare class _NSPort extends _NSObject {
     /** DO Transport API; subclassers should implement these methods default is 0 */
     reservedSpaceLength(): number;
 }
+export interface _NSPort extends _NSCopying, _NSCoding {
+}

package/dist/Foundation/NSPositionalSpecifier.d.ts

@@ -28,7 +28,7 @@ export declare class _NSPositionalSpecifier extends _NSObject {
     /**
      * Return the container into which insertion should be done, if evaluation has been successful, or nil otherwise. If this object has never been evaluated, evaluation is attempted.
      */
-    insertionContainer(): NobjcObject;
+    insertionContainer(): NobjcObject | null;
     /**
      * Return the key for the to-many relationship for which insertion should be done, if evaluation has been successful, or nil otherwise. If this object has never been evaluated, evaluation is attempted.
      */

package/dist/Foundation/NSPredicate.d.ts

@@ -1,7 +1,9 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
+import type { _NSCopying } from "./NSCopying.js";
 import type { _NSDictionary } from "./NSDictionary.js";
 import type { _NSObject } from "./NSObject.js";
+import type { _NSSecureCoding } from "./NSSecureCoding.js";
 import type { _NSString } from "./NSString.js";
 export declare class _NSPredicate extends _NSObject {
     static alloc(): _NSPredicate;
@@ -14,17 +16,19 @@ export declare class _NSPredicate extends _NSObject {
     static predicateFromMetadataQueryString$(queryString: _NSString): _NSPredicate | null;
     /** return predicates that always evaluate to true/false */
     static predicateWithValue$(value: boolean): _NSPredicate;
-    static predicateWithBlock$(block: NobjcObject): _NSPredicate;
+    static predicateWithBlock$(block: NobjcObject | null): _NSPredicate;
     /** substitute constant values for variables */
     predicateWithSubstitutionVariables$(variables: _NSDictionary): _NSPredicate;
     /** evaluate a predicate against a single object */
-    evaluateWithObject$(object_: NobjcObject): boolean;
+    evaluateWithObject$(object_: NobjcObject | null): boolean;
     /**
      * single pass evaluation substituting variables from the bindings dictionary for any variable expressions encountered
      */
-    evaluateWithObject$substitutionVariables$(object_: NobjcObject, bindings: _NSDictionary | null): boolean;
+    evaluateWithObject$substitutionVariables$(object_: NobjcObject | null, bindings: _NSDictionary | null): boolean;
     /** Force a predicate which was securely decoded to allow evaluation */
     allowEvaluation(): void;
     /** returns the format string of the predicate */
     predicateFormat(): _NSString;
 }
+export interface _NSPredicate extends _NSSecureCoding, _NSCopying {
+}

package/dist/Foundation/NSPresentationIntent.d.ts

@@ -1,5 +1,7 @@
 import type { _NSArray } from "./NSArray.js";
+import type { _NSCopying } from "./NSCopying.js";
 import type { _NSObject } from "./NSObject.js";
+import type { _NSSecureCoding } from "./NSSecureCoding.js";
 import type { _NSString } from "./NSString.js";
 import type { NSPresentationIntentKind } from "./NSPresentationIntentKind.js";
 export declare class _NSPresentationIntent extends _NSObject {
@@ -51,3 +53,5 @@ export declare class _NSPresentationIntent extends _NSObject {
      */
     indentationLevel(): number;
 }
+export interface _NSPresentationIntent extends _NSCopying, _NSSecureCoding {
+}