objcjs-types 0.4.0 → 0.5.0

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.
      */

package/dist/Foundation/NSXPCConnection.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 { _NSString } from "./NSString.js";
 import type { _NSXPCInterface } from "./NSXPCInterface.js";
@@ -24,11 +25,11 @@ export declare class _NSXPCConnection extends _NSObject {
      * Initialize an NSXPCConnection that will connect to an NSXPCListener (identified by its NSXPCListenerEndpoint).
      */
     initWithListenerEndpoint$(endpoint: _NSXPCListenerEndpoint): _NSXPCConnection;
-    remoteObjectProxyWithErrorHandler$(handler: NobjcObject): NobjcObject;
+    remoteObjectProxyWithErrorHandler$(handler: (error: _NSError) => void): NobjcObject;
     /**
      * Make a synchronous IPC call instead of the default async behavior. The error handler block and reply block will be invoked on the calling thread before the message to the proxy returns, instead of on the queue for the connection.
      */
-    synchronousRemoteObjectProxyWithErrorHandler$(handler: NobjcObject): NobjcObject;
+    synchronousRemoteObjectProxyWithErrorHandler$(handler: (error: _NSError) => void): NobjcObject;
     /**
      * All connections start suspended. You must resume them before they will start processing received messages or sending messages through the remoteObjectProxy. Note: Calling resume does not immediately launch the XPC service. The service will be started on demand when the first message is sent. However, if the name specified when creating the connection is determined to be invalid, your invalidation handler will be called immediately (and asynchronously) after calling resume. For new code, calling `-activate` is preferred for the initial activation of the connection.
      */
@@ -48,7 +49,7 @@ export declare class _NSXPCConnection extends _NSObject {
     /**
      * Add a barrier block to be executed on the connection. This barrier block will run after any outstanding sends have completed. Note: This does not guarantee that messages will be received by the remote process by the time the block is invoked. If you need to ensure receipt of a message by the remote process, waiting for a reply to come back is the best option.
      */
-    scheduleSendBarrierBlock$(block: NobjcObject): void;
+    scheduleSendBarrierBlock$(block: () => void): void;
     /**
      * Sets the code signing requirement for this connection. If the requirement is malformed, an exception is thrown. If new messages do not match the requirement, the connection is invalidated. It is recommended to set this before calling `resume`, as it is an XPC error to call it more than once. See https://developer.apple.com/library/archive/documentation/Security/Conceptual/CodeSigningGuide/RequirementLang/RequirementLang.html for more information on the format.
      */
@@ -77,13 +78,13 @@ export declare class _NSXPCConnection extends _NSObject {
     /**
      * The interruption handler will be called if the remote process exits or crashes. It may be possible to re-establish the connection by simply sending another message. The handler will be invoked on the same queue as replies and other handlers, but there is no guarantee of ordering between those callbacks and this one. The interruptionHandler property is cleared after the connection becomes invalid. This is to mitigate the impact of a retain cycle created by referencing the NSXPCConnection instance inside this block.
      */
-    interruptionHandler(): NobjcObject | null;
-    setInterruptionHandler$(value: NobjcObject | null): void;
+    interruptionHandler(): (() => void) | null;
+    setInterruptionHandler$(value: (() => void) | null): void;
     /**
      * The invalidation handler will be called if the connection can not be formed or the connection has terminated and may not be re-established. The invalidation handler will also be called if a connection created with an NSXPCListenerEndpoint is invalidated from the remote side, or if the NSXPCListener used to create that endpoint is invalidated. The handler will be invoked on the same queue as replies and other handlers, but there is no guarantee of ordering between those callbacks and this one. You may not send messages over the connection from within an invalidation handler block. The invalidationHandler property is cleared after the connection becomes invalid. This is to mitigate the impact of a retain cycle created by referencing the NSXPCConnection instance inside this block.
      */
-    invalidationHandler(): NobjcObject | null;
-    setInvalidationHandler$(value: NobjcObject | null): void;
+    invalidationHandler(): (() => void) | null;
+    setInvalidationHandler$(value: (() => void) | null): void;
     /**
      * These attributes describe the security attributes of the connection. They may be used by the listener delegate to accept or reject connections.
      */

package/dist/Foundation/NSXPCProxyCreating.d.ts

@@ -1,4 +1,5 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSError } from "./NSError.js";
 export interface _NSXPCProxyCreating {
     /**
      * Returns a proxy object with no error handling block. Messages sent to the proxy object will be sent over the wire to the other side of the connection. All messages must be 'oneway void' return type. Control may be returned to the caller before the message is sent. This proxy object will conform with the NSXPCProxyCreating protocol.
@@ -7,9 +8,9 @@ export interface _NSXPCProxyCreating {
     /**
      * Returns a proxy object which will invoke the error handling block if an error occurs on the connection. If the message sent to the proxy has a reply handler, then either the error handler or the reply handler will be called exactly once. This proxy object will also conform with the NSXPCProxyCreating protocol.
      */
-    remoteObjectProxyWithErrorHandler$?(handler: NobjcObject): NobjcObject;
+    remoteObjectProxyWithErrorHandler$?(handler: (error: _NSError) => void): NobjcObject;
     /**
      * Make a synchronous IPC call instead of the default async behavior. The error handler block and reply block will be invoked on the calling thread before the message to the proxy returns, instead of on the queue for the connection.
      */
-    synchronousRemoteObjectProxyWithErrorHandler$?(handler: NobjcObject): NobjcObject;
+    synchronousRemoteObjectProxyWithErrorHandler$?(handler: (error: _NSError) => void): NobjcObject;
 }

package/dist/GLKit/GLKTextureLoader.d.ts

@@ -3,6 +3,7 @@ import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSBundle } from "../Foundation/NSBundle.js";
 import type { _NSData } from "../Foundation/NSData.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
@@ -44,33 +45,33 @@ export declare class _GLKTextureLoader extends _NSObject {
     /**
      * Asynchronously load an image from disk into an OpenGL texture. Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    textureWithContentsOfFile$options$queue$completionHandler$(path: _NSString, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    textureWithContentsOfFile$options$queue$completionHandler$(path: _NSString, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * completionHandler:(GLKTextureLoaderCallback)block; Block to be invoked on the above dispatch queue.
      */
-    textureWithContentsOfURL$options$queue$completionHandler$(url: _NSURL, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    textureWithContentsOfURL$options$queue$completionHandler$(url: _NSURL, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * Asynchronously load a named texture asset from a given bundled into an OpenGL texture Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    textureWithName$scaleFactor$bundle$options$queue$completionHandler$(name: _NSString, scaleFactor: number, bundle: _NSBundle | null, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    textureWithName$scaleFactor$bundle$options$queue$completionHandler$(name: _NSString, scaleFactor: number, bundle: _NSBundle | null, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * Asynchronously create a texture from data residing in memory. Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    textureWithContentsOfData$options$queue$completionHandler$(data: _NSData, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    textureWithContentsOfData$options$queue$completionHandler$(data: _NSData, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * Asynchronously create a texture from a CGImageRef. Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    textureWithCGImage$options$queue$completionHandler$(cgImage: Uint8Array, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    textureWithCGImage$options$queue$completionHandler$(cgImage: Uint8Array, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * Asynchronously load six images from disk into an OpenGL cubemap texture. Face ordering will always be interpreted as Right(+x), Left(-x), Top(+y), Bottom(-y), Front(+z), Back(-z). This coordinate system is left-handed if you think of yourself within the cube. The coordinate system is right-handed if you think of yourself outside of the cube. Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    cubeMapWithContentsOfFiles$options$queue$completionHandler$(paths: _NSArray, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    cubeMapWithContentsOfFiles$options$queue$completionHandler$(paths: _NSArray, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * Asynchronously creates an OpenGL cubemap texture by splitting one image into six parts. Takes a single image file where height = 6 * width or width = 6 * height. The former (vertical orientation) is preferred to avoid image data extraction overhead. Face ordering will always be interpreted as Right(+x), Left(-x), Top(+y), Bottom(-y), Front(+z), Back(-z). This coordinate system is left-handed if you think of yourself within the cube. The coordinate system is right-handed if you think of yourself outside of the cube. Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    cubeMapWithContentsOfFile$options$queue$completionHandler$(path: _NSString, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    cubeMapWithContentsOfFile$options$queue$completionHandler$(path: _NSString, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * completionHandler:(GLKTextureLoaderCallback)block; Block to be invoked on the above dispatch queue.
      */
-    cubeMapWithContentsOfURL$options$queue$completionHandler$(url: _NSURL, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    cubeMapWithContentsOfURL$options$queue$completionHandler$(url: _NSURL, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
 }

package/dist/GameController/GCAxis2DInput.d.ts

@@ -1,12 +1,12 @@
-import type { NobjcObject } from "objc-js";
+import type { _GCPhysicalInputElement } from "./GCPhysicalInputElement.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 import type { GCPoint2 } from "../structs/GCPoint2.js";
 export interface _GCAxis2DInput {
     /**
      * Set this block to be notified when the value of the axis input changes. @param element the element that has been modified. @param input the input that has been modified. @param value the value the axis was set to at the time the valueChangedHandler fired.
      */
-    valueDidChangeHandler?(): NobjcObject | null;
-    setValueDidChangeHandler$?(value: NobjcObject | null): void;
+    valueDidChangeHandler?(): ((arg0: _GCPhysicalInputElement, arg1: _GCAxis2DInput, arg2: GCPoint2) => void) | null;
+    setValueDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCAxis2DInput, arg2: GCPoint2) => void) | null): void;
     /**
      * A pair of x,y normalized values for the axis input, each between -1 and 1 (inclusive). The values are deadzoned and saturated before they are returned so there is no value outside the range. Deadzoning does not remove values from the range; the full 0 to 1 magnitude of values are possible from the input. As an axis is often used in a digital sense, you can rely on a value of 0 meaning the axis is inside the deadzone. Any value greater than or less than zero is not in the deadzone.
      */

package/dist/GameController/GCAxisInput.d.ts

@@ -1,11 +1,11 @@
-import type { NobjcObject } from "objc-js";
+import type { _GCPhysicalInputElement } from "./GCPhysicalInputElement.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 export interface _GCAxisInput {
     /**
      * Set this block to be notified when the value of the axis input changes. @param element the element that has been modified. @param input the input that has been modified. @param value the value the axis was set to at the time the valueChangedHandler fired.
      */
-    valueDidChangeHandler?(): NobjcObject | null;
-    setValueDidChangeHandler$?(value: NobjcObject | null): void;
+    valueDidChangeHandler?(): ((arg0: _GCPhysicalInputElement, arg1: _GCAxisInput, arg2: number) => void) | null;
+    setValueDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCAxisInput, arg2: number) => void) | null): void;
     /**
      * A normalized value for the axis input, between -1 and 1 (inclusive). The values are deadzoned and saturated before they are returned so there is no value outside the range. Deadzoning does not remove values from the range, the full 0 to 1 magnitude of values are possible from the input. As an axis is often used in a digital sense, you can rely on a value of 0 meaning the axis is inside the deadzone. Any value greater than or less than zero is not in the deadzone.
      */

package/dist/GameController/GCController.d.ts

@@ -34,7 +34,7 @@ export declare class _GCController extends _NSObject {
     /**
      * Start discovery of new wireless controllers that are discoverable. This is an asynchronous and the supplied completionHandler will get called once no more devices can be found. If there are already multiple controllers available for use, there may be little reason to automatically start discovery of new wireless controllers. In this situation it may be best to allow the user to start discovery manually via in-game UI. Once discovery has started new controllers will notify themselves as connected via GCControllerDidConnectNotification. As the notification arrives the controller is also available in the controllers array. The completionHandler could be used to update UI and/or game state to indicate that no more controllers will be found and the current set of controllers is what is available for use in the game. If a completionHandler was provided, it will be called once when discovery stops. Either from an explicit call to stopWirelessControllerDiscovery or from timing out or stopping in its natural course of operation. Thus the completionHandler will at most be called once per call to startWirelessControllerDiscoveryWithCompletionHandler:. The completionHandler may also not get called at all, if for example startWirelessControllerDiscoveryWithCompletionHandler: is called multiple times during dicovery. For this case the net effect is that the completionHandler is replaced with each call and only the last one set before discovery stops will be called. @param completionHandler an optional handler that is called when discovery stops. (may be nil, in which case you will not be notified when discovery stops) @see stopWirelessControllerDiscovery @see controllers
      */
-    static startWirelessControllerDiscoveryWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    static startWirelessControllerDiscoveryWithCompletionHandler$(completionHandler: (() => void) | null): void;
     /**
      * If no more controllers are needed, depending on game state or number of controllers supported by a game, the discovery process can be stopped. Calling stopWirelessControllerDiscovery when no discovery is currently in progress will return immediately without any effect, thus it is safe to call even if the completionHandler of startWirelessControllerDiscoveryWithCompletionHandler: has been called. @see startWirelessControllerDiscoveryWithCompletionHandler:
      */
@@ -56,8 +56,8 @@ export declare class _GCController extends _NSObject {
      * Set this block to be notified when a user intends to suspend or resume the current game state. A controller will have a button dedicated to suspending and resuming play and invoking context sensitive actions. During event handling the system will notify the application using this block such that the application can handle the suspension and resumption from the given controller. Use this to implement your canonical transition to a pause menu for example if that is your application's desired handling of suspension in play. You may pause and resume based on game state as well so the event is only called each time the pause/resume button is pressed. @note This handler has been deprecated in favor of the Menu button found on GCMicroGamepad and GCExtendedGamepad. @see microGamepad @see extendedGamepad
      * @deprecated Use the Menu button found on the controller's input profile, if it exists.
      */
-    controllerPausedHandler(): NobjcObject | null;
-    setControllerPausedHandler$(value: NobjcObject | null): void;
+    controllerPausedHandler(): ((arg0: _GCController) => void) | null;
+    setControllerPausedHandler$(value: ((arg0: _GCController) => void) | null): void;
     /**
      * A controller may be form fitting or otherwise closely attached to the device. This closeness to other inputs on the device may suggest that interaction with the device may use other inputs easily. This is presented to developers to allow them to make informed decisions about UI and interactions to choose for their game in this situation.
      */

package/dist/GameController/GCControllerAxisInput.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _GCControllerElement } from "./GCControllerElement.js";
 export declare class _GCControllerAxisInput extends _GCControllerElement {
     static alloc(): _GCControllerAxisInput;
@@ -8,8 +7,8 @@ export declare class _GCControllerAxisInput extends _GCControllerElement {
      * Sets the normalized value for the input. the value to set the input to. If the controller's snapshot flag is set to NO, this method has no effect. value
      */
     setValue$(value: number): void;
-    valueChangedHandler(): NobjcObject | null;
-    setValueChangedHandler$(value: NobjcObject | null): void;
+    valueChangedHandler(): ((arg0: _GCControllerAxisInput, arg1: number) => void) | null;
+    setValueChangedHandler$(value: ((arg0: _GCControllerAxisInput, arg1: number) => void) | null): void;
     /**
      * A normalized value for the input, between -1 and 1 for axis inputs. The values are deadzoned and saturated before they are returned so there is no value ouside the range. Deadzoning does not remove values from the range, the full 0 to 1 magnitude of values are possible from the input. As an axis is often used in a digital sense, you can rely on a value of 0 meaning the axis is inside the deadzone. Any value greater than or less than zero is not in the deadzone.
      */