objcjs-types 0.3.0 → 0.5.0

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)

package/dist/Foundation/NSURLCredentialStorage.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSDictionary } from "./NSDictionary.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSURLCredential } from "./NSURLCredential.js";
@@ -36,10 +35,10 @@ export declare class _NSURLCredentialStorage extends _NSObject {
      * @method setDefaultCredential:forProtectionSpace: @abstract Set the default credential for the specified protection space. @param credential The credential to set as default. @param space The protection space for which the credential should be set as default. @discussion If the credential is not yet in the set for the protection space, it will be added to it.
      */
     setDefaultCredential$forProtectionSpace$(credential: _NSURLCredential, space: _NSURLProtectionSpace): void;
-    getCredentialsForProtectionSpace$task$completionHandler$(protectionSpace: _NSURLProtectionSpace, task: _NSURLSessionTask, completionHandler: NobjcObject | null): void;
+    getCredentialsForProtectionSpace$task$completionHandler$(protectionSpace: _NSURLProtectionSpace, task: _NSURLSessionTask, completionHandler: ((credentials: _NSDictionary) => void) | null): void;
     setCredential$forProtectionSpace$task$(credential: _NSURLCredential, protectionSpace: _NSURLProtectionSpace, task: _NSURLSessionTask): void;
     removeCredential$forProtectionSpace$options$task$(credential: _NSURLCredential, protectionSpace: _NSURLProtectionSpace, options: _NSDictionary | null, task: _NSURLSessionTask): void;
-    getDefaultCredentialForProtectionSpace$task$completionHandler$(space: _NSURLProtectionSpace, task: _NSURLSessionTask, completionHandler: NobjcObject | null): void;
+    getDefaultCredentialForProtectionSpace$task$completionHandler$(space: _NSURLProtectionSpace, task: _NSURLSessionTask, completionHandler: ((credential: _NSURLCredential) => void) | null): void;
     setDefaultCredential$forProtectionSpace$task$(credential: _NSURLCredential, protectionSpace: _NSURLProtectionSpace, task: _NSURLSessionTask): void;
     /**
      * @abstract Get a dictionary mapping NSURLProtectionSpaces to dictionaries which map usernames to NSURLCredentials @result an NSDictionary where the keys are NSURLProtectionSpaces and the values are dictionaries, in which the keys are usernames and the values are NSURLCredentials

package/dist/Foundation/NSURLSession.d.ts

@@ -1,12 +1,13 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
 import type { _NSData } from "./NSData.js";
+import type { _NSError } from "./NSError.js";
 import type { _NSNetService } from "./NSNetService.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSOperationQueue } from "./NSOperationQueue.js";
 import type { _NSString } from "./NSString.js";
 import type { _NSURL } from "./NSURL.js";
 import type { _NSURLRequest } from "./NSURLRequest.js";
+import type { _NSURLResponse } from "./NSURLResponse.js";
 import type { _NSURLSessionConfiguration } from "./NSURLSessionConfiguration.js";
 import type { _NSURLSessionDataTask } from "./NSURLSessionDataTask.js";
 import type { _NSURLSessionDelegate } from "./NSURLSessionDelegate.js";
@@ -37,19 +38,19 @@ export declare class _NSURLSession extends _NSObject {
      * -invalidateAndCancel acts as -finishTasksAndInvalidate, but issues -cancel to all outstanding tasks for this session. Note task cancellation is subject to the state of the task, and some tasks may have already have completed at the time they are sent -cancel.
      */
     invalidateAndCancel(): void;
-    resetWithCompletionHandler$(completionHandler: NobjcObject): void;
+    resetWithCompletionHandler$(completionHandler: () => void): void;
     /**
      * - (void)resetWithCompletionHandler:(void (NS_SWIFT_SENDABLE ^)(void))completionHandler; empty all cookies, cache and credential stores, removes disk files, issues -flushWithCompletionHandler:. Invokes completionHandler() on the delegate queue.
      */
-    flushWithCompletionHandler$(completionHandler: NobjcObject): void;
+    flushWithCompletionHandler$(completionHandler: () => void): void;
     /**
      * - (void)flushWithCompletionHandler:(void (NS_SWIFT_SENDABLE ^)(void))completionHandler; flush storage to disk and clear transient network caches. Invokes completionHandler() on the delegate queue.
      */
-    getTasksWithCompletionHandler$(completionHandler: NobjcObject): void;
+    getTasksWithCompletionHandler$(completionHandler: (dataTasks: _NSArray, uploadTasks: _NSArray, downloadTasks: _NSArray) => void): void;
     /**
      * - (void)getTasksWithCompletionHandler:(void (NS_SWIFT_SENDABLE ^)(NSArray<NSURLSessionDataTask *> *dataTasks, NSArray<NSURLSessionUploadTask *> *uploadTasks, NSArray<NSURLSessionDownloadTask *> *downloadTasks))completionHandler NS_SWIFT_ASYNC_NAME(getter:tasks()); invokes completionHandler with outstanding data, upload and download tasks.
      */
-    getAllTasksWithCompletionHandler$(completionHandler: NobjcObject): void;
+    getAllTasksWithCompletionHandler$(completionHandler: (tasks: _NSArray) => void): void;
     /** Creates a data task with the given request. The request may have a body stream. */
     dataTaskWithRequest$(request: _NSURLRequest): _NSURLSessionDataTask;
     /** Creates a data task to retrieve the contents of the given URL. */
@@ -108,21 +109,21 @@ export declare class _NSURLSession extends _NSObject {
     /**
      * data task convenience methods. These methods create tasks that bypass the normal delegate calls for response and data delivery, and provide a simple cancelable asynchronous interface to receiving data. Errors will be returned in the NSURLErrorDomain, see <Foundation/NSURLError.h>. The delegate, if any, will still be called for authentication challenges.
      */
-    dataTaskWithRequest$completionHandler$(request: _NSURLRequest, completionHandler: NobjcObject | null): _NSURLSessionDataTask;
-    dataTaskWithURL$completionHandler$(url: _NSURL, completionHandler: NobjcObject | null): _NSURLSessionDataTask;
+    dataTaskWithRequest$completionHandler$(request: _NSURLRequest, completionHandler: ((data: _NSData, response: _NSURLResponse, error: _NSError) => void) | null): _NSURLSessionDataTask;
+    dataTaskWithURL$completionHandler$(url: _NSURL, completionHandler: ((data: _NSData, response: _NSURLResponse, error: _NSError) => void) | null): _NSURLSessionDataTask;
     /** upload convenience method. */
-    uploadTaskWithRequest$fromFile$completionHandler$(request: _NSURLRequest, fileURL: _NSURL, completionHandler: NobjcObject | null): _NSURLSessionUploadTask;
-    uploadTaskWithRequest$fromData$completionHandler$(request: _NSURLRequest, bodyData: _NSData | null, completionHandler: NobjcObject | null): _NSURLSessionUploadTask;
+    uploadTaskWithRequest$fromFile$completionHandler$(request: _NSURLRequest, fileURL: _NSURL, completionHandler: ((data: _NSData, response: _NSURLResponse, error: _NSError) => void) | null): _NSURLSessionUploadTask;
+    uploadTaskWithRequest$fromData$completionHandler$(request: _NSURLRequest, bodyData: _NSData | null, completionHandler: ((data: _NSData, response: _NSURLResponse, error: _NSError) => void) | null): _NSURLSessionUploadTask;
     /**
      * Creates a URLSessionUploadTask from a resume data blob. If resuming from an upload file, the file must still exist and be unmodified. - Parameter resumeData: Resume data blob from an incomplete upload, such as data returned by the cancelByProducingResumeData: method. - Parameter completionHandler: The completion handler to call when the load request is complete. - Returns: A new session upload task, or nil if the resumeData is invalid.
      */
-    uploadTaskWithResumeData$completionHandler$(resumeData: _NSData, completionHandler: NobjcObject | null): _NSURLSessionUploadTask;
+    uploadTaskWithResumeData$completionHandler$(resumeData: _NSData, completionHandler: ((data: _NSData, response: _NSURLResponse, error: _NSError) => void) | null): _NSURLSessionUploadTask;
     /**
      * download task convenience methods. When a download successfully completes, the NSURL will point to a file that must be read or copied during the invocation of the completion routine. The file will be removed automatically.
      */
-    downloadTaskWithRequest$completionHandler$(request: _NSURLRequest, completionHandler: NobjcObject | null): _NSURLSessionDownloadTask;
-    downloadTaskWithURL$completionHandler$(url: _NSURL, completionHandler: NobjcObject | null): _NSURLSessionDownloadTask;
-    downloadTaskWithResumeData$completionHandler$(resumeData: _NSData, completionHandler: NobjcObject | null): _NSURLSessionDownloadTask;
+    downloadTaskWithRequest$completionHandler$(request: _NSURLRequest, completionHandler: ((location: _NSURL, response: _NSURLResponse, error: _NSError) => void) | null): _NSURLSessionDownloadTask;
+    downloadTaskWithURL$completionHandler$(url: _NSURL, completionHandler: ((location: _NSURL, response: _NSURLResponse, error: _NSError) => void) | null): _NSURLSessionDownloadTask;
+    downloadTaskWithResumeData$completionHandler$(resumeData: _NSData, completionHandler: ((location: _NSURL, response: _NSURLResponse, error: _NSError) => void) | null): _NSURLSessionDownloadTask;
     delegateQueue(): _NSOperationQueue;
     delegate(): _NSURLSessionDelegate | null;
     configuration(): _NSURLSessionConfiguration;

package/dist/Foundation/NSURLSessionDataDelegate.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSCachedURLResponse } from "./NSCachedURLResponse.js";
 import type { _NSData } from "./NSData.js";
 import type { _NSURLResponse } from "./NSURLResponse.js";
@@ -7,11 +6,12 @@ import type { _NSURLSessionDataTask } from "./NSURLSessionDataTask.js";
 import type { _NSURLSessionDownloadTask } from "./NSURLSessionDownloadTask.js";
 import type { _NSURLSessionStreamTask } from "./NSURLSessionStreamTask.js";
 import type { _NSURLSessionTaskDelegate } from "./NSURLSessionTaskDelegate.js";
+import type { NSURLSessionResponseDisposition } from "./NSURLSessionResponseDisposition.js";
 export interface _NSURLSessionDataDelegate extends _NSURLSessionTaskDelegate {
     /**
      * The task has received a response and no further messages will be received until the completion block is called. The disposition allows you to cancel a request or to turn a data task into a download task. This delegate message is optional - if you do not implement it, you can get the response as a property of the task. This method will not be called for background upload tasks (which cannot be converted to download tasks).
      */
-    URLSession$dataTask$didReceiveResponse$completionHandler$?(session: _NSURLSession, dataTask: _NSURLSessionDataTask, response: _NSURLResponse, completionHandler: NobjcObject): void;
+    URLSession$dataTask$didReceiveResponse$completionHandler$?(session: _NSURLSession, dataTask: _NSURLSessionDataTask, response: _NSURLResponse, completionHandler: (disposition: NSURLSessionResponseDisposition) => void): void;
     /**
      * Notification that a data task has become a download task. No future messages will be sent to the data task.
      */
@@ -27,5 +27,5 @@ export interface _NSURLSessionDataDelegate extends _NSURLSessionTaskDelegate {
     /**
      * Invoke the completion routine with a valid NSCachedURLResponse to allow the resulting data to be cached, or pass nil to prevent caching. Note that there is no guarantee that caching will be attempted for a given resource, and you should not rely on this message to receive the resource data.
      */
-    URLSession$dataTask$willCacheResponse$completionHandler$?(session: _NSURLSession, dataTask: _NSURLSessionDataTask, proposedResponse: _NSCachedURLResponse, completionHandler: NobjcObject | null): void;
+    URLSession$dataTask$willCacheResponse$completionHandler$?(session: _NSURLSession, dataTask: _NSURLSessionDataTask, proposedResponse: _NSCachedURLResponse, completionHandler: ((cachedResponse: _NSCachedURLResponse) => void) | null): void;
 }

package/dist/Foundation/NSURLSessionDelegate.d.ts

@@ -1,7 +1,8 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSError } from "./NSError.js";
 import type { _NSURLAuthenticationChallenge } from "./NSURLAuthenticationChallenge.js";
+import type { _NSURLCredential } from "./NSURLCredential.js";
 import type { _NSURLSession } from "./NSURLSession.js";
+import type { NSURLSessionAuthChallengeDisposition } from "./NSURLSessionAuthChallengeDisposition.js";
 export interface _NSURLSessionDelegate {
     /**
      * The last message a session receives. A session will only become invalid because of a systemic error or when it has been explicitly invalidated, in which case the error parameter will be nil.
@@ -10,7 +11,7 @@ export interface _NSURLSessionDelegate {
     /**
      * If implemented, when a connection level authentication challenge has occurred, this delegate will be given the opportunity to provide authentication credentials to the underlying connection. Some types of authentication will apply to more than one request on a given connection to a server (SSL Server Trust challenges). If this delegate message is not implemented, the behavior will be to use the default handling, which may involve user interaction.
      */
-    URLSession$didReceiveChallenge$completionHandler$?(session: _NSURLSession, challenge: _NSURLAuthenticationChallenge, completionHandler: NobjcObject | null): void;
+    URLSession$didReceiveChallenge$completionHandler$?(session: _NSURLSession, challenge: _NSURLAuthenticationChallenge, completionHandler: ((disposition: NSURLSessionAuthChallengeDisposition, credential: _NSURLCredential) => void) | null): void;
     /**
      * If an application has received an -application:handleEventsForBackgroundURLSession:completionHandler: message, the session delegate will receive this message to indicate that all messages previously enqueued for this session have been delivered. At this time it is safe to invoke the previously stored completion handler, or to begin any internal updates that will result in invoking the completion handler.
      */

package/dist/Foundation/NSURLSessionDownloadTask.d.ts

@@ -1,4 +1,4 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSData } from "./NSData.js";
 import type { _NSURLSessionTask } from "./NSURLSessionTask.js";
 export declare class _NSURLSessionDownloadTask extends _NSURLSessionTask {
     static alloc(): _NSURLSessionDownloadTask;
@@ -10,7 +10,7 @@ export declare class _NSURLSessionDownloadTask extends _NSURLSessionTask {
      * Cancel the download (and calls the superclass -cancel). If conditions will allow for resuming the download in the future, the callback will be called with an opaque data blob, which may be used with -downloadTaskWithResumeData: to attempt to resume the download. If resume data cannot be created, the completion handler will be called with nil resumeData.
      * @deprecated Please use -[NSURLSession downloadTaskWithRequest:] or other NSURLSession methods to create instances
      */
-    cancelByProducingResumeData$(completionHandler: NobjcObject | null): void;
+    cancelByProducingResumeData$(completionHandler: ((resumeData: _NSData) => void) | null): void;
     /**
      * @deprecated Please use -[NSURLSession downloadTaskWithRequest:] or other NSURLSession methods to create instances
      */

package/dist/Foundation/NSURLSessionStreamTask.d.ts

@@ -1,5 +1,5 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSData } from "./NSData.js";
+import type { _NSError } from "./NSError.js";
 import type { _NSURLSessionTask } from "./NSURLSessionTask.js";
 export declare class _NSURLSessionStreamTask extends _NSURLSessionTask {
     static alloc(): _NSURLSessionStreamTask;
@@ -10,11 +10,11 @@ export declare class _NSURLSessionStreamTask extends _NSURLSessionTask {
     /**
      * Read minBytes, or at most maxBytes bytes and invoke the completion handler on the sessions delegate queue with the data or an error. If an error occurs, any outstanding reads will also fail, and new read requests will error out immediately.
      */
-    readDataOfMinLength$maxLength$timeout$completionHandler$(minBytes: number, maxBytes: number, timeout: number, completionHandler: NobjcObject | null): void;
+    readDataOfMinLength$maxLength$timeout$completionHandler$(minBytes: number, maxBytes: number, timeout: number, completionHandler: ((_result: _NSData, atEOF: boolean, error: _NSError) => void) | null): void;
     /**
      * Write the data completely to the underlying socket. If all the bytes have not been written by the timeout, a timeout error will occur. Note that invocation of the completion handler does not guarantee that the remote side has received all the bytes, only that they have been written to the kernel.
      */
-    writeData$timeout$completionHandler$(data: _NSData, timeout: number, completionHandler: NobjcObject | null): void;
+    writeData$timeout$completionHandler$(data: _NSData, timeout: number, completionHandler: ((error: _NSError) => void) | null): void;
     /**
      * -captureStreams completes any already enqueued reads and writes, and then invokes the URLSession:streamTask:didBecomeInputStream:outputStream: delegate message. When that message is received, the task object is considered completed and will not receive any more delegate messages.
      */

package/dist/Foundation/NSURLSessionTaskDelegate.d.ts

@@ -1,12 +1,15 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSError } from "./NSError.js";
 import type { _NSHTTPURLResponse } from "./NSHTTPURLResponse.js";
+import type { _NSInputStream } from "./NSInputStream.js";
 import type { _NSURLAuthenticationChallenge } from "./NSURLAuthenticationChallenge.js";
+import type { _NSURLCredential } from "./NSURLCredential.js";
 import type { _NSURLRequest } from "./NSURLRequest.js";
 import type { _NSURLSession } from "./NSURLSession.js";
 import type { _NSURLSessionDelegate } from "./NSURLSessionDelegate.js";
 import type { _NSURLSessionTask } from "./NSURLSessionTask.js";
 import type { _NSURLSessionTaskMetrics } from "./NSURLSessionTaskMetrics.js";
+import type { NSURLSessionAuthChallengeDisposition } from "./NSURLSessionAuthChallengeDisposition.js";
+import type { NSURLSessionDelayedRequestDisposition } from "./NSURLSessionDelayedRequestDisposition.js";
 export interface _NSURLSessionTaskDelegate extends _NSURLSessionDelegate {
     /**
      * Notification that a task has been created. This method is the first message a task sends, providing a place to configure the task before it is resumed. This delegate callback is *NOT* dispatched to the delegate queue. It is invoked synchronously before the task creation method returns.
@@ -15,7 +18,7 @@ export interface _NSURLSessionTaskDelegate extends _NSURLSessionDelegate {
     /**
      * Sent when the system is ready to begin work for a task with a delayed start time set (using the earliestBeginDate property). The completionHandler must be invoked in order for loading to proceed. The disposition provided to the completion handler continues the load with the original request provided to the task, replaces the request with the specified task, or cancels the task. If this delegate is not implemented, loading will proceed with the original request. Recommendation: only implement this delegate if tasks that have the earliestBeginDate property set may become stale and require alteration prior to starting the network load. If a new request is specified, the allowsExpensiveNetworkAccess, allowsConstrainedNetworkAccess, and allowsCellularAccess properties from the new request will not be used; the properties from the original request will continue to be used. Canceling the task is equivalent to calling the task's cancel method; the URLSession:task:didCompleteWithError: task delegate will be called with error NSURLErrorCancelled.
      */
-    URLSession$task$willBeginDelayedRequest$completionHandler$?(session: _NSURLSession, task: _NSURLSessionTask, request: _NSURLRequest, completionHandler: NobjcObject | null): void;
+    URLSession$task$willBeginDelayedRequest$completionHandler$?(session: _NSURLSession, task: _NSURLSessionTask, request: _NSURLRequest, completionHandler: ((disposition: NSURLSessionDelayedRequestDisposition, newRequest: _NSURLRequest) => void) | null): void;
     /**
      * Sent when a task cannot start the network loading process because the current network connectivity is not available or sufficient for the task's request. This delegate will be called at most one time per task, and is only called if the waitsForConnectivity property in the NSURLSessionConfiguration has been set to YES. This delegate callback will never be called for background sessions, because the waitForConnectivity property is ignored by those sessions.
      */
@@ -23,19 +26,19 @@ export interface _NSURLSessionTaskDelegate extends _NSURLSessionDelegate {
     /**
      * An HTTP request is attempting to perform a redirection to a different URL. You must invoke the completion routine to allow the redirection, allow the redirection with a modified request, or pass nil to the completionHandler to cause the body of the redirection response to be delivered as the payload of this request. The default is to follow redirections. For tasks in background sessions, redirections will always be followed and this method will not be called.
      */
-    URLSession$task$willPerformHTTPRedirection$newRequest$completionHandler$?(session: _NSURLSession, task: _NSURLSessionTask, response: _NSHTTPURLResponse, request: _NSURLRequest, completionHandler: NobjcObject | null): void;
+    URLSession$task$willPerformHTTPRedirection$newRequest$completionHandler$?(session: _NSURLSession, task: _NSURLSessionTask, response: _NSHTTPURLResponse, request: _NSURLRequest, completionHandler: ((arg0: _NSURLRequest) => void) | null): void;
     /**
      * The task has received a request specific authentication challenge. If this delegate is not implemented, the session specific authentication challenge will *NOT* be called and the behavior will be the same as using the default handling disposition.
      */
-    URLSession$task$didReceiveChallenge$completionHandler$?(session: _NSURLSession, task: _NSURLSessionTask, challenge: _NSURLAuthenticationChallenge, completionHandler: NobjcObject | null): void;
+    URLSession$task$didReceiveChallenge$completionHandler$?(session: _NSURLSession, task: _NSURLSessionTask, challenge: _NSURLAuthenticationChallenge, completionHandler: ((disposition: NSURLSessionAuthChallengeDisposition, credential: _NSURLCredential) => void) | null): void;
     /**
      * Sent if a task requires a new, unopened body stream. This may be necessary when authentication has failed for any request that involves a body stream.
      */
-    URLSession$task$needNewBodyStream$?(session: _NSURLSession, task: _NSURLSessionTask, completionHandler: NobjcObject | null): void;
+    URLSession$task$needNewBodyStream$?(session: _NSURLSession, task: _NSURLSessionTask, completionHandler: ((bodyStream: _NSInputStream) => void) | null): void;
     /**
      * Tells the delegate if a task requires a new body stream starting from the given offset. This may be necessary when resuming a failed upload task. - Parameter session: The session containing the task that needs a new body stream from the given offset. - Parameter task: The task that needs a new body stream. - Parameter offset: The starting offset required for the body stream. - Parameter completionHandler: A completion handler that your delegate method should call with the new body stream.
      */
-    URLSession$task$needNewBodyStreamFromOffset$completionHandler$?(session: _NSURLSession, task: _NSURLSessionTask, offset: number, completionHandler: NobjcObject | null): void;
+    URLSession$task$needNewBodyStreamFromOffset$completionHandler$?(session: _NSURLSession, task: _NSURLSessionTask, offset: number, completionHandler: ((bodyStream: _NSInputStream) => void) | null): void;
     /**
      * Sent periodically to notify the delegate of upload progress. This information is also available as properties of the task.
      */

package/dist/Foundation/NSURLSessionUploadTask.d.ts

@@ -1,4 +1,4 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSData } from "./NSData.js";
 import type { _NSURLSessionDataTask } from "./NSURLSessionDataTask.js";
 export declare class _NSURLSessionUploadTask extends _NSURLSessionDataTask {
     static alloc(): _NSURLSessionUploadTask;
@@ -13,5 +13,5 @@ export declare class _NSURLSessionUploadTask extends _NSURLSessionDataTask {
     /**
      * Cancels an upload and calls the completion handler with resume data for later use. resumeData will be nil if the server does not support the latest resumable uploads Internet-Draft from the HTTP Working Group, found at https://datatracker.ietf.org/doc/draft-ietf-httpbis-resumable-upload/ - Parameter completionHandler: The completion handler to call when the upload has been successfully canceled.
      */
-    cancelByProducingResumeData$(completionHandler: NobjcObject | null): void;
+    cancelByProducingResumeData$(completionHandler: ((resumeData: _NSData) => void) | null): void;
 }

package/dist/Foundation/NSURLSessionWebSocketTask.d.ts

@@ -1,5 +1,5 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSData } from "./NSData.js";
+import type { _NSError } from "./NSError.js";
 import type { _NSURLSessionTask } from "./NSURLSessionTask.js";
 import type { _NSURLSessionWebSocketMessage } from "./NSURLSessionWebSocketMessage.js";
 import type { NSURLSessionWebSocketCloseCode } from "./NSURLSessionWebSocketCloseCode.js";
@@ -10,15 +10,15 @@ export declare class _NSURLSessionWebSocketTask extends _NSURLSessionTask {
     /**
      * Sends a WebSocket message. If an error occurs, any outstanding work will also fail. Note that invocation of the completion handler does not guarantee that the remote side has received all the bytes, only that they have been written to the kernel.
      */
-    sendMessage$completionHandler$(message: _NSURLSessionWebSocketMessage, completionHandler: NobjcObject | null): void;
+    sendMessage$completionHandler$(message: _NSURLSessionWebSocketMessage, completionHandler: ((error: _NSError) => void) | null): void;
     /**
      * Reads a WebSocket message once all the frames of the message are available. If the maximumMessage size is hit while buffering the frames, the receiveMessage call will error out and all outstanding work will also fail resulting in the end of the task.
      */
-    receiveMessageWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    receiveMessageWithCompletionHandler$(completionHandler: ((message: _NSURLSessionWebSocketMessage, error: _NSError) => void) | null): void;
     /**
      * Sends a ping frame from the client side. The pongReceiveHandler is invoked when the client receives a pong from the server endpoint. If a connection is lost or an error occurs before receiving the pong from the endpoint, the pongReceiveHandler block will be invoked with an error. Note - the pongReceiveHandler will always be called in the order in which the pings were sent.
      */
-    sendPingWithPongReceiveHandler$(pongReceiveHandler: NobjcObject | null): void;
+    sendPingWithPongReceiveHandler$(pongReceiveHandler: ((error: _NSError) => void) | null): void;
     /**
      * Sends a close frame with the given closeCode. An optional reason can be provided while sending the close frame. Simply calling cancel on the task will result in a cancellation frame being sent without any reason.
      */

package/dist/Foundation/NSUndoManager.d.ts

@@ -52,7 +52,7 @@ export declare class _NSUndoManager extends _NSObject {
     /**
      * Records a single undo operation for a given target so that when an undo is performed, it executes the specified block. As with other undo operations, this does not strongly retain target. Care should be taken to avoid introducing retain cycles by other references captured by the block. - Parameter target: The target of the undo operation. - Parameter undoHandler: The block to be executed when an operation is undone. The block takes a single argument, the target of the undo operation.
      */
-    registerUndoWithTarget$handler$(target: NobjcObject, undoHandler: NobjcObject): void;
+    registerUndoWithTarget$handler$(target: NobjcObject, undoHandler: (target: NobjcObject) => void): void;
     /**
      * Sets whether the next undo or redo action is discardable. Specifies that the latest undo action may be safely discarded when a document can not be saved for any reason. An example might be an undo action that changes the viewable area of a document. To find out if an undo group contains only discardable actions, look for the ``NSUndoManagerGroupIsDiscardableKey`` in the `userInfo` dictionary of the ``NSUndoManagerWillCloseUndoGroupNotification``. - Parameter discardable: Specifies if the action is discardable. YES if the next undo or redo action can be discarded; NO otherwise.
      */

package/dist/Foundation/NSUserActivity.d.ts

@@ -1,8 +1,10 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
 import type { _NSDate } from "./NSDate.js";
 import type { _NSDictionary } from "./NSDictionary.js";
+import type { _NSError } from "./NSError.js";
+import type { _NSInputStream } from "./NSInputStream.js";
 import type { _NSObject } from "./NSObject.js";
+import type { _NSOutputStream } from "./NSOutputStream.js";
 import type { _NSSet } from "./NSSet.js";
 import type { _NSString } from "./NSString.js";
 import type { _NSURL } from "./NSURL.js";
@@ -10,8 +12,8 @@ import type { _NSUserActivityDelegate } from "./NSUserActivityDelegate.js";
 export declare class _NSUserActivity extends _NSObject {
     static alloc(): _NSUserActivity;
     static new(): _NSUserActivity;
-    static deleteSavedUserActivitiesWithPersistentIdentifiers$completionHandler$(persistentIdentifiers: _NSArray, handler: NobjcObject): void;
-    static deleteAllSavedUserActivitiesWithCompletionHandler$(handler: NobjcObject): void;
+    static deleteSavedUserActivitiesWithPersistentIdentifiers$completionHandler$(persistentIdentifiers: _NSArray, handler: () => void): void;
+    static deleteAllSavedUserActivitiesWithCompletionHandler$(handler: () => void): void;
     /**
      * Initializes and returns a newly created NSUserActivity with the given activityType. A user activity may be continued only in an application that (1) has the same developer Team ID as the activity's source application and (2) supports the activity's type. Supported activity types are specified in the application's Info.plist under the NSUserActivityTypes key. When receiving a user activity for continuation, the system locates the appropriate application to launch by finding applications with the target Team ID, then filtering on the incoming activity's type identifier.
      * @deprecated Use initWithActivityType: with a specific activity type string
@@ -41,7 +43,7 @@ export declare class _NSUserActivity extends _NSObject {
     /**
      * When an app is launched for a continuation event it can request streams back to the originating side. Streams can only be successfully retrieved from the NSUserActivity in the NS/UIApplication delegate that is called for a continuation event. This functionality is optional and is not expected to be needed in most continuation cases. The streams returned in the completion handler will be in an unopened state. The streams should be opened immediately to start requesting information from the other side.
      */
-    getContinuationStreamsWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    getContinuationStreamsWithCompletionHandler$(completionHandler: ((inputStream: _NSInputStream, outputStream: _NSOutputStream, error: _NSError) => void) | null): void;
     /** The activityType the user activity was created with. */
     activityType(): _NSString;
     /**

package/dist/Foundation/NSUserAppleScriptTask.d.ts

@@ -1,9 +1,9 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSAppleEventDescriptor } from "./NSAppleEventDescriptor.js";
+import type { _NSError } from "./NSError.js";
 import type { _NSUserScriptTask } from "./NSUserScriptTask.js";
 export declare class _NSUserAppleScriptTask extends _NSUserScriptTask {
     static alloc(): _NSUserAppleScriptTask;
     static new(): _NSUserAppleScriptTask;
     init(): _NSUserAppleScriptTask;
-    executeWithAppleEvent$completionHandler$(event: _NSAppleEventDescriptor | null, handler: NobjcObject | null): void;
+    executeWithAppleEvent$completionHandler$(event: _NSAppleEventDescriptor | null, handler: ((arg0: _NSAppleEventDescriptor, arg1: _NSError) => void) | null): void;
 }

package/dist/Foundation/NSUserAutomatorTask.d.ts

@@ -1,12 +1,13 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSDictionary } from "./NSDictionary.js";
+import type { _NSError } from "./NSError.js";
 import type { _NSSecureCoding } from "./NSSecureCoding.js";
 import type { _NSUserScriptTask } from "./NSUserScriptTask.js";
 export declare class _NSUserAutomatorTask extends _NSUserScriptTask {
     static alloc(): _NSUserAutomatorTask;
     static new(): _NSUserAutomatorTask;
     init(): _NSUserAutomatorTask;
-    executeWithInput$completionHandler$(input: _NSSecureCoding | null, handler: NobjcObject | null): void;
+    executeWithInput$completionHandler$(input: _NSSecureCoding | null, handler: ((arg0: NobjcObject, arg1: _NSError) => void) | null): void;
     /** Workflow variables. */
     variables(): _NSDictionary | null;
     setVariables$(value: _NSDictionary | null): void;

package/dist/Foundation/NSUserScriptTask.d.ts

@@ -1,4 +1,5 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSError } from "./NSError.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSURL } from "./NSURL.js";
 export declare class _NSUserScriptTask extends _NSObject {
@@ -9,6 +10,6 @@ export declare class _NSUserScriptTask extends _NSObject {
      * Initialize given a URL for a script file. The returned object will be of one of the specific sub-classes below, or nil if the file does not appear to match any of the known types. (If used from a sub-class, the result will be of that class, or nil.)
      */
     initWithURL$error$(url: _NSURL, error: NobjcObject | null): _NSUserScriptTask | null;
-    executeWithCompletionHandler$(handler: NobjcObject | null): void;
+    executeWithCompletionHandler$(handler: ((arg0: _NSError) => void) | null): void;
     scriptURL(): _NSURL;
 }

package/dist/Foundation/NSUserUnixTask.d.ts

@@ -1,12 +1,12 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "./NSArray.js";
+import type { _NSError } from "./NSError.js";
 import type { _NSFileHandle } from "./NSFileHandle.js";
 import type { _NSUserScriptTask } from "./NSUserScriptTask.js";
 export declare class _NSUserUnixTask extends _NSUserScriptTask {
     static alloc(): _NSUserUnixTask;
     static new(): _NSUserUnixTask;
     init(): _NSUserUnixTask;
-    executeWithArguments$completionHandler$(arguments_: _NSArray | null, handler: NobjcObject | null): void;
+    executeWithArguments$completionHandler$(arguments_: _NSArray | null, handler: ((arg0: _NSError) => void) | null): void;
     /**
      * Standard I/O streams. Setting them to nil (the default) will bind them to /dev/null.
      */