objcjs-types 0.3.0 → 0.5.0

package/dist/Foundation/NSFileManager.d.ts

@@ -5,7 +5,9 @@ import type { _NSCopying } from "./NSCopying.js";
 import type { _NSData } from "./NSData.js";
 import type { _NSDictionary } from "./NSDictionary.js";
 import type { _NSDirectoryEnumerator } from "./NSDirectoryEnumerator.js";
+import type { _NSError } from "./NSError.js";
 import type { _NSFileManagerDelegate } from "./NSFileManagerDelegate.js";
+import type { _NSFileVersion } from "./NSFileVersion.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSString } from "./NSString.js";
 import type { _NSURL } from "./NSURL.js";
@@ -30,7 +32,7 @@ export declare class _NSFileManager extends _NSObject {
     /**
      * This method starts the process of unmounting the volume specified by url. If the volume is encrypted, it is re-locked after being unmounted. The completionHandler will be executed when the operation is complete. If the operation was successful, the block’s errorOrNil argument will be nil; otherwise, errorOrNil will be an error object indicating why the unmount operation failed.
      */
-    unmountVolumeAtURL$options$completionHandler$(url: _NSURL, mask: NSFileManagerUnmountOptions, completionHandler: NobjcObject | null): void;
+    unmountVolumeAtURL$options$completionHandler$(url: _NSURL, mask: NSFileManagerUnmountOptions, completionHandler: ((errorOrNil: _NSError) => void) | null): void;
     /**
      * -contentsOfDirectoryAtURL:includingPropertiesForKeys:options:error: returns an NSArray of NSURLs identifying the the directory entries. If this method returns nil, an NSError will be returned by reference in the 'error' parameter. If the directory contains no entries, this method will return the empty array. When an array is specified for the 'keys' parameter, the specified property values will be pre-fetched and cached with each enumerated URL. This method always does a shallow enumeration of the specified directory (i.e. it always acts as if NSDirectoryEnumerationSkipsSubdirectoryDescendants has been specified). If you need to perform a deep enumeration, use -[NSFileManager enumeratorAtURL:includingPropertiesForKeys:options:errorHandler:]. If you wish to only receive the URLs and no other attributes, then pass '0' for 'options' and an empty NSArray ('[NSArray array]') for 'keys'. If you wish to have the property caches of the vended URLs pre-populated with a default set of attributes, then pass '0' for 'options' and 'nil' for 'keys'.
      */
@@ -166,7 +168,7 @@ export declare class _NSFileManager extends _NSObject {
     /**
      * enumeratorAtURL:includingPropertiesForKeys:options:errorHandler: returns an NSDirectoryEnumerator rooted at the provided directory URL. The NSDirectoryEnumerator returns NSURLs from the -nextObject method. The optional 'includingPropertiesForKeys' parameter indicates which resource properties should be pre-fetched and cached with each enumerated URL. The optional 'errorHandler' block argument is invoked when an error occurs. Parameters to the block are the URL on which an error occurred and the error. When the error handler returns YES, enumeration continues if possible. Enumeration stops immediately when the error handler returns NO. If you wish to only receive the URLs and no other attributes, then pass '0' for 'options' and an empty NSArray ('[NSArray array]') for 'keys'. If you wish to have the property caches of the vended URLs pre-populated with a default set of attributes, then pass '0' for 'options' and 'nil' for 'keys'.
      */
-    enumeratorAtURL$includingPropertiesForKeys$options$errorHandler$(url: _NSURL, keys: _NSArray | null, mask: NSDirectoryEnumerationOptions, handler: NobjcObject | null): _NSDirectoryEnumerator | null;
+    enumeratorAtURL$includingPropertiesForKeys$options$errorHandler$(url: _NSURL, keys: _NSArray | null, mask: NSDirectoryEnumerationOptions, handler: ((url: _NSURL, error: _NSError) => boolean) | null): _NSDirectoryEnumerator | null;
     /**
      * subpathsAtPath: returns an NSArray of all contents and subpaths recursively from the provided path. This may be very expensive to compute for deep filesystem hierarchies, and should probably be avoided.
      */
@@ -213,23 +215,23 @@ export declare class _NSFileManager extends _NSObject {
     /**
      * Asynchronously pauses sync of an item at the given URL. Call this when opening an item to prevent sync from altering the contents of the URL. Once paused, the file provider will not upload local changes nor download remote changes. While paused, call ``uploadLocalVersionOfUbiquitousItem(at:withConflictResolutionPolicy:completionHandler:)`` when the document is in a stable state. This action keeps the server version as up-to-date as possible. If the item is already paused, a second call to this method reports success. If the file provider is already applying changes to the item, the pause fails with an ``NSFileWriteUnknownError-enum.case``, with an underlying error that has domain ``NSPOSIXErrorDomain`` and code ``POSIXError/EBUSY``. If the pause fails, wait for the state to stabilize before retrying. Pausing also fails with ``CocoaError/featureUnsupported`` if `url` refers to a regular (non-package) directory. Pausing sync is independent of the calling app's lifecycle; sync doesn't automatically resume if the app closes or crashes and relaunches later. To resume syncing, explicitly call ``resumeSyncForUbiquitousItem(at:with:completionHandler:)``. Always be sure to resume syncing before you close the item. - Parameters: - url: The URL of the item for which to pause sync. - completionHandler: A closure or block that the framework calls when the pause action completes. It receives a single ``NSError`` parameter to indicate an error that prevented pausing; this value is `nil` if the pause succeeded. In Swift, you can omit the completion handler and catch the thrown error instead.
      */
-    pauseSyncForUbiquitousItemAtURL$completionHandler$(url: _NSURL, completionHandler: NobjcObject | null): void;
+    pauseSyncForUbiquitousItemAtURL$completionHandler$(url: _NSURL, completionHandler: ((error: _NSError) => void) | null): void;
     /**
      * Asynchronously resumes the sync on a paused item using the given resume behavior. Always call this method when your app closes an item to allow the file provider to sync local changes back to the server. In most situations, the ``NSFileManagerResumeSyncBehavior/preserveLocalChanges`` behavior is the best choice to avoid any risk of data loss. The resume call fails with ``CocoaError/featureUnsupported`` if `url` isn't currently paused. If the device isn't connected to the network, the call may fail with ``NSFileWriteUnknownError-enum.case``, with the underlying error of <doc://com.apple.documentation/documentation/FileProvider/NSFileProviderError/serverUnreachable>. - Parameters: - url: The URL of the item for which to resume sync. - behavior: A ``NSFileManagerResumeSyncBehavior`` value that tells the file manager how to handle conflicts between local and remote versions of files. - completionHandler: A closure or block that the framework calls when the resume action completes. It receives a single ``NSError`` parameter to indicate an error that prevented the resume action; the value is `nil` if the resume succeeded. In Swift, you can omit the completion handler and catch the thrown error instead.
      */
-    resumeSyncForUbiquitousItemAtURL$withBehavior$completionHandler$(url: _NSURL, behavior: NSFileManagerResumeSyncBehavior, completionHandler: NobjcObject | null): void;
+    resumeSyncForUbiquitousItemAtURL$withBehavior$completionHandler$(url: _NSURL, behavior: NSFileManagerResumeSyncBehavior, completionHandler: ((error: _NSError) => void) | null): void;
     /**
      * Asynchronously fetches the latest remote version of a given item from the server. Use this method if uploading fails due to a version conflict and sync is paused. In this case, fetching the latest remote version allows you to inspect the newer item from the server, resolve the conflict, and resume uploading. The version provided by this call depends on several factors: * If there is no newer version of the file on the server, the caller receives the current version of the file. * If the server has a newer version and sync isn't paused, this call replaces the local item and provides the version of the new item. * If the server has a newer version but sync is paused, the returned version points to a side location. In this case, call ``NSFileVersion/replaceItem(at:options:)`` on the provided version object to replace the local item with the newer item from the server. If the device isn't connected to the network, the call may fail with ``NSFileReadUnknownError-enum.case``, with the underlying error of <doc://com.apple.documentation/documentation/FileProvider/NSFileProviderError/serverUnreachable>. - Parameters: - url: The URL of the item for which to check the version. - completionHandler: A closure or block that the framework calls when the fetch action completes. It receives parameters of types ``NSFileVersion`` and ``NSError``. The error is `nil` if fetching the remote version succeeded; otherwise it indicates the error that caused the call to fail. In Swift, you can omit the completion handler, catching any error in a `do`-`catch` block and receiving the version as the return value.
      */
-    fetchLatestRemoteVersionOfItemAtURL$completionHandler$(url: _NSURL, completionHandler: NobjcObject | null): void;
+    fetchLatestRemoteVersionOfItemAtURL$completionHandler$(url: _NSURL, completionHandler: ((latestRemoteVersion: _NSFileVersion, error: _NSError) => void) | null): void;
     /**
      * Asynchronously uploads the local version of the item using the provided conflict resolution policy. Once your app pauses a sync for an item, call this method every time your document is in a stable state. This action keeps the server version as up-to-date as possible. If the server has a newer version than the one to which the app made changes, uploading fails with ``NSFileWriteUnknownError-enum.case``, with an underlying error of <doc://com.apple.documentation/documentation/FileProvider/NSFileProviderError/localVersionConflictingWithServer>. In this case, call ``FileManager/fetchLatestRemoteVersionOfItem(at:completionHandler:)``, rebase local changes on top of that version, and retry the upload. If the device isn't connected to the network, the call may fail with ``NSFileWriteUnknownError-enum.case``, with the underlying error of <doc://com.apple.documentation/documentation/FileProvider/NSFileProviderError/serverUnreachable>. - Parameters: - url: The URL of the item for which to check the version. - conflictResolutionPolicy: The policy the file manager applies if the local and server versions conflict. - completionHandler: A closure or block that the framework calls when the upload completes. It receives parameters of types ``NSFileVersion`` and ``NSError``. The error is `nil` if fetching the remote version succeeded; otherwise it indicates the error that caused the call to fail. In Swift, you can omit the completion handler, catching any error in a `do`-`catch` block and receiving the version as the return value.
      */
-    uploadLocalVersionOfUbiquitousItemAtURL$withConflictResolutionPolicy$completionHandler$(url: _NSURL, conflictResolutionPolicy: NSFileManagerUploadLocalVersionConflictPolicy, completionHandler: NobjcObject | null): void;
+    uploadLocalVersionOfUbiquitousItemAtURL$withConflictResolutionPolicy$completionHandler$(url: _NSURL, conflictResolutionPolicy: NSFileManagerUploadLocalVersionConflictPolicy, completionHandler: ((uploadedVersion: _NSFileVersion, error: _NSError) => void) | null): void;
     /**
      * Asynchronously returns a dictionary of zero or more NSFileProviderService instances, which enable your application to instruct the file's provider to take various actions on or with regards to the given URL. To do this, first identify an NSFileProviderService object whose name matches the service you wish to use. Then get an NSXPCConnection from it and set up its NSXPCInterface with the protocol that matches the service's name. You'll need to refer to external documentation or an SDK supplied by the provider to get this information. Once an NSXPCConnection is obtained, you must finish configuring it and send it -resume. Failure to do so will result in leaking system resources.
      */
-    getFileProviderServicesForItemAtURL$completionHandler$(url: _NSURL, completionHandler: NobjcObject | null): void;
+    getFileProviderServicesForItemAtURL$completionHandler$(url: _NSURL, completionHandler: ((services: _NSDictionary, error: _NSError) => void) | null): void;
     /** Available for OS X in 10.8.3. */
     containerURLForSecurityApplicationGroupIdentifier$(groupIdentifier: _NSString): _NSURL | null;
     homeDirectoryForUser$(userName: _NSString): _NSURL | null;

package/dist/Foundation/NSFilePresenter.d.ts

@@ -1,4 +1,4 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSError } from "./NSError.js";
 import type { _NSFileVersion } from "./NSFileVersion.js";
 import type { _NSOperationQueue } from "./NSOperationQueue.js";
 import type { _NSSet } from "./NSSet.js";
@@ -7,23 +7,23 @@ export interface _NSFilePresenter {
     /**
      * Given that something in the system is waiting to read from the presented file or directory, do whatever it takes to ensure that the application will behave properly while that reading is happening, and then invoke the completion handler. The definition of "properly" depends on what kind of ownership model the application implements. Implementations of this method must always invoke the passed-in reader block because other parts of the system will wait until it is invoked or until the user loses patience and cancels the waiting. When an implementation of this method invokes the passed-in block it can pass that block yet another block, which will be invoked in the receiver's operation queue when reading is complete. A common sequence that your NSFilePresenter must handle is the file coordination mechanism sending this message, then sending -savePresentedItemChangesWithCompletionHandler:, and then, after you have invoked that completion handler, invoking your reacquirer.
      */
-    relinquishPresentedItemToReader$?(reader: NobjcObject | null): void;
+    relinquishPresentedItemToReader$?(reader: ((arg0: () => void) => void) | null): void;
     /**
      * Given that something in the system is waiting to write to the presented file or directory, do whatever it takes to ensure that the application will behave properly while that writing is happening, and then invoke the completion handler. The definition of "properly" depends on what kind of ownership model the application implements. Implementations of this method must always invoke the passed-in writer block because other parts of the system will wait until it is invoked or until the user loses patience and cancels the waiting. When an implementation of this method invokes the passed-in block it can pass that block yet another block, which will be invoked in the receiver's operation queue when writing is complete. A common sequence that your NSFilePresenter must handle is the file coordination mechanism sending this message, then sending -accommodatePresentedItemDeletionWithCompletionHandler: or -savePresentedItemChangesWithCompletionHandler:, and then, after you have invoked that completion handler, invoking your reacquirer. It is also common for your NSFilePresenter to be sent a combination of the -presented... messages listed below in between relinquishing and reacquiring.
      */
-    relinquishPresentedItemToWriter$?(writer: NobjcObject | null): void;
+    relinquishPresentedItemToWriter$?(writer: ((arg0: () => void) => void) | null): void;
     /**
      * Given that something in the system is waiting to read from the presented file or directory, do whatever it takes to ensure that the contents of the presented file or directory is completely up to date, and then invoke the completion handler. If successful (including when there is simply nothing to do) pass nil to the completion handler, or if not successful pass an NSError that encapsulates the reason why saving failed. Implementations of this method must always invoke the completion handler because other parts of the system will wait until it is invoked or the user loses patience and cancels the waiting. If this method is not implemented then the NSFilePresenter is assumed to be one that never lets the user make changes that need to be saved. For example, NSDocument has an implementation of this method that autosaves the document if it has been changed since the last time it was saved or autosaved. That way when another process tries to read the document file it always reads the same version of the document that the user is looking at in your application. (WYSIWGCBF - What You See Is What Gets Copied By Finder.) A shoebox application would also implement this method. The file coordination mechanism does not always send -relinquishPresentedItemToReader: or -relinquishPresentedItemToWriter: to your NSFilePresenter before sending this message. For example, other process' use of -[NSFileCoordinator prepareForReadingItemsAtURLs:options:writingItemsAtURLs:options:error:byAccessor:] can cause this to happen.
      */
-    savePresentedItemChangesWithCompletionHandler$?(completionHandler: NobjcObject | null): void;
+    savePresentedItemChangesWithCompletionHandler$?(completionHandler: ((errorOrNil: _NSError) => void) | null): void;
     /**
      * Given that something in the system is waiting to delete the presented file or directory, do whatever it takes to ensure that the deleting will succeed and that the receiver's application will behave properly when the deleting has happened, and then invoke the completion handler. If successful (including when there is simply nothing to do) pass nil to the completion handler, or if not successful pass an NSError that encapsulates the reason why preparation failed. Implementations of this method must always invoke the completion handler because other parts of the system will wait until it is invoked or until the user loses patience and cancels the waiting. For example, NSDocument has an implementation of this method that closes the document. That way if the document is in the trash and the user empties the trash the document is simply closed before its file is deleted. This means that emptying the trash will not fail with an alert about the file being "in use" just because the document's file is memory mapped by the application. It also means that the document won't be left open with no document file underneath it. A shoebox application would only implement this method to be robust against surprising things like the user deleting its data directory while the application is running. The file coordination mechanism does not always send -relinquishPresentedItemToReader: or -relinquishPresentedItemToWriter: to your NSFilePresenter before sending this message. For example, other process' use of -[NSFileCoordinator prepareForReadingItemsAtURLs:options:writingItemsAtURLs:options:error:byAccessor:] can cause this to happen.
      */
-    accommodatePresentedItemDeletionWithCompletionHandler$?(completionHandler: NobjcObject | null): void;
+    accommodatePresentedItemDeletionWithCompletionHandler$?(completionHandler: ((errorOrNil: _NSError) => void) | null): void;
     /**
      * Given that something in the system is waiting to evict the presented file or directory, do whatever it takes to ensure that the eviction will succeed and that the receiver's application will behave properly when the eviction has happened, and then invoke the completion handler. This must include calling `+[NSFileCoordinator removeFilePresenter:]`. If successful, pass nil to the completion handler. If not successful, or to prevent the eviction of the file, throw an error that encapsulates the reason. Implementations of this method must always invoke the completion handler because other parts of the system will wait until it is invoked or until the user loses patience and cancels the waiting. If this method is not implemented, eviction will fail.
      */
-    accommodatePresentedItemEvictionWithCompletionHandler$?(completionHandler: NobjcObject | null): void;
+    accommodatePresentedItemEvictionWithCompletionHandler$?(completionHandler: ((errorOrNil: _NSError) => void) | null): void;
     /**
      * Be notified that the file or directory has been moved or renamed, or a directory containing it has been moved or renamed. A typical implementation of this method will cause subsequent invocations of -presentedItemURL to return the new URL. The new URL may have a different file name extension than the current value of the presentedItemURL property. For example, NSDocument implements this method to handle document file moving and renaming. A shoebox application would only implement this method to be robust against surprising things like the user moving its data directory while the application is running. Not all programs use file coordination. Your NSFileProvider may be sent this message without being sent -relinquishPresentedItemToWriter: first. Make your application do the best it can in that case.
      */
@@ -45,7 +45,7 @@ export interface _NSFilePresenter {
     /**
      * Given that something in the system is waiting to delete a file or directory contained by the directory, do whatever it takes to ensure that the deleting will succeed and that the receiver's application will behave properly when the deleting has happened, and then invoke the completion handler. If successful (including when there is simply nothing to do) pass nil to the completion handler, or if not successful pass an NSError that encapsulates the reason why preparation failed. Implementations of this method must always invoke the completion handler because other parts of the system will wait until it is invoked or until the user loses patience and cancels the waiting. The file coordination mechanism does not always send -relinquishPresentedItemToReader: or -relinquishPresentedItemToWriter: to your NSFilePresenter before sending this message. For example, other process' use of -[NSFileCoordinator prepareForReadingItemsAtURLs:options:writingItemsAtURLs:options:error:byAccessor:] can cause this to happen.
      */
-    accommodatePresentedSubitemDeletionAtURL$completionHandler$?(url: _NSURL, completionHandler: NobjcObject | null): void;
+    accommodatePresentedSubitemDeletionAtURL$completionHandler$?(url: _NSURL, completionHandler: ((errorOrNil: _NSError) => void) | null): void;
     /**
      * Be notified that a file or directory contained by the directory has been added. If this method is not implemented but -presentedItemDidChange is, and the directory is actually a file package, then the file coordination machinery will invoke -presentedItemDidChange instead. Not all programs use file coordination. Your NSFileProvider may be sent this message without being sent -relinquishPresentedItemToWriter: first. Make your application do the best it can in that case.
      */

package/dist/Foundation/NSFileProviderService.d.ts

@@ -1,10 +1,11 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSError } from "./NSError.js";
 import type { _NSObject } from "./NSObject.js";
+import type { _NSXPCConnection } from "./NSXPCConnection.js";
 import type { NSFileProviderServiceName } from "./NSFileProviderServiceName.js";
 export declare class _NSFileProviderService extends _NSObject {
     static alloc(): _NSFileProviderService;
     static new(): _NSFileProviderService;
     init(): _NSFileProviderService;
-    getFileProviderConnectionWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    getFileProviderConnectionWithCompletionHandler$(completionHandler: ((connection: _NSXPCConnection, error: _NSError) => void) | null): void;
     name(): NSFileProviderServiceName;
 }

package/dist/Foundation/NSFileVersion.d.ts

@@ -2,6 +2,7 @@ import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
 import type { _NSCoding } from "./NSCoding.js";
 import type { _NSDate } from "./NSDate.js";
+import type { _NSError } from "./NSError.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSPersonNameComponents } from "./NSPersonNameComponents.js";
 import type { _NSString } from "./NSString.js";
@@ -27,7 +28,7 @@ export declare class _NSFileVersion extends _NSObject {
     /**
      * Asynchronously return an array of NSFileVersions associated with the file located by the given URL, or nil if there is no such file or another error occurs. Versions returned by this method do not initially have their contents stored locally on the device, so a download may be required before you are able to access them. File attributes are accessible via -[NSURL getPromisedItemResourceValue:forKey:error:]. You can request a download by performing a coordinated read with NSFileCoordinator on the URL property of the resulting NSFileVersions. When a version is successfully downloaded, its contents are cached locally, and the version will no longer be returned by this method. The version will be returned by +[NSFileVersion otherVersionsOfItemAtURL:] instead, but will retain the same persistentIdentifier value. If the local version is later discarded, future invocations of this method may resume returning the version. If you need to get all versions for a document, both local and non-local, you should use an NSFilePresenter that implements -presentedItemDidGainVersion: and -presentedItemDidLoseVersion: and invoke +[NSFileCoordinator addFilePresenter:], +[NSFileVersion otherVersionsOfItemAtURL:], and this method within a single coordinated read.
      */
-    static getNonlocalVersionsOfItemAtURL$completionHandler$(url: _NSURL, completionHandler: NobjcObject | null): void;
+    static getNonlocalVersionsOfItemAtURL$completionHandler$(url: _NSURL, completionHandler: ((nonlocalFileVersions: _NSArray, error: _NSError) => void) | null): void;
     /**
      * For a file located by a URL, return the NSFileVersion identified by a persistent identifier of the sort returned by -persistentIdentifier, or nil if the version no longer exists.
      */

package/dist/Foundation/NSHTTPCookieStorage.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
 import type { _NSDate } from "./NSDate.js";
 import type { _NSHTTPCookie } from "./NSHTTPCookie.js";
@@ -42,7 +41,7 @@ export declare class _NSHTTPCookieStorage extends _NSObject {
      */
     sortedCookiesUsingDescriptors$(sortOrder: _NSArray): _NSArray;
     storeCookies$forTask$(cookies: _NSArray, task: _NSURLSessionTask): void;
-    getCookiesForTask$completionHandler$(task: _NSURLSessionTask, completionHandler: NobjcObject | null): void;
+    getCookiesForTask$completionHandler$(task: _NSURLSessionTask, completionHandler: ((cookies: _NSArray) => void) | null): void;
     /** @abstract Get all the cookies @result An NSArray of NSHTTPCookies */
     cookies(): _NSArray | null;
     /** @abstract The cookie accept policy preference of the receiver. */

package/dist/Foundation/NSIndexSet.d.ts

@@ -29,21 +29,21 @@ export declare class _NSIndexSet extends _NSObject {
     containsIndexesInRange$(range: NSRange): boolean;
     containsIndexes$(indexSet: _NSIndexSet): boolean;
     intersectsIndexesInRange$(range: NSRange): boolean;
-    enumerateIndexesUsingBlock$(block: NobjcObject): void;
-    enumerateIndexesWithOptions$usingBlock$(opts: NSEnumerationOptions, block: NobjcObject): void;
-    enumerateIndexesInRange$options$usingBlock$(range: NSRange, opts: NSEnumerationOptions, block: NobjcObject): void;
-    indexPassingTest$(predicate: NobjcObject): number;
-    indexWithOptions$passingTest$(opts: NSEnumerationOptions, predicate: NobjcObject): number;
-    indexInRange$options$passingTest$(range: NSRange, opts: NSEnumerationOptions, predicate: NobjcObject): number;
-    indexesPassingTest$(predicate: NobjcObject): _NSIndexSet;
-    indexesWithOptions$passingTest$(opts: NSEnumerationOptions, predicate: NobjcObject): _NSIndexSet;
-    indexesInRange$options$passingTest$(range: NSRange, opts: NSEnumerationOptions, predicate: NobjcObject): _NSIndexSet;
+    enumerateIndexesUsingBlock$(block: (idx: number, stop: NobjcObject) => void): void;
+    enumerateIndexesWithOptions$usingBlock$(opts: NSEnumerationOptions, block: (idx: number, stop: NobjcObject) => void): void;
+    enumerateIndexesInRange$options$usingBlock$(range: NSRange, opts: NSEnumerationOptions, block: (idx: number, stop: NobjcObject) => void): void;
+    indexPassingTest$(predicate: (idx: number, stop: NobjcObject) => boolean): number;
+    indexWithOptions$passingTest$(opts: NSEnumerationOptions, predicate: (idx: number, stop: NobjcObject) => boolean): number;
+    indexInRange$options$passingTest$(range: NSRange, opts: NSEnumerationOptions, predicate: (idx: number, stop: NobjcObject) => boolean): number;
+    indexesPassingTest$(predicate: (idx: number, stop: NobjcObject) => boolean): _NSIndexSet;
+    indexesWithOptions$passingTest$(opts: NSEnumerationOptions, predicate: (idx: number, stop: NobjcObject) => boolean): _NSIndexSet;
+    indexesInRange$options$passingTest$(range: NSRange, opts: NSEnumerationOptions, predicate: (idx: number, stop: NobjcObject) => boolean): _NSIndexSet;
     /**
      * The following three convenience methods allow you to enumerate the indexes in the receiver by ranges of contiguous indexes. The performance of these methods is not guaranteed to be any better than if they were implemented with enumerateIndexesInRange:options:usingBlock:. However, depending on the receiver's implementation, they may perform better than that. If the specified range for enumeration intersects a range of contiguous indexes in the receiver, then the block will be invoked with the intersection of those two ranges.
      */
-    enumerateRangesUsingBlock$(block: NobjcObject): void;
-    enumerateRangesWithOptions$usingBlock$(opts: NSEnumerationOptions, block: NobjcObject): void;
-    enumerateRangesInRange$options$usingBlock$(range: NSRange, opts: NSEnumerationOptions, block: NobjcObject): void;
+    enumerateRangesUsingBlock$(block: (range: NSRange, stop: NobjcObject) => void): void;
+    enumerateRangesWithOptions$usingBlock$(opts: NSEnumerationOptions, block: (range: NSRange, stop: NobjcObject) => void): void;
+    enumerateRangesInRange$options$usingBlock$(range: NSRange, opts: NSEnumerationOptions, block: (range: NSRange, stop: NobjcObject) => void): void;
     count(): number;
     /**
      * The following six methods will return NSNotFound if there is no index in the set satisfying the query.

package/dist/Foundation/NSItemProvider.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 { _NSData } from "./NSData.js";
 import type { _NSDictionary } from "./NSDictionary.js";
+import type { _NSError } from "./NSError.js";
+import type { _NSItemProviderReading } from "./NSItemProviderReading.js";
 import type { _NSItemProviderWriting } from "./NSItemProviderWriting.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSProgress } from "./NSProgress.js";
@@ -15,11 +18,11 @@ export declare class _NSItemProvider extends _NSObject {
     static new(): _NSItemProvider;
     init(): _NSItemProvider;
     /** Registers a data-backed representation. */
-    registerDataRepresentationForTypeIdentifier$visibility$loadHandler$(typeIdentifier: _NSString, visibility: NSItemProviderRepresentationVisibility, loadHandler: NobjcObject | null): void;
+    registerDataRepresentationForTypeIdentifier$visibility$loadHandler$(typeIdentifier: _NSString, visibility: NSItemProviderRepresentationVisibility, loadHandler: ((arg0: (arg0: _NSData, arg1: _NSError) => void) => _NSProgress) | null): void;
     /**
      * Registers a file-backed representation. Set `coordinated` to YES if the returned file must be accessed using NSFileCoordinator. If `NSItemProviderFileOptionOpenInPlace` is not provided, the file provided will be copied before the load handler returns.
      */
-    registerFileRepresentationForTypeIdentifier$fileOptions$visibility$loadHandler$(typeIdentifier: _NSString, fileOptions: NSItemProviderFileOptions, visibility: NSItemProviderRepresentationVisibility, loadHandler: NobjcObject | null): void;
+    registerFileRepresentationForTypeIdentifier$fileOptions$visibility$loadHandler$(typeIdentifier: _NSString, fileOptions: NSItemProviderFileOptions, visibility: NSItemProviderRepresentationVisibility, loadHandler: ((arg0: (arg0: _NSURL, arg1: boolean, arg2: _NSError) => void) => _NSProgress) | null): void;
     registeredTypeIdentifiersWithFileOptions$(fileOptions: NSItemProviderFileOptions): _NSArray;
     /**
      * Returns YES if the item provider has at least one item that conforms to the supplied type identifier.
@@ -27,15 +30,15 @@ export declare class _NSItemProvider extends _NSObject {
     hasItemConformingToTypeIdentifier$(typeIdentifier: _NSString): boolean;
     hasRepresentationConformingToTypeIdentifier$fileOptions$(typeIdentifier: _NSString, fileOptions: NSItemProviderFileOptions): boolean;
     /** Copies the provided data into an NSData object. */
-    loadDataRepresentationForTypeIdentifier$completionHandler$(typeIdentifier: _NSString, completionHandler: NobjcObject | null): _NSProgress;
+    loadDataRepresentationForTypeIdentifier$completionHandler$(typeIdentifier: _NSString, completionHandler: ((data: _NSData, error: _NSError) => void) | null): _NSProgress;
     /**
      * Writes a copy of the data to a temporary file. This file will be deleted when the completion handler returns. Your program should copy or move the file within the completion handler.
      */
-    loadFileRepresentationForTypeIdentifier$completionHandler$(typeIdentifier: _NSString, completionHandler: NobjcObject | null): _NSProgress;
+    loadFileRepresentationForTypeIdentifier$completionHandler$(typeIdentifier: _NSString, completionHandler: ((url: _NSURL, error: _NSError) => void) | null): _NSProgress;
     /**
      * Open the original file in place, if possible. If a file is not available for opening in place, a copy of the file is written to a temporary location, and `isInPlace` is set to NO. Your program may then copy or move the file, or the system will delete this file at some point in the future.
      */
-    loadInPlaceFileRepresentationForTypeIdentifier$completionHandler$(typeIdentifier: _NSString, completionHandler: NobjcObject | null): _NSProgress;
+    loadInPlaceFileRepresentationForTypeIdentifier$completionHandler$(typeIdentifier: _NSString, completionHandler: ((url: _NSURL, isInPlace: boolean, error: _NSError) => void) | null): _NSProgress;
     /**
      * Instantiate an NSItemProvider by querying an object for its eligible type identifiers via the NSItemProviderWriting protocol.
      */
@@ -45,10 +48,10 @@ export declare class _NSItemProvider extends _NSObject {
      */
     registerObject$visibility$(object_: _NSItemProviderWriting, visibility: NSItemProviderRepresentationVisibility): void;
     /** Add representations from a class, but defer loading the object until needed. */
-    registerObjectOfClass$visibility$loadHandler$(aClass: NobjcObject, visibility: NSItemProviderRepresentationVisibility, loadHandler: NobjcObject | null): void;
+    registerObjectOfClass$visibility$loadHandler$(aClass: NobjcObject, visibility: NSItemProviderRepresentationVisibility, loadHandler: ((arg0: (arg0: _NSItemProviderWriting, arg1: _NSError) => void) => _NSProgress) | null): void;
     canLoadObjectOfClass$(aClass: NobjcObject): boolean;
     /** Instantiate an object using the NSItemProviderReading protocol. */
-    loadObjectOfClass$completionHandler$(aClass: NobjcObject, completionHandler: NobjcObject | null): _NSProgress;
+    loadObjectOfClass$completionHandler$(aClass: NobjcObject, completionHandler: ((object: _NSItemProviderReading, error: _NSError) => void) | null): _NSProgress;
     /**
      * Initialize an NSItemProvider with an object assigned to a single UTI. `item` is retained.
      */
@@ -58,15 +61,15 @@ export declare class _NSItemProvider extends _NSObject {
      */
     initWithContentsOfURL$(fileURL: _NSURL): _NSItemProvider | null;
     /** Registers a load handler that returns an object, assigned to a single UTI. */
-    registerItemForTypeIdentifier$loadHandler$(typeIdentifier: _NSString, loadHandler: NobjcObject): void;
+    registerItemForTypeIdentifier$loadHandler$(typeIdentifier: _NSString, loadHandler: (arg0: (arg0: _NSSecureCoding, arg1: _NSError) => void, arg1: NobjcObject, arg2: _NSDictionary) => void): void;
     /**
      * Loads the best matching item for a type identifier. The returned object depends on the class specified for the completion handler's `item` parameter. See the table above for coercion rules.
      */
-    loadItemForTypeIdentifier$options$completionHandler$(typeIdentifier: _NSString, options: _NSDictionary | null, completionHandler: NobjcObject | null): void;
+    loadItemForTypeIdentifier$options$completionHandler$(typeIdentifier: _NSString, options: _NSDictionary | null, completionHandler: ((arg0: _NSSecureCoding, arg1: _NSError) => void) | null): void;
     /**
      * Loads the preview image for this item by either calling the supplied preview block or falling back to a QuickLook-based handler. This method, like loadItemForTypeIdentifier:options:completionHandler:, supports implicit type coercion for the item parameter of the completion block. Allowed value classes are: NSData, NSURL, UIImage/NSImage.
      */
-    loadPreviewImageWithOptions$completionHandler$(options: _NSDictionary, completionHandler: NobjcObject): void;
+    loadPreviewImageWithOptions$completionHandler$(options: _NSDictionary, completionHandler: (arg0: _NSSecureCoding, arg1: _NSError) => void): void;
     /**
      * Returns the list of registered type identifiers, in the order they were registered.
      */
@@ -76,8 +79,8 @@ export declare class _NSItemProvider extends _NSObject {
     /**
      * Sets a custom preview image handler block for this item provider. The returned item should preferably be NSData or a file NSURL.
      */
-    previewImageHandler(): NobjcObject | null;
-    setPreviewImageHandler$(value: NobjcObject | null): void;
+    previewImageHandler(): ((arg0: (arg0: _NSSecureCoding, arg1: _NSError) => void, arg1: NobjcObject, arg2: _NSDictionary) => void) | null;
+    setPreviewImageHandler$(value: ((arg0: (arg0: _NSSecureCoding, arg1: _NSError) => void, arg1: NobjcObject, arg2: _NSDictionary) => void) | null): void;
 }
 export interface _NSItemProvider extends _NSCopying {
 }

package/dist/Foundation/NSItemProviderWriting.d.ts

@@ -1,9 +1,10 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSData } from "./NSData.js";
+import type { _NSError } from "./NSError.js";
 import type { _NSProgress } from "./NSProgress.js";
 import type { _NSString } from "./NSString.js";
 import type { NSItemProviderRepresentationVisibility } from "./NSItemProviderRepresentationVisibility.js";
 export interface _NSItemProviderWriting {
     /** If this method is not implemented, the class method will be consulted instead. */
     itemProviderVisibilityForRepresentationWithTypeIdentifier$?(typeIdentifier: _NSString): NSItemProviderRepresentationVisibility;
-    loadDataWithTypeIdentifier$forItemProviderCompletionHandler$?(typeIdentifier: _NSString, completionHandler: NobjcObject | null): _NSProgress | null;
+    loadDataWithTypeIdentifier$forItemProviderCompletionHandler$?(typeIdentifier: _NSString, completionHandler: ((data: _NSData, error: _NSError) => void) | null): _NSProgress | null;
 }

package/dist/Foundation/NSLinguisticTagger.d.ts

@@ -38,7 +38,7 @@ export declare class _NSLinguisticTagger extends _NSObject {
     /**
      * @deprecated All NSLinguisticTagger API should be replaced with NaturalLanguage.framework API
      */
-    static enumerateTagsForString$range$unit$scheme$options$orthography$usingBlock$(string_: _NSString, range: NSRange, unit: NSLinguisticTaggerUnit, scheme: NSLinguisticTagScheme, options: NSLinguisticTaggerOptions, orthography: _NSOrthography | null, block: NobjcObject | null): void;
+    static enumerateTagsForString$range$unit$scheme$options$orthography$usingBlock$(string_: _NSString, range: NSRange, unit: NSLinguisticTaggerUnit, scheme: NSLinguisticTagScheme, options: NSLinguisticTaggerOptions, orthography: _NSOrthography | null, block: ((tag: NSLinguisticTag, tokenRange: NSRange, stop: NobjcObject) => void) | null): void;
     /**
      * An instance of NSLinguisticTagger is created with an array of tag schemes. The tagger will be able to supply tags corresponding to any of the schemes in this array.
      * @deprecated All NSLinguisticTagger API should be replaced with NaturalLanguage.framework API
@@ -72,7 +72,7 @@ export declare class _NSLinguisticTagger extends _NSObject {
      * The tagger will segment the string as needed into tokens for the given unit, and return those ranges along with a tag for any scheme in its array of tag schemes. The fundamental tagging method on NSLinguisticTagger is a block iterator, that iterates over all tokens intersecting a given range, supplying tags and ranges. There are several additional convenience methods, for obtaining a sentence range, information about a single token, or for obtaining information about all tokens intersecting a given range at once, in arrays. In each case, the charIndex or range passed in must not extend beyond the end of the tagger's string, or the methods will raise an exception. Note that a given instance of NSLinguisticTagger should not be used from more than one thread simultaneously.
      * @deprecated All NSLinguisticTagger API should be replaced with NaturalLanguage.framework API
      */
-    enumerateTagsInRange$unit$scheme$options$usingBlock$(range: NSRange, unit: NSLinguisticTaggerUnit, scheme: NSLinguisticTagScheme, options: NSLinguisticTaggerOptions, block: NobjcObject | null): void;
+    enumerateTagsInRange$unit$scheme$options$usingBlock$(range: NSRange, unit: NSLinguisticTaggerUnit, scheme: NSLinguisticTagScheme, options: NSLinguisticTaggerOptions, block: ((tag: NSLinguisticTag, tokenRange: NSRange, stop: NobjcObject) => void) | null): void;
     /**
      * @deprecated All NSLinguisticTagger API should be replaced with NaturalLanguage.framework API
      */
@@ -85,7 +85,7 @@ export declare class _NSLinguisticTagger extends _NSObject {
      * Methods that do not specify a unit act at the word level.
      * @deprecated All NSLinguisticTagger API should be replaced with NaturalLanguage.framework API
      */
-    enumerateTagsInRange$scheme$options$usingBlock$(range: NSRange, tagScheme: NSLinguisticTagScheme, opts: NSLinguisticTaggerOptions, block: NobjcObject | null): void;
+    enumerateTagsInRange$scheme$options$usingBlock$(range: NSRange, tagScheme: NSLinguisticTagScheme, opts: NSLinguisticTaggerOptions, block: ((tag: NSLinguisticTag, tokenRange: NSRange, sentenceRange: NSRange, stop: NobjcObject) => void) | null): void;
     /**
      * @deprecated All NSLinguisticTagger API should be replaced with NaturalLanguage.framework API
      */

package/dist/Foundation/NSMetadataQuery.d.ts

@@ -18,8 +18,8 @@ export declare class _NSMetadataQuery extends _NSObject {
     disableUpdates(): void;
     enableUpdates(): void;
     resultAtIndex$(idx: number): NobjcObject;
-    enumerateResultsUsingBlock$(block: NobjcObject): void;
-    enumerateResultsWithOptions$usingBlock$(opts: NSEnumerationOptions, block: NobjcObject): void;
+    enumerateResultsUsingBlock$(block: (result: NobjcObject, idx: number, stop: NobjcObject) => void): void;
+    enumerateResultsWithOptions$usingBlock$(opts: NSEnumerationOptions, block: (result: NobjcObject, idx: number, stop: NobjcObject) => void): void;
     indexOfResult$(result: NobjcObject): number;
     valueOfAttribute$forResultAtIndex$(attrName: _NSString, idx: number): NobjcObject | null;
     delegate(): _NSMetadataQueryDelegate | null;

package/dist/Foundation/NSMutableArray.d.ts

@@ -47,8 +47,8 @@ export declare class _NSMutableArray extends _NSArray {
     removeObjectsAtIndexes$(indexes: _NSIndexSet): void;
     replaceObjectsAtIndexes$withObjects$(indexes: _NSIndexSet, objects: _NSArray): void;
     setObject$atIndexedSubscript$(obj: NobjcObject, idx: number): void;
-    sortUsingComparator$(cmptr: NobjcObject): void;
-    sortWithOptions$usingComparator$(opts: NSSortOptions, cmptr: NobjcObject): void;
+    sortUsingComparator$(cmptr: (arg0: NobjcObject, arg1: NobjcObject) => number): void;
+    sortWithOptions$usingComparator$(opts: NSSortOptions, cmptr: (arg0: NobjcObject, arg1: NobjcObject) => number): void;
     initWithContentsOfFile$(path: _NSString): _NSMutableArray | null;
     initWithContentsOfURL$(url: _NSURL): _NSMutableArray | null;
     applyDifference$(difference: _NSOrderedCollectionDifference): void;

package/dist/Foundation/NSMutableOrderedSet.d.ts

@@ -39,9 +39,9 @@ export declare class _NSMutableOrderedSet extends _NSOrderedSet {
     intersectSet$(other: _NSSet): void;
     minusSet$(other: _NSSet): void;
     unionSet$(other: _NSSet): void;
-    sortUsingComparator$(cmptr: NobjcObject): void;
-    sortWithOptions$usingComparator$(opts: NSSortOptions, cmptr: NobjcObject): void;
-    sortRange$options$usingComparator$(range: NSRange, opts: NSSortOptions, cmptr: NobjcObject): void;
+    sortUsingComparator$(cmptr: (arg0: NobjcObject, arg1: NobjcObject) => number): void;
+    sortWithOptions$usingComparator$(opts: NSSortOptions, cmptr: (arg0: NobjcObject, arg1: NobjcObject) => number): void;
+    sortRange$options$usingComparator$(range: NSRange, opts: NSSortOptions, cmptr: (arg0: NobjcObject, arg1: NobjcObject) => number): void;
     applyDifference$(difference: _NSOrderedCollectionDifference): void;
     /** sorts the ordered set itself */
     sortUsingDescriptors$(sortDescriptors: _NSArray): void;

package/dist/Foundation/NSNotificationCenter.d.ts

@@ -15,5 +15,5 @@ export declare class _NSNotificationCenter extends _NSObject {
     postNotificationName$object$userInfo$(aName: _NSString, anObject: NobjcObject | null, aUserInfo: _NSDictionary | null): void;
     removeObserver$(observer: NobjcObject): void;
     removeObserver$name$object$(observer: NobjcObject, aName: _NSString | null, anObject: NobjcObject | null): void;
-    addObserverForName$object$queue$usingBlock$(name: _NSString | null, obj: NobjcObject | null, queue: _NSOperationQueue | null, block: NobjcObject): _NSObject;
+    addObserverForName$object$queue$usingBlock$(name: _NSString | null, obj: NobjcObject | null, queue: _NSOperationQueue | null, block: (notification: _NSNotification) => void): _NSObject;
 }

package/dist/Foundation/NSOperation.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSString } from "./NSString.js";
@@ -26,8 +25,8 @@ export declare class _NSOperation extends _NSObject {
     queuePriority(): NSOperationQueuePriority;
     setQueuePriority$(value: NSOperationQueuePriority): void;
     /** @deprecated Not supported */
-    completionBlock(): NobjcObject | null;
-    setCompletionBlock$(value: NobjcObject | null): void;
+    completionBlock(): (() => void) | null;
+    setCompletionBlock$(value: (() => void) | null): void;
     /** @deprecated Not supported */
     threadPriority(): number;
     setThreadPriority$(value: number): void;

package/dist/Foundation/NSOperationQueue.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSOperation } from "./NSOperation.js";
@@ -13,11 +12,11 @@ export declare class _NSOperationQueue extends _NSObject {
     static mainQueue(): _NSOperationQueue;
     addOperation$(op: _NSOperation): void;
     addOperations$waitUntilFinished$(ops: _NSArray, wait: boolean): void;
-    addOperationWithBlock$(block: NobjcObject): void;
+    addOperationWithBlock$(block: () => void): void;
     /**
      * @method addBarrierBlock: @param barrier A block to execute @discussion The `addBarrierBlock:` method executes the block when the NSOperationQueue has finished all enqueued operations and prevents any subsequent operations to be executed until the barrier has been completed. This acts similarly to the `dispatch_barrier_async` function.
      */
-    addBarrierBlock$(barrier: NobjcObject): void;
+    addBarrierBlock$(barrier: () => void): void;
     cancelAllOperations(): void;
     waitUntilAllOperationsAreFinished(): void;
     /**

package/dist/Foundation/NSOrderedCollectionDifference.d.ts

@@ -1,8 +1,8 @@
-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";
+import type { _NSOrderedCollectionChange } from "./NSOrderedCollectionChange.js";
 export declare class _NSOrderedCollectionDifference extends _NSObject {
     static alloc(): _NSOrderedCollectionDifference;
     static new(): _NSOrderedCollectionDifference;
@@ -14,7 +14,7 @@ export declare class _NSOrderedCollectionDifference extends _NSObject {
     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;
+    differenceByTransformingChangesWithBlock$(block: (arg0: _NSOrderedCollectionChange) => _NSOrderedCollectionChange): _NSOrderedCollectionDifference;
     /**
      * 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.
      */

package/dist/Foundation/NSOrderedSet.d.ts

@@ -46,19 +46,19 @@ export declare class _NSOrderedSet extends _NSObject {
     objectAtIndexedSubscript$(idx: number): NobjcObject;
     objectEnumerator(): _NSEnumerator;
     reverseObjectEnumerator(): _NSEnumerator;
-    enumerateObjectsUsingBlock$(block: NobjcObject): void;
-    enumerateObjectsWithOptions$usingBlock$(opts: NSEnumerationOptions, block: NobjcObject): void;
-    enumerateObjectsAtIndexes$options$usingBlock$(s: _NSIndexSet, opts: NSEnumerationOptions, block: NobjcObject): void;
-    indexOfObjectPassingTest$(predicate: NobjcObject): number;
-    indexOfObjectWithOptions$passingTest$(opts: NSEnumerationOptions, predicate: NobjcObject): number;
-    indexOfObjectAtIndexes$options$passingTest$(s: _NSIndexSet, opts: NSEnumerationOptions, predicate: NobjcObject): number;
-    indexesOfObjectsPassingTest$(predicate: NobjcObject): _NSIndexSet;
-    indexesOfObjectsWithOptions$passingTest$(opts: NSEnumerationOptions, predicate: NobjcObject): _NSIndexSet;
-    indexesOfObjectsAtIndexes$options$passingTest$(s: _NSIndexSet, opts: NSEnumerationOptions, predicate: NobjcObject): _NSIndexSet;
+    enumerateObjectsUsingBlock$(block: (obj: NobjcObject, idx: number, stop: NobjcObject) => void): void;
+    enumerateObjectsWithOptions$usingBlock$(opts: NSEnumerationOptions, block: (obj: NobjcObject, idx: number, stop: NobjcObject) => void): void;
+    enumerateObjectsAtIndexes$options$usingBlock$(s: _NSIndexSet, opts: NSEnumerationOptions, block: (obj: NobjcObject, idx: number, stop: NobjcObject) => void): void;
+    indexOfObjectPassingTest$(predicate: (obj: NobjcObject, idx: number, stop: NobjcObject) => boolean): number;
+    indexOfObjectWithOptions$passingTest$(opts: NSEnumerationOptions, predicate: (obj: NobjcObject, idx: number, stop: NobjcObject) => boolean): number;
+    indexOfObjectAtIndexes$options$passingTest$(s: _NSIndexSet, opts: NSEnumerationOptions, predicate: (obj: NobjcObject, idx: number, stop: NobjcObject) => boolean): number;
+    indexesOfObjectsPassingTest$(predicate: (obj: NobjcObject, idx: number, stop: NobjcObject) => boolean): _NSIndexSet;
+    indexesOfObjectsWithOptions$passingTest$(opts: NSEnumerationOptions, predicate: (obj: NobjcObject, idx: number, stop: NobjcObject) => boolean): _NSIndexSet;
+    indexesOfObjectsAtIndexes$options$passingTest$(s: _NSIndexSet, opts: NSEnumerationOptions, predicate: (obj: NobjcObject, idx: number, stop: NobjcObject) => boolean): _NSIndexSet;
     /** binary search */
-    indexOfObject$inSortedRange$options$usingComparator$(object_: NobjcObject, range: NSRange, opts: NSBinarySearchingOptions, cmp: NobjcObject): number;
-    sortedArrayUsingComparator$(cmptr: NobjcObject): _NSArray;
-    sortedArrayWithOptions$usingComparator$(opts: NSSortOptions, cmptr: NobjcObject): _NSArray;
+    indexOfObject$inSortedRange$options$usingComparator$(object_: NobjcObject, range: NSRange, opts: NSBinarySearchingOptions, cmp: (arg0: NobjcObject, arg1: NobjcObject) => number): number;
+    sortedArrayUsingComparator$(cmptr: (arg0: NobjcObject, arg1: NobjcObject) => number): _NSArray;
+    sortedArrayWithOptions$usingComparator$(opts: NSSortOptions, cmptr: (arg0: NobjcObject, arg1: NobjcObject) => number): _NSArray;
     descriptionWithLocale$(locale: NobjcObject | null): _NSString;
     descriptionWithLocale$indent$(locale: NobjcObject | null, level: number): _NSString;
     initWithObject$(object_: NobjcObject): _NSOrderedSet;
@@ -71,7 +71,7 @@ export declare class _NSOrderedSet extends _NSObject {
     initWithArray$range$copyItems$(set: _NSArray, range: NSRange, flag: boolean): _NSOrderedSet;
     initWithSet$(set: _NSSet): _NSOrderedSet;
     initWithSet$copyItems$(set: _NSSet, flag: boolean): _NSOrderedSet;
-    differenceFromOrderedSet$withOptions$usingEquivalenceTest$(other: _NSOrderedSet, options: NSOrderedCollectionDifferenceCalculationOptions, block: NobjcObject): _NSOrderedCollectionDifference;
+    differenceFromOrderedSet$withOptions$usingEquivalenceTest$(other: _NSOrderedSet, options: NSOrderedCollectionDifferenceCalculationOptions, block: (obj1: NobjcObject, obj2: NobjcObject) => boolean): _NSOrderedCollectionDifference;
     differenceFromOrderedSet$withOptions$(other: _NSOrderedSet, options: NSOrderedCollectionDifferenceCalculationOptions): _NSOrderedCollectionDifference;
     /**
      * Uses isEqual: to determine the difference between the parameter and the receiver

package/dist/Foundation/NSPredicate.d.ts

@@ -16,7 +16,7 @@ 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 | null): _NSPredicate;
+    static predicateWithBlock$(block: ((evaluatedObject: NobjcObject, bindings: _NSDictionary) => boolean) | null): _NSPredicate;
     /** substitute constant values for variables */
     predicateWithSubstitutionVariables$(variables: _NSDictionary): _NSPredicate;
     /** evaluate a predicate against a single object */

package/dist/Foundation/NSProcessInfo.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
 import type { _NSDictionary } from "./NSDictionary.js";
 import type { _NSObject } from "./NSObject.js";
@@ -39,11 +38,11 @@ export declare class _NSProcessInfo extends _NSObject {
     /**
      * Synchronously perform an activity. The activity will be automatically ended after your block argument returns. The reason string is used for debugging.
      */
-    performActivityWithOptions$reason$usingBlock$(options: NSActivityOptions, reason: _NSString, block: NobjcObject): void;
+    performActivityWithOptions$reason$usingBlock$(options: NSActivityOptions, reason: _NSString, block: () => void): void;
     /**
      * Perform an expiring background task, which obtains an expiring task assertion on iOS. The block contains any work which needs to be completed as a background-priority task. The block will be scheduled on a system-provided concurrent queue. After a system-specified time, the block will be called with the `expired` parameter set to YES. The `expired` parameter will also be YES if the system decides to prematurely terminate a previous non-expiration invocation of the block.
      */
-    performExpiringActivityWithReason$usingBlock$(reason: _NSString, block: NobjcObject): void;
+    performExpiringActivityWithReason$usingBlock$(reason: _NSString, block: (expired: boolean) => void): void;
     environment(): _NSDictionary;
     arguments(): _NSArray;
     hostName(): _NSString;

package/dist/Foundation/NSProgress.d.ts

@@ -30,7 +30,7 @@ export declare class _NSProgress extends _NSObject {
     /**
      * Register to hear about file progress. The passed-in block will be invoked when -publish has been sent to an NSProgress whose NSProgressFileURLKey user info dictionary entry is an NSURL locating the same item located by the passed-in NSURL, or an item directly contained by it. The NSProgress passed to your block will be a proxy of the one that was published. The passed-in block may return another block. If it does, then that returned block will be invoked when the corresponding invocation of -unpublish is made, or the publishing process terminates, or +removeSubscriber: is invoked. Your blocks will be invoked on the main thread.
      */
-    static addSubscriberForFileURL$withPublishingHandler$(url: _NSURL, publishingHandler: NobjcObject): NobjcObject;
+    static addSubscriberForFileURL$withPublishingHandler$(url: _NSURL, publishingHandler: (arg0: _NSProgress) => () => void): NobjcObject;
     /**
      * Given the object returned by a previous invocation of -addSubscriberForFileURL:withPublishingHandler:, deregister.
      */
@@ -44,7 +44,7 @@ export declare class _NSProgress extends _NSObject {
      */
     becomeCurrentWithPendingUnitCount$(unitCount: number): void;
     /** Become current, do some work, then resign current. */
-    performAsCurrentWithPendingUnitCount$usingBlock$(unitCount: number, work: NobjcObject): void;
+    performAsCurrentWithPendingUnitCount$usingBlock$(unitCount: number, work: () => void): void;
     /**
      * Balance the most recent previous invocation of -becomeCurrentWithPendingUnitCount: on the same thread by restoring the current progress object to what it was before -becomeCurrentWithPendingUnitCount: was invoked.
      */
@@ -107,18 +107,18 @@ export declare class _NSProgress extends _NSObject {
     /**
      * A block to be invoked when cancel is invoked. The block will be invoked even when the method is invoked on an ancestor of the receiver, or an instance of NSProgress in another process that resulted from publishing the receiver or an ancestor of the receiver. Your block won't be invoked on any particular queue. If it must do work on a specific queue then it should schedule that work on that queue.
      */
-    cancellationHandler(): NobjcObject | null;
-    setCancellationHandler$(value: NobjcObject | null): void;
+    cancellationHandler(): (() => void) | null;
+    setCancellationHandler$(value: (() => void) | null): void;
     /**
      * A block to be invoked when pause is invoked. The block will be invoked even when the method is invoked on an ancestor of the receiver, or an instance of NSProgress in another process that resulted from publishing the receiver or an ancestor of the receiver. Your block won't be invoked on any particular queue. If it must do work on a specific queue then it should schedule that work on that queue.
      */
-    pausingHandler(): NobjcObject | null;
-    setPausingHandler$(value: NobjcObject | null): void;
+    pausingHandler(): (() => void) | null;
+    setPausingHandler$(value: (() => void) | null): void;
     /**
      * A block to be invoked when resume is invoked. The block will be invoked even when the method is invoked on an ancestor of the receiver, or an instance of NSProgress in another process that resulted from publishing the receiver or an ancestor of the receiver. Your block won't be invoked on any particular queue. If it must do work on a specific queue then it should schedule that work on that queue.
      */
-    resumingHandler(): NobjcObject | null;
-    setResumingHandler$(value: NobjcObject | null): void;
+    resumingHandler(): (() => void) | null;
+    setResumingHandler$(value: (() => void) | null): void;
     /**
      * Whether the progress being made is indeterminate. -isIndeterminate returns YES when the value of the totalUnitCount or completedUnitCount property is less than zero. Zero values for both of those properties indicates that there turned out to not be any work to do after all; -isIndeterminate returns NO and -fractionCompleted returns 1.0 in that case. NSProgress is by default KVO-compliant for these properties, with the notifications always being sent on the thread which updates the property.
      */

package/dist/Foundation/NSRegularExpression.d.ts

@@ -7,6 +7,7 @@ import type { _NSSecureCoding } from "./NSSecureCoding.js";
 import type { _NSString } from "./NSString.js";
 import type { _NSTextCheckingResult } from "./NSTextCheckingResult.js";
 import type { NSRange } from "../structs/NSRange.js";
+import type { NSMatchingFlags } from "./NSMatchingFlags.js";
 import type { NSMatchingOptions } from "./NSMatchingOptions.js";
 import type { NSRegularExpressionOptions } from "./NSRegularExpressionOptions.js";
 export declare class _NSRegularExpression extends _NSObject {
@@ -29,7 +30,7 @@ export declare class _NSRegularExpression extends _NSObject {
     /**
      * The fundamental matching method on NSRegularExpression is a block iterator. There are several additional convenience methods, for returning all matches at once, the number of matches, the first match, or the range of the first match. Each match is specified by an instance of NSTextCheckingResult (of type NSTextCheckingTypeRegularExpression) in which the overall match range is given by the range property (equivalent to rangeAtIndex:0) and any capture group ranges are given by rangeAtIndex: for indexes from 1 to numberOfCaptureGroups. {NSNotFound, 0} is used if a particular capture group does not participate in the match.
      */
-    enumerateMatchesInString$options$range$usingBlock$(string_: _NSString, options: NSMatchingOptions, range: NSRange, block: NobjcObject | null): void;
+    enumerateMatchesInString$options$range$usingBlock$(string_: _NSString, options: NSMatchingOptions, range: NSRange, block: ((result: _NSTextCheckingResult, flags: NSMatchingFlags, stop: NobjcObject) => void) | null): void;
     matchesInString$options$range$(string_: _NSString, options: NSMatchingOptions, range: NSRange): _NSArray;
     numberOfMatchesInString$options$range$(string_: _NSString, options: NSMatchingOptions, range: NSRange): number;
     firstMatchInString$options$range$(string_: _NSString, options: NSMatchingOptions, range: NSRange): _NSTextCheckingResult | null;