objcjs-types 0.4.0 → 0.5.0

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;

package/dist/Foundation/NSRunLoop.d.ts

@@ -27,11 +27,11 @@ export declare class _NSRunLoop extends _NSObject {
     /**
      * Schedules the execution of a block on the target run loop in given modes. - parameter: modes An array of input modes for which the block may be executed. - parameter: block The block to execute
      */
-    performInModes$block$(modes: _NSArray, block: NobjcObject): void;
+    performInModes$block$(modes: _NSArray, block: () => void): void;
     /**
      * Schedules the execution of a block on the target run loop. - parameter: block The block to execute
      */
-    performBlock$(block: NobjcObject): void;
+    performBlock$(block: () => void): void;
     performSelector$target$argument$order$modes$(aSelector: string, target: NobjcObject, arg: NobjcObject | null, order: number, modes: _NSArray): void;
     cancelPerformSelector$target$argument$(aSelector: string, target: NobjcObject, arg: NobjcObject | null): void;
     cancelPerformSelectorsWithTarget$(target: NobjcObject): void;

package/dist/Foundation/NSSet.d.ts

@@ -35,10 +35,10 @@ export declare class _NSSet extends _NSObject {
     setByAddingObject$(anObject: NobjcObject): _NSSet;
     setByAddingObjectsFromSet$(other: _NSSet): _NSSet;
     setByAddingObjectsFromArray$(other: _NSArray): _NSSet;
-    enumerateObjectsUsingBlock$(block: NobjcObject): void;
-    enumerateObjectsWithOptions$usingBlock$(opts: NSEnumerationOptions, block: NobjcObject): void;
-    objectsPassingTest$(predicate: NobjcObject): _NSSet;
-    objectsWithOptions$passingTest$(opts: NSEnumerationOptions, predicate: NobjcObject): _NSSet;
+    enumerateObjectsUsingBlock$(block: (obj: NobjcObject, stop: NobjcObject) => void): void;
+    enumerateObjectsWithOptions$usingBlock$(opts: NSEnumerationOptions, block: (obj: NobjcObject, stop: NobjcObject) => void): void;
+    objectsPassingTest$(predicate: (obj: NobjcObject, stop: NobjcObject) => boolean): _NSSet;
+    objectsWithOptions$passingTest$(opts: NSEnumerationOptions, predicate: (obj: NobjcObject, stop: NobjcObject) => boolean): _NSSet;
     initWithObjects$(firstObj: NobjcObject): _NSSet;
     initWithSet$(set: _NSSet): _NSSet;
     initWithSet$copyItems$(set: _NSSet, flag: boolean): _NSSet;

package/dist/Foundation/NSSortDescriptor.d.ts

@@ -9,14 +9,14 @@ export declare class _NSSortDescriptor extends _NSObject {
     init(): _NSSortDescriptor;
     static sortDescriptorWithKey$ascending$(key: _NSString | null, ascending: boolean): _NSSortDescriptor;
     static sortDescriptorWithKey$ascending$selector$(key: _NSString | null, ascending: boolean, selector: string | null): _NSSortDescriptor;
-    static sortDescriptorWithKey$ascending$comparator$(key: _NSString | null, ascending: boolean, cmptr: NobjcObject): _NSSortDescriptor;
+    static sortDescriptorWithKey$ascending$comparator$(key: _NSString | null, ascending: boolean, cmptr: (arg0: NobjcObject, arg1: NobjcObject) => number): _NSSortDescriptor;
     /** keys may be key paths */
     initWithKey$ascending$(key: _NSString | null, ascending: boolean): _NSSortDescriptor;
     initWithKey$ascending$selector$(key: _NSString | null, ascending: boolean, selector: string | null): _NSSortDescriptor;
     initWithCoder$(coder: _NSCoder): _NSSortDescriptor | null;
     /** Force a sort descriptor which was securely decoded to allow evaluation */
     allowEvaluation(): void;
-    initWithKey$ascending$comparator$(key: _NSString | null, ascending: boolean, cmptr: NobjcObject): _NSSortDescriptor;
+    initWithKey$ascending$comparator$(key: _NSString | null, ascending: boolean, cmptr: (arg0: NobjcObject, arg1: NobjcObject) => number): _NSSortDescriptor;
     /**
      * primitive - override this method if you want to perform comparisons differently (not key based for example)
      */
@@ -24,7 +24,7 @@ export declare class _NSSortDescriptor extends _NSObject {
     key(): _NSString | null;
     ascending(): boolean;
     selector(): string | null;
-    comparator(): NobjcObject;
+    comparator(): (arg0: NobjcObject, arg1: NobjcObject) => number;
     /**
      * primitive - override this method to return a sort descriptor instance with reversed sort order
      */

package/dist/Foundation/NSString.d.ts

@@ -13,6 +13,7 @@ import type { _NSObject } from "./NSObject.js";
 import type { _NSOrthography } from "./NSOrthography.js";
 import type { _NSURL } from "./NSURL.js";
 import type { NSRange } from "../structs/NSRange.js";
+import type { NSLinguisticTag } from "./NSLinguisticTag.js";
 import type { NSLinguisticTagScheme } from "./NSLinguisticTagScheme.js";
 import type { NSLinguisticTaggerOptions } from "./NSLinguisticTaggerOptions.js";
 import type { NSStringCompareOptions } from "./NSStringCompareOptions.js";
@@ -134,8 +135,8 @@ export declare class _NSString extends _NSObject {
     /**
      * In the enumerate methods, the blocks will be invoked inside an autorelease pool, so any values assigned inside the block should be retained.
      */
-    enumerateSubstringsInRange$options$usingBlock$(range: NSRange, opts: NSStringEnumerationOptions, block: NobjcObject | null): void;
-    enumerateLinesUsingBlock$(block: NobjcObject): void;
+    enumerateSubstringsInRange$options$usingBlock$(range: NSRange, opts: NSStringEnumerationOptions, block: ((substring: _NSString, substringRange: NSRange, enclosingRange: NSRange, stop: NobjcObject) => void) | null): void;
+    enumerateLinesUsingBlock$(block: (line: _NSString, stop: NobjcObject) => void): void;
     /** External representation */
     dataUsingEncoding$allowLossyConversion$(encoding: number, lossy: boolean): _NSData | null;
     /** External representation */
@@ -193,7 +194,7 @@ export declare class _NSString extends _NSObject {
     /**
      * - (instancetype)initWithCharactersNoCopy:(unichar *)characters length:(NSUInteger)length freeWhenDone:(BOOL)freeBuffer; "NoCopy" is a hint
      */
-    initWithCharactersNoCopy$length$deallocator$(chars: NobjcObject, len: number, deallocator: NobjcObject | null): _NSString;
+    initWithCharactersNoCopy$length$deallocator$(chars: NobjcObject, len: number, deallocator: ((arg0: NobjcObject, arg1: number) => void) | null): _NSString;
     initWithCharacters$length$(characters: NobjcObject, length: number): _NSString;
     initWithUTF8String$(nullTerminatedCString: string): _NSString | null;
     initWithString$(aString: _NSString): _NSString;
@@ -211,7 +212,7 @@ export declare class _NSString extends _NSObject {
     /**
      * - (nullable instancetype)initWithBytesNoCopy:(void *)bytes length:(NSUInteger)len encoding:(NSStringEncoding)encoding freeWhenDone:(BOOL)freeBuffer; "NoCopy" is a hint
      */
-    initWithBytesNoCopy$length$encoding$deallocator$(bytes: Uint8Array, len: number, encoding: number, deallocator: NobjcObject | null): _NSString | null;
+    initWithBytesNoCopy$length$encoding$deallocator$(bytes: Uint8Array, len: number, encoding: number, deallocator: ((arg0: NobjcObject, arg1: number) => void) | null): _NSString | null;
     initWithCString$encoding$(nullTerminatedCString: string, encoding: number): _NSString | null;
     /**
      * These use the specified encoding. If nil is returned, the optional error return indicates problem that was encountered (for instance, file system or encoding errors).
@@ -290,7 +291,7 @@ export declare class _NSString extends _NSObject {
     /**
      * @deprecated All NSLinguisticTagger API should be replaced with NaturalLanguage.framework API
      */
-    enumerateLinguisticTagsInRange$scheme$options$orthography$usingBlock$(range: NSRange, scheme: NSLinguisticTagScheme, options: NSLinguisticTaggerOptions, orthography: _NSOrthography | null, block: NobjcObject | null): void;
+    enumerateLinguisticTagsInRange$scheme$options$orthography$usingBlock$(range: NSRange, scheme: NSLinguisticTagScheme, options: NSLinguisticTaggerOptions, orthography: _NSOrthography | null, block: ((tag: NSLinguisticTag, tokenRange: NSRange, sentenceRange: NSRange, stop: NobjcObject) => void) | null): void;
     /**
      * NSString primitives. A minimal subclass of NSString just needs to implement these two, along with an init method appropriate for that subclass. We also recommend overriding getCharacters:range: for performance.
      */

package/dist/Foundation/NSTask.d.ts

@@ -10,7 +10,7 @@ import type { NSTaskTerminationReason } from "./NSTaskTerminationReason.js";
 export declare class _NSTask extends _NSObject {
     static alloc(): _NSTask;
     static new(): _NSTask;
-    static launchedTaskWithExecutableURL$arguments$error$terminationHandler$(url: _NSURL, arguments_: _NSArray, error: NobjcObject | null, terminationHandler: NobjcObject | null): _NSTask | null;
+    static launchedTaskWithExecutableURL$arguments$error$terminationHandler$(url: _NSURL, arguments_: _NSArray, error: NobjcObject | null, terminationHandler: ((arg0: _NSTask) => void) | null): _NSTask | null;
     /** @deprecated launchedTaskWithExecutableURL:arguments:error: */
     static launchedTaskWithLaunchPath$arguments$(path: _NSString, arguments_: _NSArray): _NSTask;
     /**
@@ -55,8 +55,8 @@ export declare class _NSTask extends _NSObject {
     /**
      * A block to be invoked when the process underlying the NSTask terminates. Setting the block to nil is valid, and stops the previous block from being invoked, as long as it hasn't started in any way. The NSTask is passed as the argument to the block so the block does not have to capture, and thus retain, it. The block is copied when set. Only one termination handler block can be set at any time. The execution context in which the block is invoked is undefined. If the NSTask has already finished, the block is executed immediately/soon (not necessarily on the current thread). If a terminationHandler is set on an NSTask, the NSTaskDidTerminateNotification notification is not posted for that task. Also note that -waitUntilExit won't wait until the terminationHandler has been fully executed. You cannot use this property in a concrete subclass of NSTask which hasn't been updated to include an implementation of the storage and use of it.
      */
-    terminationHandler(): NobjcObject;
-    setTerminationHandler$(value: NobjcObject): void;
+    terminationHandler(): (arg0: _NSTask) => void;
+    setTerminationHandler$(value: (arg0: _NSTask) => void): void;
     /** read-only after the task is launched */
     qualityOfService(): NSQualityOfService;
     setQualityOfService$(value: NSQualityOfService): void;

package/dist/Foundation/NSThread.d.ts

@@ -8,7 +8,7 @@ import type { NSQualityOfService } from "./NSQualityOfService.js";
 export declare class _NSThread extends _NSObject {
     static alloc(): _NSThread;
     static new(): _NSThread;
-    static detachNewThreadWithBlock$(block: NobjcObject): void;
+    static detachNewThreadWithBlock$(block: () => void): void;
     static detachNewThreadSelector$toTarget$withObject$(selector: string, target: NobjcObject, argument: NobjcObject | null): void;
     static isMultiThreaded(): boolean;
     static sleepUntilDate$(date: _NSDate): void;
@@ -22,7 +22,7 @@ export declare class _NSThread extends _NSObject {
     static mainThread(): _NSThread;
     init(): _NSThread;
     initWithTarget$selector$object$(target: NobjcObject, selector: string, argument: NobjcObject | null): _NSThread;
-    initWithBlock$(block: NobjcObject): _NSThread;
+    initWithBlock$(block: () => void): _NSThread;
     cancel(): void;
     start(): void;
     /**

package/dist/Foundation/NSTimer.d.ts

@@ -13,15 +13,15 @@ export declare class _NSTimer extends _NSObject {
     /**
      * Creates and returns a new NSTimer object initialized with the specified block object. This timer needs to be scheduled on a run loop (via -[NSRunLoop addTimer:]) before it will fire. - parameter: timeInterval The number of seconds between firings of the timer. If seconds is less than or equal to 0.0, this method chooses the nonnegative value of 0.1 milliseconds instead - parameter: repeats If YES, the timer will repeatedly reschedule itself until invalidated. If NO, the timer will be invalidated after it fires. - parameter: block The execution body of the timer; the timer itself is passed as the parameter to this block when executed to aid in avoiding cyclical references
      */
-    static timerWithTimeInterval$repeats$block$(interval: number, repeats: boolean, block: NobjcObject): _NSTimer;
+    static timerWithTimeInterval$repeats$block$(interval: number, repeats: boolean, block: (timer: _NSTimer) => void): _NSTimer;
     /**
      * Creates and returns a new NSTimer object initialized with the specified block object and schedules it on the current run loop in the default mode. - parameter: ti The number of seconds between firings of the timer. If seconds is less than or equal to 0.0, this method chooses the nonnegative value of 0.1 milliseconds instead - parameter: repeats If YES, the timer will repeatedly reschedule itself until invalidated. If NO, the timer will be invalidated after it fires. - parameter: block The execution body of the timer; the timer itself is passed as the parameter to this block when executed to aid in avoiding cyclical references
      */
-    static scheduledTimerWithTimeInterval$repeats$block$(interval: number, repeats: boolean, block: NobjcObject): _NSTimer;
+    static scheduledTimerWithTimeInterval$repeats$block$(interval: number, repeats: boolean, block: (timer: _NSTimer) => void): _NSTimer;
     /**
      * Initializes a new NSTimer object using the block as the main body of execution for the timer. This timer needs to be scheduled on a run loop (via -[NSRunLoop addTimer:]) before it will fire. - parameter: fireDate The time at which the timer should first fire. - parameter: interval The number of seconds between firings of the timer. If seconds is less than or equal to 0.0, this method chooses the nonnegative value of 0.1 milliseconds instead - parameter: repeats If YES, the timer will repeatedly reschedule itself until invalidated. If NO, the timer will be invalidated after it fires. - parameter: block The execution body of the timer; the timer itself is passed as the parameter to this block when executed to aid in avoiding cyclical references
      */
-    initWithFireDate$interval$repeats$block$(date: _NSDate, interval: number, repeats: boolean, block: NobjcObject): _NSTimer;
+    initWithFireDate$interval$repeats$block$(date: _NSDate, interval: number, repeats: boolean, block: (timer: _NSTimer) => void): _NSTimer;
     initWithFireDate$interval$target$selector$userInfo$repeats$(date: _NSDate, ti: number, t: NobjcObject, s: string, ui: NobjcObject | null, rep: boolean): _NSTimer;
     fire(): void;
     invalidate(): void;

package/dist/Foundation/NSURLCache.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSCachedURLResponse } from "./NSCachedURLResponse.js";
 import type { _NSDate } from "./NSDate.js";
 import type { _NSObject } from "./NSObject.js";
@@ -45,7 +44,7 @@ export declare class _NSURLCache extends _NSObject {
      */
     removeCachedResponsesSinceDate$(date: _NSDate): void;
     storeCachedResponse$forDataTask$(cachedResponse: _NSCachedURLResponse, dataTask: _NSURLSessionDataTask): void;
-    getCachedResponseForDataTask$completionHandler$(dataTask: _NSURLSessionDataTask, completionHandler: NobjcObject | null): void;
+    getCachedResponseForDataTask$completionHandler$(dataTask: _NSURLSessionDataTask, completionHandler: ((cachedResponse: _NSCachedURLResponse) => void) | null): void;
     removeCachedResponseForDataTask$(dataTask: _NSURLSessionDataTask): void;
     /**
      * @abstract In-memory capacity of the receiver. @discussion At the time this call is made, the in-memory cache will truncate its contents to the size given, if necessary. @result The in-memory capacity, measured in bytes, for the receiver.

package/dist/Foundation/NSURLConnection.d.ts

@@ -1,10 +1,12 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSData } from "./NSData.js";
+import type { _NSError } from "./NSError.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSOperationQueue } from "./NSOperationQueue.js";
 import type { _NSRunLoop } from "./NSRunLoop.js";
 import type { _NSString } from "./NSString.js";
 import type { _NSURLRequest } from "./NSURLRequest.js";
+import type { _NSURLResponse } from "./NSURLResponse.js";
 export declare class _NSURLConnection extends _NSObject {
     static alloc(): _NSURLConnection;
     static new(): _NSURLConnection;
@@ -24,7 +26,7 @@ export declare class _NSURLConnection extends _NSObject {
      * @method sendAsynchronousRequest:queue:completionHandler: @abstract Performs an asynchronous load of the given request. When the request has completed or failed, the block will be executed from the context of the specified NSOperationQueue. @discussion This is a convenience routine that allows for asynchronous loading of a url-based resource. If the resource load is successful, the data parameter to the callback will contain the resource data and the error parameter will be nil. If the resource load fails, the data parameter will be nil and the error will contain information about the failure. @param request The request to load. Note that the request is deep-copied as part of the initialization process. Changes made to the request argument after this method returns do not affect the request that is used for the loading process. @param queue An NSOperationQueue upon which the handler block will be dispatched. @param handler A block which receives the results of the resource load.
      * @deprecated Use [NSURLSession dataTaskWithRequest:completionHandler:] (see NSURLSession.h
      */
-    static sendAsynchronousRequest$queue$completionHandler$(request: _NSURLRequest, queue: _NSOperationQueue, handler: NobjcObject | null): void;
+    static sendAsynchronousRequest$queue$completionHandler$(request: _NSURLRequest, queue: _NSOperationQueue, handler: ((response: _NSURLResponse, data: _NSData, connectionError: _NSError) => void) | null): void;
     /**
      * Designated initializer
      * @deprecated Use NSURLSession (see NSURLSession.h)