objcjs-types 0.4.0 → 0.5.0

package/dist/Vision/index.d.ts

@@ -279,12 +279,15 @@ import type { _VNRequestProgressProviding } from "./VNRequestProgressProviding.j
 export type { _VNRequestProgressProviding };
 import type { _VNRequestRevisionProviding } from "./VNRequestRevisionProviding.js";
 export type { _VNRequestRevisionProviding };
+export { VNBarcodeCompositeType } from "./VNBarcodeCompositeType.js";
+export { VNChirality } from "./VNChirality.js";
 export { VNElementType } from "./VNElementType.js";
 export { VNErrorCode } from "./VNErrorCode.js";
 export { VNGenerateOpticalFlowRequestComputationAccuracy } from "./VNGenerateOpticalFlowRequestComputationAccuracy.js";
 export { VNGeneratePersonSegmentationRequestQualityLevel } from "./VNGeneratePersonSegmentationRequestQualityLevel.js";
 export { VNHumanBodyPose3DObservationHeightEstimation } from "./VNHumanBodyPose3DObservationHeightEstimation.js";
 export { VNImageCropAndScaleOption } from "./VNImageCropAndScaleOption.js";
+export { VNPointsClassification } from "./VNPointsClassification.js";
 export { VNRequestFaceLandmarksConstellation } from "./VNRequestFaceLandmarksConstellation.js";
 export { VNRequestTextRecognitionLevel } from "./VNRequestTextRecognitionLevel.js";
 export { VNRequestTrackingLevel } from "./VNRequestTrackingLevel.js";

package/dist/Vision/index.js

@@ -93,12 +93,15 @@ export const VNVideoProcessorCadence = _bindClass(Vision, "VNVideoProcessorCaden
 export const VNVideoProcessorFrameRateCadence = _bindClass(Vision, "VNVideoProcessorFrameRateCadence");
 export const VNVideoProcessorRequestProcessingOptions = _bindClass(Vision, "VNVideoProcessorRequestProcessingOptions");
 export const VNVideoProcessorTimeIntervalCadence = _bindClass(Vision, "VNVideoProcessorTimeIntervalCadence");
+export { VNBarcodeCompositeType } from "./VNBarcodeCompositeType.js";
+export { VNChirality } from "./VNChirality.js";
 export { VNElementType } from "./VNElementType.js";
 export { VNErrorCode } from "./VNErrorCode.js";
 export { VNGenerateOpticalFlowRequestComputationAccuracy } from "./VNGenerateOpticalFlowRequestComputationAccuracy.js";
 export { VNGeneratePersonSegmentationRequestQualityLevel } from "./VNGeneratePersonSegmentationRequestQualityLevel.js";
 export { VNHumanBodyPose3DObservationHeightEstimation } from "./VNHumanBodyPose3DObservationHeightEstimation.js";
 export { VNImageCropAndScaleOption } from "./VNImageCropAndScaleOption.js";
+export { VNPointsClassification } from "./VNPointsClassification.js";
 export { VNRequestFaceLandmarksConstellation } from "./VNRequestFaceLandmarksConstellation.js";
 export { VNRequestTextRecognitionLevel } from "./VNRequestTextRecognitionLevel.js";
 export { VNRequestTrackingLevel } from "./VNRequestTrackingLevel.js";

package/dist/WebKit/WKContentRuleListStore.d.ts

@@ -1,15 +1,17 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSArray } from "../Foundation/NSArray.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";
+import type { _WKContentRuleList } from "./WKContentRuleList.js";
 export declare class _WKContentRuleListStore extends _NSObject {
     static alloc(): _WKContentRuleListStore;
     static new(): _WKContentRuleListStore;
     init(): _WKContentRuleListStore;
     static defaultStore(): _WKContentRuleListStore;
     static storeWithURL$(url: _NSURL): _WKContentRuleListStore;
-    compileContentRuleListForIdentifier$encodedContentRuleList$completionHandler$(identifier: _NSString, encodedContentRuleList: _NSString, completionHandler: NobjcObject): void;
-    lookUpContentRuleListForIdentifier$completionHandler$(identifier: _NSString, completionHandler: NobjcObject): void;
-    removeContentRuleListForIdentifier$completionHandler$(identifier: _NSString, completionHandler: NobjcObject): void;
-    getAvailableContentRuleListIdentifiers$(completionHandler: NobjcObject): void;
+    compileContentRuleListForIdentifier$encodedContentRuleList$completionHandler$(identifier: _NSString, encodedContentRuleList: _NSString, completionHandler: (arg0: _WKContentRuleList, arg1: _NSError) => void): void;
+    lookUpContentRuleListForIdentifier$completionHandler$(identifier: _NSString, completionHandler: (arg0: _WKContentRuleList, arg1: _NSError) => void): void;
+    removeContentRuleListForIdentifier$completionHandler$(identifier: _NSString, completionHandler: (arg0: _NSError) => void): void;
+    getAvailableContentRuleListIdentifiers$(completionHandler: (arg0: _NSArray) => void): void;
 }

package/dist/WebKit/WKDownload.d.ts

@@ -1,4 +1,5 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSData } from "../Foundation/NSData.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSProgressReporting } from "../Foundation/NSProgressReporting.js";
 import type { _NSURLRequest } from "../Foundation/NSURLRequest.js";
@@ -12,7 +13,7 @@ export declare class _WKDownload extends _NSObject {
     /**
      * Cancel the download. A block to invoke when cancellation is finished. To attempt to resume the download, call WKWebView resumeDownloadFromResumeData: with the data given to the completionHandler. If no resume attempt is possible with this server, completionHandler will be called with nil.
      */
-    cancel$(completionHandler: NobjcObject | null): void;
+    cancel$(completionHandler: ((resumeData: _NSData) => NobjcObject) | null): void;
     /**
      * The request used to initiate this download. If the original request redirected to a different URL, originalRequest will be unchanged after the download follows the redirect.
      */

package/dist/WebKit/WKDownloadDelegate.d.ts

@@ -6,21 +6,25 @@ import type { _NSHTTPURLResponse } from "../Foundation/NSHTTPURLResponse.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 import type { _NSURLAuthenticationChallenge } from "../Foundation/NSURLAuthenticationChallenge.js";
+import type { _NSURLCredential } from "../Foundation/NSURLCredential.js";
 import type { _NSURLRequest } from "../Foundation/NSURLRequest.js";
 import type { _NSURLResponse } from "../Foundation/NSURLResponse.js";
+import type { WKDownloadPlaceholderPolicy } from "./WKDownloadPlaceholderPolicy.js";
+import type { WKDownloadRedirectPolicy } from "./WKDownloadRedirectPolicy.js";
+import type { NSURLSessionAuthChallengeDisposition } from "../Foundation/NSURLSessionAuthChallengeDisposition.js";
 export interface _WKDownloadDelegate {
     /**
      * Invoked when the download needs a location to write the downloaded bytes. The download for which we need a file to which to write. The server response if this download was the result of an HTTP request, or a synthesized response for blob downloads. The suggested filename. The completion handler you must invoke with either a file URL to begin the download or nil to cancel the download. suggestedFilename will often be the same as response.suggestedFilename, but web content can specify the suggested download filename. If the destination file URL is non-null, it must be a file that does not exist in a directory that does exist and can be written to.
      */
-    download$decideDestinationUsingResponse$suggestedFilename$completionHandler$?(download: _WKDownload, response: _NSURLResponse, suggestedFilename: _NSString, completionHandler: NobjcObject | null): void;
+    download$decideDestinationUsingResponse$suggestedFilename$completionHandler$?(download: _WKDownload, response: _NSURLResponse, suggestedFilename: _NSString, completionHandler: ((destination: _NSURL) => NobjcObject) | null): void;
     /**
      * Invoked when the download has received an HTTP redirection response. The download that received the redirect. The redirection response. The new request that will be sent. The completion handler you must invoke to indicate whether or not to proceed with the redirection. If you do not implement this method, all server suggested redirects will be taken.
      */
-    download$willPerformHTTPRedirection$newRequest$decisionHandler$?(download: _WKDownload, response: _NSHTTPURLResponse, request: _NSURLRequest, decisionHandler: NobjcObject): void;
+    download$willPerformHTTPRedirection$newRequest$decisionHandler$?(download: _WKDownload, response: _NSHTTPURLResponse, request: _NSURLRequest, decisionHandler: (arg0: WKDownloadRedirectPolicy) => NobjcObject): void;
     /**
      * Invoked when the download needs to respond to an authentication challenge. The download that received the authentication challenge. The authentication challenge. The completion handler you must invoke to respond to the challenge. The disposition argument is one of the constants of the enumerated type NSURLSessionAuthChallengeDisposition. When disposition is NSURLSessionAuthChallengeUseCredential, the credential argument is the credential to use, or nil to indicate continuing without a credential. If you do not implement this method, the web view will respond to the authentication challenge with the NSURLSessionAuthChallengeRejectProtectionSpace disposition.
      */
-    download$didReceiveAuthenticationChallenge$completionHandler$?(download: _WKDownload, challenge: _NSURLAuthenticationChallenge, completionHandler: NobjcObject | null): void;
+    download$didReceiveAuthenticationChallenge$completionHandler$?(download: _WKDownload, challenge: _NSURLAuthenticationChallenge, completionHandler: ((arg0: NSURLSessionAuthChallengeDisposition, arg1: _NSURLCredential) => NobjcObject) | null): void;
     /**
      * Invoked when the download has finished successfully. The download that finished.
      */
@@ -32,11 +36,11 @@ export interface _WKDownloadDelegate {
     /**
      * Invoked when the download needs a placeholder policy from the client. The download for which we need a placeholder policy The completion handler that should be invoked with the chosen policy. If the client implements it's own placeholder, it can choose to provide an alternate placeholder URL, which progress will be published against. The download will not proceed until the completion handler is called. The placeholder policy specifies whether a placeholder file should be created in the Downloads directory when the download is in progress. This function is called after the destination for the download has been decided, and before the download begins. If the client opts into the placeholder feature, the system will create a placeholder file in the Downloads directory, which is updated with the download's progress. When the download is done, the placeholder file is replaced with the actual downloaded file. If the client opts out of the placeholder feature, it can choose to provide a custom URL to publish progress against. This is useful if the client maintains it's own placeholder file. If this delegate is not implemented, the placeholder feature will be disabled.
      */
-    download$decidePlaceholderPolicy$?(download: _WKDownload, completionHandler: NobjcObject | null): void;
+    download$decidePlaceholderPolicy$?(download: _WKDownload, completionHandler: ((arg0: WKDownloadPlaceholderPolicy, arg1: _NSURL) => NobjcObject) | null): void;
     /**
      * Called when the download receives a placeholder URL The download for which we received a placeholder URL The completion handler that should be called by the client in response to this call. The didReceiveFinalURL function will not be called until the completion handler has been called. This function is called only if the client opted into the placeholder feature, and it is called before receiving the final URL of the download. The placeholder URL will normally refer to a file in the Downloads directory.
      */
-    download$didReceivePlaceholderURL$completionHandler$?(download: _WKDownload, url: _NSURL, completionHandler: NobjcObject): void;
+    download$didReceivePlaceholderURL$completionHandler$?(download: _WKDownload, url: _NSURL, completionHandler: () => NobjcObject): void;
     /**
      * Called when the download receives a final URL The download for which we received a final URL The URL of the final download location This function is called after didReceivePlaceholderURL was called and after the download finished. The final URL will normally refer to a file in the Downloads directory
      */

package/dist/WebKit/WKHTTPCookieStore.d.ts

@@ -9,19 +9,19 @@ export declare class _WKHTTPCookieStore extends _NSObject {
     static new(): _WKHTTPCookieStore;
     init(): _WKHTTPCookieStore;
     /** Fetches all stored cookies. A block to invoke with the fetched cookies. */
-    getAllCookies$(completionHandler: NobjcObject): void;
+    getAllCookies$(completionHandler: (arg0: _NSArray) => NobjcObject): void;
     /**
      * Set a cookie. The cookie to set. A block to invoke once the cookie has been stored.
      */
-    setCookie$completionHandler$(cookie: _NSHTTPCookie, completionHandler: NobjcObject | null): void;
+    setCookie$completionHandler$(cookie: _NSHTTPCookie, completionHandler: (() => NobjcObject) | null): void;
     /**
      * Set multiple cookies. An array of cookies to set. A block to invoke once the cookies have been stored.
      */
-    setCookies$completionHandler$(cookies: _NSArray, completionHandler: NobjcObject | null): void;
+    setCookies$completionHandler$(cookies: _NSArray, completionHandler: (() => NobjcObject) | null): void;
     /**
      * Delete the specified cookie. A block to invoke once the cookie has been deleted.
      */
-    deleteCookie$completionHandler$(cookie: _NSHTTPCookie, completionHandler: NobjcObject | null): void;
+    deleteCookie$completionHandler$(cookie: _NSHTTPCookie, completionHandler: (() => NobjcObject) | null): void;
     /**
      * Adds a WKHTTPCookieStoreObserver object with the cookie store. The observer object to add. The observer is not retained by the receiver. It is your responsibility to unregister the observer before it becomes invalid.
      */
@@ -33,9 +33,9 @@ export declare class _WKHTTPCookieStore extends _NSObject {
     /**
      * Set whether cookies are allowed. A value indicating whether cookies are allowed. The default value is WKCookiePolicyAllow. A block to invoke once the cookie policy has been set.
      */
-    setCookiePolicy$completionHandler$(policy: WKCookiePolicy, completionHandler: NobjcObject | null): void;
+    setCookiePolicy$completionHandler$(policy: WKCookiePolicy, completionHandler: (() => NobjcObject) | null): void;
     /**
      * Get whether cookies are allowed. A block to invoke with the value of whether cookies are allowed.
      */
-    getCookiePolicy$(completionHandler: NobjcObject): void;
+    getCookiePolicy$(completionHandler: (arg0: WKCookiePolicy) => NobjcObject): void;
 }

package/dist/WebKit/WKNavigationDelegate.d.ts

@@ -8,19 +8,23 @@ import type { _WKWebView } from "./WKWebView.js";
 import type { _WKWebpagePreferences } from "./WKWebpagePreferences.js";
 import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSURLAuthenticationChallenge } from "../Foundation/NSURLAuthenticationChallenge.js";
+import type { _NSURLCredential } from "../Foundation/NSURLCredential.js";
+import type { WKNavigationActionPolicy } from "./WKNavigationActionPolicy.js";
+import type { WKNavigationResponsePolicy } from "./WKNavigationResponsePolicy.js";
+import type { NSURLSessionAuthChallengeDisposition } from "../Foundation/NSURLSessionAuthChallengeDisposition.js";
 export interface _WKNavigationDelegate {
     /**
      * Decides whether to allow or cancel a navigation. The web view invoking the delegate method. Descriptive information about the action triggering the navigation request. The decision handler to call to allow or cancel the navigation. The argument is one of the constants of the enumerated type WKNavigationActionPolicy. If you do not implement this method, the web view will load the request or, if appropriate, forward it to another application.
      */
-    webView$decidePolicyForNavigationAction$decisionHandler$?(webView: _WKWebView, navigationAction: _WKNavigationAction, decisionHandler: NobjcObject): void;
+    webView$decidePolicyForNavigationAction$decisionHandler$?(webView: _WKWebView, navigationAction: _WKNavigationAction, decisionHandler: (arg0: WKNavigationActionPolicy) => NobjcObject): void;
     /**
      * Decides whether to allow or cancel a navigation. The web view invoking the delegate method. Descriptive information about the action triggering the navigation request. The default set of webpage preferences. This may be changed by setting defaultWebpagePreferences on WKWebViewConfiguration. The policy decision handler to call to allow or cancel the navigation. The arguments are one of the constants of the enumerated type WKNavigationActionPolicy, as well as an instance of WKWebpagePreferences. If you implement this method, -webView:decidePolicyForNavigationAction:decisionHandler: will not be called.
      */
-    webView$decidePolicyForNavigationAction$preferences$decisionHandler$?(webView: _WKWebView, navigationAction: _WKNavigationAction, preferences: _WKWebpagePreferences, decisionHandler: NobjcObject): void;
+    webView$decidePolicyForNavigationAction$preferences$decisionHandler$?(webView: _WKWebView, navigationAction: _WKNavigationAction, preferences: _WKWebpagePreferences, decisionHandler: (arg0: WKNavigationActionPolicy, arg1: _WKWebpagePreferences) => NobjcObject): void;
     /**
      * Decides whether to allow or cancel a navigation after its response is known. The web view invoking the delegate method. Descriptive information about the navigation response. The decision handler to call to allow or cancel the navigation. The argument is one of the constants of the enumerated type WKNavigationResponsePolicy. If you do not implement this method, the web view will allow the response, if the web view can show it.
      */
-    webView$decidePolicyForNavigationResponse$decisionHandler$?(webView: _WKWebView, navigationResponse: _WKNavigationResponse, decisionHandler: NobjcObject): void;
+    webView$decidePolicyForNavigationResponse$decisionHandler$?(webView: _WKWebView, navigationResponse: _WKNavigationResponse, decisionHandler: (arg0: WKNavigationResponsePolicy) => NobjcObject): void;
     /**
      * Invoked when a main frame navigation starts. The web view invoking the delegate method. The navigation.
      */
@@ -48,7 +52,7 @@ export interface _WKNavigationDelegate {
     /**
      * Invoked when the web view needs to respond to an authentication challenge. The web view that received the authentication challenge. The authentication challenge. The completion handler you must invoke to respond to the challenge. The disposition argument is one of the constants of the enumerated type NSURLSessionAuthChallengeDisposition. When disposition is NSURLSessionAuthChallengeUseCredential, the credential argument is the credential to use, or nil to indicate continuing without a credential. If you do not implement this method, the web view will respond to the authentication challenge with the NSURLSessionAuthChallengeRejectProtectionSpace disposition.
      */
-    webView$didReceiveAuthenticationChallenge$completionHandler$?(webView: _WKWebView, challenge: _NSURLAuthenticationChallenge, completionHandler: NobjcObject | null): void;
+    webView$didReceiveAuthenticationChallenge$completionHandler$?(webView: _WKWebView, challenge: _NSURLAuthenticationChallenge, completionHandler: ((disposition: NSURLSessionAuthChallengeDisposition, credential: _NSURLCredential) => NobjcObject) | null): void;
     /**
      * Invoked when the web view's web content process is terminated. The web view whose underlying web content process was terminated.
      */
@@ -56,7 +60,7 @@ export interface _WKNavigationDelegate {
     /**
      * Invoked when the web view is establishing a network connection using a deprecated version of TLS. The web view initiating the connection. The authentication challenge. The decision handler you must invoke to respond to indicate whether or not to continue with the connection establishment.
      */
-    webView$authenticationChallenge$shouldAllowDeprecatedTLS$?(webView: _WKWebView, challenge: _NSURLAuthenticationChallenge, decisionHandler: NobjcObject): void;
+    webView$authenticationChallenge$shouldAllowDeprecatedTLS$?(webView: _WKWebView, challenge: _NSURLAuthenticationChallenge, decisionHandler: (arg0: boolean) => NobjcObject): void;
     /**
      * Called after using WKNavigationActionPolicyDownload. The web view that created the download. The action that is being turned into a download. The download. The download needs its delegate to be set to receive updates about its progress.
      */
@@ -68,5 +72,5 @@ export interface _WKNavigationDelegate {
     /**
      * Called when the webpage initiates a back/forward navigation via JavaScript The web view invoking the delegate method. The back/forward list item that will be navigated to Whether or not the navigation will resume a previously suspended webpage that is eligible for Instant Back The completion handler you must invoke to allow or disallow the navigation Back/forward navigations - including those triggered by webpage JavaScript - will consult the WebKit client via this delegate. If the `willUseInstantBack` argument is `YES`, then the navigation is to a webpage that is suspended in memory and might be resumed without the normal webpage loading process. Even if the `willUseInstantBack` argument is `YES`, it is possible that the suspended webpage will not be used and the normal loading process will take place. In the case where the normal webpage loading process takes place, additional navigation delegate calls will continue to happen for this navigation starting with `decidePolicyForNavigationAction`
      */
-    webView$shouldGoToBackForwardListItem$willUseInstantBack$completionHandler$?(webView: _WKWebView, backForwardListItem: _WKBackForwardListItem, willUseInstantBack: boolean, completionHandler: NobjcObject): void;
+    webView$shouldGoToBackForwardListItem$willUseInstantBack$completionHandler$?(webView: _WKWebView, backForwardListItem: _WKBackForwardListItem, willUseInstantBack: boolean, completionHandler: (shouldGoToItem: boolean) => void): void;
 }

package/dist/WebKit/WKScriptMessageHandlerWithReply.d.ts

@@ -1,9 +1,10 @@
 import type { NobjcObject } from "objc-js";
 import type { _WKScriptMessage } from "./WKScriptMessage.js";
 import type { _WKUserContentController } from "./WKUserContentController.js";
+import type { _NSString } from "../Foundation/NSString.js";
 export interface _WKScriptMessageHandlerWithReply {
     /**
      * Invoked when a script message is received from a webpage. The user content controller invoking the delegate method. The script message received. A block to be called with the result of processing the message. When the JavaScript running in your application's web content called window.webkit.messageHandlers. <name >.postMessage( <messageBody >), a JavaScript Promise object was returned. The values passed to the replyHandler are used to resolve that Promise. Passing a non-nil NSString value to the second parameter of the replyHandler signals an error. No matter what value you pass to the first parameter of the replyHandler, the Promise will be rejected with a JavaScript error object whose message property is set to that errorMessage string. If the second parameter to the replyHandler is nil, the first argument will be serialized into its JavaScript equivalent and the Promise will be fulfilled with the resulting value. If the first argument is nil then the Promise will be resolved with a JavaScript value of "undefined" Allowed non-nil result types are: NSNumber, NSNull, NSString, NSDate, NSArray, and NSDictionary. Any NSArray or NSDictionary containers can only contain objects of those types. The replyHandler can be called at most once. If the replyHandler is deallocated before it is called, the Promise will be rejected with a JavaScript Error object with an appropriate message indicating the handler was never called. Example: With a WKScriptMessageHandlerWithReply object installed with the name "testHandler", consider the following JavaScript: And consider the following WKScriptMessageHandlerWithReply implementation: In this example: - The JavaScript code sends a message to your application code with the body " Fulfill me with 42" - JavaScript execution is suspended while waiting for the resulting promise to resolve. - Your message handler is invoked with that message and a block to call with the reply when ready. - Your message handler sends the value @ 42 as a reply. - The JavaScript promise is fulfilled with the value 42. - JavaScript execution continues and the value 42 is returned.
      */
-    userContentController$didReceiveScriptMessage$replyHandler$?(userContentController: _WKUserContentController, message: _WKScriptMessage, replyHandler: NobjcObject | null): void;
+    userContentController$didReceiveScriptMessage$replyHandler$?(userContentController: _WKUserContentController, message: _WKScriptMessage, replyHandler: ((reply: NobjcObject, errorMessage: _NSString) => NobjcObject) | null): void;
 }

package/dist/WebKit/WKUIDelegate.d.ts

@@ -6,8 +6,10 @@ import type { _WKSecurityOrigin } from "./WKSecurityOrigin.js";
 import type { _WKWebView } from "./WKWebView.js";
 import type { _WKWebViewConfiguration } from "./WKWebViewConfiguration.js";
 import type { _WKWindowFeatures } from "./WKWindowFeatures.js";
+import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { WKMediaCaptureType } from "./WKMediaCaptureType.js";
+import type { WKPermissionDecision } from "./WKPermissionDecision.js";
 export interface _WKUIDelegate {
     /**
      * Creates a new web view. The web view invoking the delegate method. The configuration to use when creating the new web view. This configuration is a copy of webView.configuration. The navigation action causing the new web view to be created. Window features requested by the webpage. A new web view or nil. The web view returned must be created with the specified configuration. WebKit will load the request in the returned web view. If you do not implement this method, the web view will cancel the navigation.
@@ -20,25 +22,25 @@ export interface _WKUIDelegate {
     /**
      * Displays a JavaScript alert panel. The web view invoking the delegate method. The message to display. Information about the frame whose JavaScript initiated this call. The completion handler to call after the alert panel has been dismissed. For user security, your app should call attention to the fact that a specific website controls the content in this panel. A simple forumla for identifying the controlling website is frame.request.URL.host. The panel should have a single OK button. If you do not implement this method, the web view will behave as if the user selected the OK button.
      */
-    webView$runJavaScriptAlertPanelWithMessage$initiatedByFrame$completionHandler$?(webView: _WKWebView, message: _NSString, frame: _WKFrameInfo, completionHandler: NobjcObject): void;
+    webView$runJavaScriptAlertPanelWithMessage$initiatedByFrame$completionHandler$?(webView: _WKWebView, message: _NSString, frame: _WKFrameInfo, completionHandler: () => NobjcObject): void;
     /**
      * Displays a JavaScript confirm panel. The web view invoking the delegate method. The message to display. Information about the frame whose JavaScript initiated this call. The completion handler to call after the confirm panel has been dismissed. Pass YES if the user chose OK, NO if the user chose Cancel. For user security, your app should call attention to the fact that a specific website controls the content in this panel. A simple forumla for identifying the controlling website is frame.request.URL.host. The panel should have two buttons, such as OK and Cancel. If you do not implement this method, the web view will behave as if the user selected the Cancel button.
      */
-    webView$runJavaScriptConfirmPanelWithMessage$initiatedByFrame$completionHandler$?(webView: _WKWebView, message: _NSString, frame: _WKFrameInfo, completionHandler: NobjcObject): void;
+    webView$runJavaScriptConfirmPanelWithMessage$initiatedByFrame$completionHandler$?(webView: _WKWebView, message: _NSString, frame: _WKFrameInfo, completionHandler: (result: boolean) => NobjcObject): void;
     /**
      * Displays a JavaScript text input panel. The web view invoking the delegate method. The prompt to display. The initial text to display in the text entry field. Information about the frame whose JavaScript initiated this call. The completion handler to call after the text input panel has been dismissed. Pass the entered text if the user chose OK, otherwise nil. For user security, your app should call attention to the fact that a specific website controls the content in this panel. A simple forumla for identifying the controlling website is frame.request.URL.host. The panel should have two buttons, such as OK and Cancel, and a field in which to enter text. If you do not implement this method, the web view will behave as if the user selected the Cancel button.
      */
-    webView$runJavaScriptTextInputPanelWithPrompt$defaultText$initiatedByFrame$completionHandler$?(webView: _WKWebView, prompt: _NSString, defaultText: _NSString | null, frame: _WKFrameInfo, completionHandler: NobjcObject | null): void;
+    webView$runJavaScriptTextInputPanelWithPrompt$defaultText$initiatedByFrame$completionHandler$?(webView: _WKWebView, prompt: _NSString, defaultText: _NSString | null, frame: _WKFrameInfo, completionHandler: ((result: _NSString) => NobjcObject) | null): void;
     /**
      * A delegate to request permission for microphone audio and camera video access. The web view invoking the delegate method. The origin of the page. Information about the frame whose JavaScript initiated this call. The type of capture (camera, microphone). The completion handler to call once the decision is made If not implemented, the result is the same as calling the decisionHandler with WKPermissionDecisionPrompt.
      */
-    webView$requestMediaCapturePermissionForOrigin$initiatedByFrame$type$decisionHandler$?(webView: _WKWebView, origin: _WKSecurityOrigin, frame: _WKFrameInfo, type: WKMediaCaptureType, decisionHandler: NobjcObject): void;
+    webView$requestMediaCapturePermissionForOrigin$initiatedByFrame$type$decisionHandler$?(webView: _WKWebView, origin: _WKSecurityOrigin, frame: _WKFrameInfo, type: WKMediaCaptureType, decisionHandler: (decision: WKPermissionDecision) => NobjcObject): void;
     /**
      * Allows your app to determine whether or not the given security origin should have access to the device's orientation and motion. The security origin which requested access to the device's orientation and motion. The frame that initiated the request. The decision handler to call once the app has made its decision.
      */
-    webView$requestDeviceOrientationAndMotionPermissionForOrigin$initiatedByFrame$decisionHandler$?(webView: _WKWebView, origin: _WKSecurityOrigin, frame: _WKFrameInfo, decisionHandler: NobjcObject): void;
+    webView$requestDeviceOrientationAndMotionPermissionForOrigin$initiatedByFrame$decisionHandler$?(webView: _WKWebView, origin: _WKSecurityOrigin, frame: _WKFrameInfo, decisionHandler: (decision: WKPermissionDecision) => NobjcObject): void;
     /**
      * Displays a file upload panel. The web view invoking the delegate method. Parameters describing the file upload control. Information about the frame whose file upload control initiated this call. The completion handler to call after open panel has been dismissed. Pass the selected URLs if the user chose OK, otherwise nil. If you do not implement this method on macOS, the web view will behave as if the user selected the Cancel button. If you do not implement this method on iOS or visionOS, the web view will match the file upload behavior of Safari. If you desire the web view to act as if the user selected the Cancel button on iOS or visionOS, immediately call the completion handler with nil.
      */
-    webView$runOpenPanelWithParameters$initiatedByFrame$completionHandler$?(webView: _WKWebView, parameters: _WKOpenPanelParameters, frame: _WKFrameInfo, completionHandler: NobjcObject | null): void;
+    webView$runOpenPanelWithParameters$initiatedByFrame$completionHandler$?(webView: _WKWebView, parameters: _WKOpenPanelParameters, frame: _WKFrameInfo, completionHandler: ((URLs: _NSArray) => NobjcObject) | null): void;
 }

package/dist/WebKit/WKWebExtension.d.ts

@@ -1,7 +1,7 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSBundle } from "../Foundation/NSBundle.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSLocale } from "../Foundation/NSLocale.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
@@ -16,11 +16,11 @@ export declare class _WKWebExtension extends _NSObject {
     /**
      * Returns a web extension initialized with a specified app extension bundle. The bundle to use for the new web extension. A block to be called with an initialized web extension, or if the object could not be initialized due to an error. The app extension bundle must contain a `manifest.json` file in its resources directory. If the manifest is invalid or missing, or the bundle is otherwise improperly configured, an error will be returned.
      */
-    static extensionWithAppExtensionBundle$completionHandler$(appExtensionBundle: _NSBundle, completionHandler: NobjcObject | null): void;
+    static extensionWithAppExtensionBundle$completionHandler$(appExtensionBundle: _NSBundle, completionHandler: ((extension: _WKWebExtension, error: _NSError) => void) | null): void;
     /**
      * Returns a web extension initialized with a specified resource base URL, which can point to either a directory or a ZIP archive. The file URL to use for the new web extension. A block to be called with an initialized web extension, or if the object could not be initialized due to an error. The URL must be a file URL that points to either a directory with a `manifest.json` file or a ZIP archive containing a `manifest.json` file. If the manifest is invalid or missing, or the URL points to an unsupported format or invalid archive, an error will be returned.
      */
-    static extensionWithResourceBaseURL$completionHandler$(resourceBaseURL: _NSURL, completionHandler: NobjcObject | null): void;
+    static extensionWithResourceBaseURL$completionHandler$(resourceBaseURL: _NSURL, completionHandler: ((extension: _WKWebExtension, error: _NSError) => void) | null): void;
     /**
      * Checks if a manifest version is supported by the extension. The version number to check. Returns `YES` if the extension specified a manifest version that is greater than or equal to `manifestVersion`.
      */

package/dist/WebKit/WKWebExtensionContext.d.ts

@@ -1,7 +1,7 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDate } from "../Foundation/NSDate.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -101,7 +101,7 @@ export declare class _WKWebExtensionContext extends _NSObject {
     /**
      * Loads the background content if needed for the extension. A block to be called upon completion of the loading process, with an optional error. This method forces the loading of the background content for the extension that will otherwise be loaded on-demand during specific events. It is useful when the app requires the background content to be loaded for other reasons. If the background content is already loaded, the completion handler will be called immediately. An error will occur if the extension does not have any background content to load or loading fails.
      */
-    loadBackgroundContentWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    loadBackgroundContentWithCompletionHandler$(completionHandler: ((error: _NSError) => void) | null): void;
     /**
      * Retrieves the extension action for a given tab, or the default action if `nil` is passed. The tab for which to retrieve the extension action, or `nil` to get the default action. The returned object represents the action specific to the tab when provided; otherwise, it returns the default action. The default action is useful when the context is unrelated to a specific tab. When possible, specify the tab to get the most context-relevant action. performActionForTab:
      */

package/dist/WebKit/WKWebExtensionContextError.d.ts

@@ -0,0 +1,9 @@
+export declare const WKWebExtensionContextError: {
+    readonly Unknown: 1;
+    readonly AlreadyLoaded: 2;
+    readonly NotLoaded: 3;
+    readonly BaseURLAlreadyInUse: 4;
+    readonly NoBackgroundContent: 5;
+    readonly BackgroundContentFailedToLoad: 6;
+};
+export type WKWebExtensionContextError = typeof WKWebExtensionContextError[keyof typeof WKWebExtensionContextError];

package/dist/WebKit/WKWebExtensionContextError.js

@@ -0,0 +1,9 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const WKWebExtensionContextError = {
+    Unknown: 1,
+    AlreadyLoaded: 2,
+    NotLoaded: 3,
+    BaseURLAlreadyInUse: 4,
+    NoBackgroundContent: 5,
+    BackgroundContentFailedToLoad: 6,
+};

package/dist/WebKit/WKWebExtensionController.d.ts

@@ -7,6 +7,7 @@ import type { _WKWebExtension } from "./WKWebExtension.js";
 import type { _WKWebExtensionContext } from "./WKWebExtensionContext.js";
 import type { _WKWebExtensionControllerConfiguration } from "./WKWebExtensionControllerConfiguration.js";
 import type { _WKWebExtensionControllerDelegate } from "./WKWebExtensionControllerDelegate.js";
+import type { _WKWebExtensionDataRecord } from "./WKWebExtensionDataRecord.js";
 import type { _WKWebExtensionTab } from "./WKWebExtensionTab.js";
 import type { _WKWebExtensionWindow } from "./WKWebExtensionWindow.js";
 import type { WKWebExtensionTabChangedProperties } from "./WKWebExtensionTabChangedProperties.js";
@@ -42,15 +43,15 @@ export declare class _WKWebExtensionController extends _NSObject {
     /**
      * Fetches data records containing the given extension data types for all known extensions. The extension data types to fetch records for. A block to invoke when the data records have been fetched. The extension does not need to be loaded to be included in the result.
      */
-    fetchDataRecordsOfTypes$completionHandler$(dataTypes: _NSSet, completionHandler: NobjcObject): void;
+    fetchDataRecordsOfTypes$completionHandler$(dataTypes: _NSSet, completionHandler: (arg0: _NSArray) => void): void;
     /**
      * Fetches a data record containing the given extension data types for a specific known web extension context. The extension data types to fetch records for. The specific web extension context to fetch records for. A block to invoke when the data record has been fetched. The extension does not need to be loaded to be included in the result.
      */
-    fetchDataRecordOfTypes$forExtensionContext$completionHandler$(dataTypes: _NSSet, extensionContext: _WKWebExtensionContext, completionHandler: NobjcObject | null): void;
+    fetchDataRecordOfTypes$forExtensionContext$completionHandler$(dataTypes: _NSSet, extensionContext: _WKWebExtensionContext, completionHandler: ((arg0: _WKWebExtensionDataRecord) => void) | null): void;
     /**
      * Removes extension data of the given types for the given data records. The extension data types that should be removed. The extension data records to delete data from. A block to invoke when the data has been removed.
      */
-    removeDataOfTypes$fromDataRecords$completionHandler$(dataTypes: _NSSet, dataRecords: _NSArray, completionHandler: NobjcObject): void;
+    removeDataOfTypes$fromDataRecords$completionHandler$(dataTypes: _NSSet, dataRecords: _NSArray, completionHandler: () => void): void;
     /**
      * Should be called by the app when a new window is opened to fire appropriate events with all loaded web extensions. The newly opened window. This method informs all loaded extensions of the opening of a new window, ensuring consistent understanding across extensions. If the intention is to inform only a specific extension, you should use the respective method on that extension's context instead. didCloseWindow:
      */

package/dist/WebKit/WKWebExtensionControllerDelegate.d.ts

@@ -1,5 +1,7 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSDate } from "../Foundation/NSDate.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _WKWebExtensionAction } from "./WKWebExtensionAction.js";
@@ -22,27 +24,27 @@ export interface _WKWebExtensionControllerDelegate {
     /**
      * @abstract Called when an extension context requests a new window to be opened. @param controller The web extension controller that is managing the extension. @param configuration The configuration specifying how the new window should be created. @param extensionContext The context in which the web extension is running. @param completionHandler A block to be called with the newly created window or \c nil if the window wasn't created. An error should be provided if any errors occurred. @discussion This method should be implemented by the app to handle requests to open new windows. The app can decide how to handle the process based on the provided configuration and existing windows. Once handled, the app should call the completion handler with the opened window or `nil` if the request was declined or failed. If not implemented, the extension will be unable to open new windows.
      */
-    webExtensionController$openNewWindowUsingConfiguration$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, configuration: _WKWebExtensionWindowConfiguration, extensionContext: _WKWebExtensionContext, completionHandler: NobjcObject | null): void;
+    webExtensionController$openNewWindowUsingConfiguration$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, configuration: _WKWebExtensionWindowConfiguration, extensionContext: _WKWebExtensionContext, completionHandler: ((newWindow: _WKWebExtensionWindow, error: _NSError) => void) | null): void;
     /**
      * @abstract Called when an extension context requests a new tab to be opened. @param controller The web extension controller that is managing the extension. @param configuration The configuration specifying how the new tab should be created. @param extensionContext The context in which the web extension is running. @param completionHandler A block to be called with the newly created tab or \c nil if the tab wasn't created. An error should be provided if any errors occurred. @discussion This method should be implemented by the app to handle requests to open new tabs. The app can decide how to handle the process based on the provided configuration and existing tabs. Once handled, the app should call the completion handler with the opened tab or `nil` if the request was declined or failed. If not implemented, the extension will be unable to open new tabs.
      */
-    webExtensionController$openNewTabUsingConfiguration$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, configuration: _WKWebExtensionTabConfiguration, extensionContext: _WKWebExtensionContext, completionHandler: NobjcObject | null): void;
+    webExtensionController$openNewTabUsingConfiguration$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, configuration: _WKWebExtensionTabConfiguration, extensionContext: _WKWebExtensionContext, completionHandler: ((newTab: _WKWebExtensionTab, error: _NSError) => void) | null): void;
     /**
      * @abstract Called when an extension context requests its options page to be opened. @param controller The web extension controller that is managing the extension. @param extensionContext The context in which the web extension is running. @param completionHandler A block to be called once the options page has been displayed or with an error if the page could not be shown. @discussion This method should be implemented by the app to handle requests to display the extension's options page. The app can decide how and where to display the options page (e.g., in a new tab or a separate window). The app should call the completion handler once the options page is visible to the user, or with an error if the operation was declined or failed. If not implemented, the options page will be opened in a new tab using the ``webExtensionController:openNewTabUsingConfiguration:forExtensionContext:completionHandler:`` delegate method.
      */
-    webExtensionController$openOptionsPageForExtensionContext$completionHandler$?(controller: _WKWebExtensionController, extensionContext: _WKWebExtensionContext, completionHandler: NobjcObject | null): void;
+    webExtensionController$openOptionsPageForExtensionContext$completionHandler$?(controller: _WKWebExtensionController, extensionContext: _WKWebExtensionContext, completionHandler: ((error: _NSError) => void) | null): void;
     /**
      * @abstract Called when an extension context requests permissions. @param controller The web extension controller that is managing the extension. @param permissions The set of permissions being requested by the extension. @param tab The tab in which the extension is running, or \c nil if the request is not specific to a tab. @param extensionContext The context in which the web extension is running. @param completionHandler A block to be called with the set of allowed permissions and an optional expiration date. @discussion This method should be implemented by the app to prompt the user for permission and call the completion handler with the set of permissions that were granted and an optional expiration date. If not implemented or the completion handler is not called within a reasonable amount of time, the request is assumed to have been denied. The expiration date can be used to specify when the permissions expire. If `nil`, permissions are assumed to not expire.
      */
-    webExtensionController$promptForPermissions$inTab$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, permissions: _NSSet, tab: _WKWebExtensionTab | null, extensionContext: _WKWebExtensionContext, completionHandler: NobjcObject | null): void;
+    webExtensionController$promptForPermissions$inTab$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, permissions: _NSSet, tab: _WKWebExtensionTab | null, extensionContext: _WKWebExtensionContext, completionHandler: ((allowedPermissions: _NSSet, expirationDate: _NSDate) => void) | null): void;
     /**
      * @abstract Called when an extension context requests access to a set of URLs. @param controller The web extension controller that is managing the extension. @param urls The set of URLs that the extension is requesting access to. @param tab The tab in which the extension is running, or \c nil if the request is not specific to a tab. @param extensionContext The context in which the web extension is running. @param completionHandler A block to be called with the set of allowed URLs and an optional expiration date. @discussion This method should be implemented by the app to prompt the user for permission and call the completion handler with the set of URLs that were granted access to and an optional expiration date. If not implemented or the completion handler is not called within a reasonable amount of time, the request is assumed to have been denied. The expiration date can be used to specify when the URLs expire. If `nil`, URLs are assumed to not expire.
      */
-    webExtensionController$promptForPermissionToAccessURLs$inTab$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, urls: _NSSet, tab: _WKWebExtensionTab | null, extensionContext: _WKWebExtensionContext, completionHandler: NobjcObject | null): void;
+    webExtensionController$promptForPermissionToAccessURLs$inTab$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, urls: _NSSet, tab: _WKWebExtensionTab | null, extensionContext: _WKWebExtensionContext, completionHandler: ((allowedURLs: _NSSet, expirationDate: _NSDate) => void) | null): void;
     /**
      * @abstract Called when an extension context requests access to a set of match patterns. @param controller The web extension controller that is managing the extension. @param matchPatterns The set of match patterns that the extension is requesting access to. @param tab The tab in which the extension is running, or \c nil if the request is not specific to a tab. @param extensionContext The context in which the web extension is running. @param completionHandler A block to be called with the set of allowed match patterns and an optional expiration date. @discussion This method should be implemented by the app to prompt the user for permission and call the completion handler with the set of match patterns that were granted access to and an optional expiration date. If not implemented or the completion handler is not called within a reasonable amount of time, the request is assumed to have been denied. The expiration date can be used to specify when the match patterns expire. If `nil`, match patterns are assumed to not expire.
      */
-    webExtensionController$promptForPermissionMatchPatterns$inTab$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, matchPatterns: _NSSet, tab: _WKWebExtensionTab | null, extensionContext: _WKWebExtensionContext, completionHandler: NobjcObject | null): void;
+    webExtensionController$promptForPermissionMatchPatterns$inTab$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, matchPatterns: _NSSet, tab: _WKWebExtensionTab | null, extensionContext: _WKWebExtensionContext, completionHandler: ((allowedMatchPatterns: _NSSet, expirationDate: _NSDate) => void) | null): void;
     /**
      * @abstract Called when an action's properties are updated. @param controller The web extension controller initiating the request. @param action The web extension action whose properties are updated. @param context The context within which the web extension is running. @discussion This method is called when an action's properties are updated and should be reflected in the app's user interface. The app should ensure that any visible changes, such as icons and labels, are updated accordingly.
      */
@@ -50,13 +52,13 @@ export interface _WKWebExtensionControllerDelegate {
     /**
      * @abstract Called when a popup is requested to be displayed for a specific action. @param controller The web extension controller initiating the request. @param action The action for which the popup is requested. @param context The context within which the web extension is running. @param completionHandler A block to be called once the popup display operation is completed. @discussion This method is called in response to the extension's scripts or when invoking ``performActionForTab:`` if the action has a popup. The associated tab, if applicable, can be located through the ``associatedTab`` property of the ``action`` parameter. This delegate method is called when the web view for the popup is fully loaded and ready to display. Implementing this method is needed if the app intends to support programmatically showing the popup by the extension, although it is recommended for handling both programmatic and user-initiated cases.
      */
-    webExtensionController$presentPopupForAction$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, action: _WKWebExtensionAction, context: _WKWebExtensionContext, completionHandler: NobjcObject | null): void;
+    webExtensionController$presentPopupForAction$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, action: _WKWebExtensionAction, context: _WKWebExtensionContext, completionHandler: ((error: _NSError) => void) | null): void;
     /**
      * @abstract Called when an extension context wants to send a one-time message to an application. @param controller The web extension controller that is managing the extension. @param message The message to be sent. @param applicationIdentifier The unique identifier for the application, or \c nil if none was specified. @param extensionContext The context in which the web extension is running. @param replyHandler A block to be called with a JSON-serializable reply message or an error. @discussion This method should be implemented by the app to handle one-off messages to applications. If not implemented, the default behavior is to pass the message to the app extension handler within the extension's bundle, if the extension was loaded from an app extension bundle; otherwise, no action is performed if not implemented. @note The reply message must be JSON-serializable according to ``NSJSONSerialization``.
      */
-    webExtensionController$sendMessage$toApplicationWithIdentifier$forExtensionContext$replyHandler$?(controller: _WKWebExtensionController, message: NobjcObject, applicationIdentifier: _NSString | null, extensionContext: _WKWebExtensionContext, replyHandler: NobjcObject | null): void;
+    webExtensionController$sendMessage$toApplicationWithIdentifier$forExtensionContext$replyHandler$?(controller: _WKWebExtensionController, message: NobjcObject, applicationIdentifier: _NSString | null, extensionContext: _WKWebExtensionContext, replyHandler: ((replyMessage: NobjcObject, error: _NSError) => void) | null): void;
     /**
      * @abstract Called when an extension context wants to establish a persistent connection to an application. @param controller The web extension controller that is managing the extension. @param extensionContext The context in which the web extension is running. @param port A port object for handling the message exchange. @param completionHandler A block to be called when the connection is ready to use, taking an optional error. If the connection is successfully established, the error should be \c nil. @discussion This method should be implemented by the app to handle establishing connections to applications. The provided ``WKWebExtensionPort`` object can be used to handle message sending, receiving, and disconnection. You should retain the port object for as long as the connection remains active. Releasing the port will disconnect it. If not implemented, the default behavior is to pass the messages to the app extension handler within the extension's bundle, if the extension was loaded from an app extension bundle; otherwise, no action is performed if not implemented.
      */
-    webExtensionController$connectUsingMessagePort$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, port: _WKWebExtensionMessagePort, extensionContext: _WKWebExtensionContext, completionHandler: NobjcObject | null): void;
+    webExtensionController$connectUsingMessagePort$forExtensionContext$completionHandler$?(controller: _WKWebExtensionController, port: _WKWebExtensionMessagePort, extensionContext: _WKWebExtensionContext, completionHandler: ((error: _NSError) => void) | null): void;
 }

package/dist/WebKit/WKWebExtensionDataRecordError.d.ts

@@ -0,0 +1,7 @@
+export declare const WKWebExtensionDataRecordError: {
+    readonly Unknown: 1;
+    readonly LocalStorageFailed: 2;
+    readonly SessionStorageFailed: 3;
+    readonly SynchronizedStorageFailed: 4;
+};
+export type WKWebExtensionDataRecordError = typeof WKWebExtensionDataRecordError[keyof typeof WKWebExtensionDataRecordError];

package/dist/WebKit/WKWebExtensionDataRecordError.js

@@ -0,0 +1,7 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const WKWebExtensionDataRecordError = {
+    Unknown: 1,
+    LocalStorageFailed: 2,
+    SessionStorageFailed: 3,
+    SynchronizedStorageFailed: 4,
+};

package/dist/WebKit/WKWebExtensionError.d.ts

@@ -0,0 +1,12 @@
+export declare const WKWebExtensionError: {
+    readonly Unknown: 1;
+    readonly ResourceNotFound: 2;
+    readonly InvalidResourceCodeSignature: 3;
+    readonly InvalidManifest: 4;
+    readonly UnsupportedManifestVersion: 5;
+    readonly InvalidManifestEntry: 6;
+    readonly InvalidDeclarativeNetRequestEntry: 7;
+    readonly InvalidBackgroundPersistence: 8;
+    readonly InvalidArchive: 9;
+};
+export type WKWebExtensionError = typeof WKWebExtensionError[keyof typeof WKWebExtensionError];

package/dist/WebKit/WKWebExtensionError.js

@@ -0,0 +1,12 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const WKWebExtensionError = {
+    Unknown: 1,
+    ResourceNotFound: 2,
+    InvalidResourceCodeSignature: 3,
+    InvalidManifest: 4,
+    UnsupportedManifestVersion: 5,
+    InvalidManifestEntry: 6,
+    InvalidDeclarativeNetRequestEntry: 7,
+    InvalidBackgroundPersistence: 8,
+    InvalidArchive: 9,
+};

package/dist/WebKit/WKWebExtensionMatchPatternError.d.ts

@@ -0,0 +1,7 @@
+export declare const WKWebExtensionMatchPatternError: {
+    readonly Unknown: 1;
+    readonly InvalidScheme: 2;
+    readonly InvalidHost: 3;
+    readonly InvalidPath: 4;
+};
+export type WKWebExtensionMatchPatternError = typeof WKWebExtensionMatchPatternError[keyof typeof WKWebExtensionMatchPatternError];

package/dist/WebKit/WKWebExtensionMatchPatternError.js

@@ -0,0 +1,7 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const WKWebExtensionMatchPatternError = {
+    Unknown: 1,
+    InvalidScheme: 2,
+    InvalidHost: 3,
+    InvalidPath: 4,
+};

package/dist/WebKit/WKWebExtensionMessagePort.d.ts

@@ -9,7 +9,7 @@ export declare class _WKWebExtensionMessagePort extends _NSObject {
     /**
      * Sends a message to the connected web extension. The JSON-serializable message to be sent. An optional block to be invoked after the message is sent, taking an optional error. The message must be JSON-serializable according to ``NSJSONSerialization``.
      */
-    sendMessage$completionHandler$(message: NobjcObject | null, completionHandler: NobjcObject | null): void;
+    sendMessage$completionHandler$(message: NobjcObject | null, completionHandler: ((error: _NSError) => void) | null): void;
     /** Disconnects the port, terminating all further messages. */
     disconnect(): void;
     /**
@@ -23,13 +23,13 @@ export declare class _WKWebExtensionMessagePort extends _NSObject {
     /**
      * The block to be executed when a message is received from the web extension. An optional block to be invoked when a message is received, taking two parameters: the message and an optional error.
      */
-    messageHandler(): NobjcObject | null;
-    setMessageHandler$(value: NobjcObject | null): void;
+    messageHandler(): ((arg0: NobjcObject, arg1: _NSError) => void) | null;
+    setMessageHandler$(value: ((arg0: NobjcObject, arg1: _NSError) => void) | null): void;
     /**
      * The block to be executed when the port disconnects. An optional block to be invoked when the port disconnects, taking an optional error that indicates if the disconnection was caused by an error.
      */
-    disconnectHandler(): NobjcObject | null;
-    setDisconnectHandler$(value: NobjcObject | null): void;
+    disconnectHandler(): ((arg0: _NSError) => void) | null;
+    setDisconnectHandler$(value: ((arg0: _NSError) => void) | null): void;
     /** Indicates whether the message port is disconnected. */
     disconnected(): boolean;
 }

package/dist/WebKit/WKWebExtensionMessagePortError.d.ts

@@ -0,0 +1,6 @@
+export declare const WKWebExtensionMessagePortError: {
+    readonly Unknown: 1;
+    readonly NotConnected: 2;
+    readonly MessageInvalid: 3;
+};
+export type WKWebExtensionMessagePortError = typeof WKWebExtensionMessagePortError[keyof typeof WKWebExtensionMessagePortError];

package/dist/WebKit/WKWebExtensionMessagePortError.js

@@ -0,0 +1,6 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const WKWebExtensionMessagePortError = {
+    Unknown: 1,
+    NotConnected: 2,
+    MessageInvalid: 3,
+};