objcjs-types 0.3.0 → 0.5.0

package/dist/AppKit/NSDocument.d.ts

@@ -87,23 +87,23 @@ export declare class _NSDocument extends _NSObject {
     /**
      * Given a block that will perform work that might result in the presentation of modal UI, wait for any work scheduled by previous invocations of this method to be completed, and then invoke the block. The block is passed another block, the activity completion handler, which must be invoked when the activity is complete. There are two kinds of waiting possible, synchronous and asynchronous. Which one is used is controlled by the waitSynchronously parameter. If the value for that parameter is YES then this method does not return until previous activities are complete and the passed-in block has been invoked. If it is NO then the passed-in block might not be invoked before this method has returned. It might instead be invoked later, on the main thread, after previous activities are complete. This method's primary use is to wait for asynchronous saving, a new feature that was introduced in Mac OS 10.7. With asynchronous saving it is possible for the user to instigate a user interface action that might present modal UI, a sheet for example, when asynchronous saving is about to fail and present an error alert sheet of its own, which would not work. This method solves that problem. If your NSDocument subclass supports asynchronous saving you should invoke this method around the performance of any work that might cause the presentation of modal UI, regardless of whether that work is performed synchronously or asynchronously. Here is a list of NSDocument methods whose default implementations invoke this method because they might present sheets, either to ask the user what to do as they begin their work or because they may fail and present errors to user: -revertDocumentToSaved: -saveDocumentWithDelegate:didSaveSelector:contextInfo: -runModalSavePanelForSaveOperation:delegate:didSaveSelector:contextInfo: -saveToURL:ofType:forSaveOperation:delegate:didSaveSelector:contextInfo: -canCloseDocumentWithDelegate:shouldCloseSelector:contextInfo: -duplicateDocumentWithDelegate:didDuplicateSelector:contextInfo: -runModalPageLayoutWithPrintInfo:delegate:didRunSelector:contextInfo: -printDocumentWithSettings:showPrintPanel:delegate:didPrintSelector:contextInfo: -runModalPrintOperation:delegate:didRunSelector:contextInfo: More uses of this method may be added to NSDocument in the future. This method must be invoked on the main thread. If it is passed YES for waitSynchronously it waits on the main thread, blocking further user interaction with the document. The purpose of blocking the main thread is so the user cannot continue to change the document while an activity is pending. This prevents for example the strange situation where the user chooses to revert the document, reverting does not happen immediately because asynchronous saving is still in progress, the user is able to continue to make changes to the document, and then those changes are immediately discarded when the asynchronous saving is complete and the document is reverted. All of the NSDocument methods listed above pass YES for waitSynchronously. You pass NO for waitSynchronously when the work that is to be done is instigated by the user so indirectly that the work might begin when modal UI is already being presented. For example, here is another method whose default implementation invokes this method, this time passing NO for waitSynchronously: -autosaveDocumentWithDelegate:didAutosaveSelector:contextInfo: This method might present an error alert but it is typically invoked by a timer. If it passed YES for waitSynchronously, and the timer fired while the user was looking at a sheet presented by a previous activity, blocking of the main thread would prevent the handling of the user interface events necessary to dismiss that sheet and complete that previous activity. Deadlock would result. Whether you make this method wait synchronously or asynchronously to do your work is separate from whether your work is done synchronously or asynchronously. For example, as mentioned above -saveToURL:ofType:forSaveOperation:delegate:didSaveSelector:contextInfo: passes YES for waitSynchronously when it uses this method, even though the majority of the work it does may be done asynchronously. You should not invoke this method during the invocation of the block passed to -performSynchronousFileAccessUsingBlock:, mentioned down below, or in between the time -performAsynchronousFileAccessUsingBlock:, also mentioned down below, invokes the block passed to it and the time at which the corresponding file access completion handler is invoked. If you do then deadlock can result. In other words, you cannot begin a new activity as part of file access. You can on the other hand invoke -performSynchronousFileAccessUsingBlock: or -performAsynchronousFileAccessUsingBlock: as part of an activity. Some asynchronous activities, like saving, need to do work on the main thread as they are completing. A deadlock would be inevitable if there were no way to interrupt this method's blocking of the main thread. See -continueAsynchronousWorkOnMainThreadUsingBlock: to find out how to interrupt this method's blocking of the main thread.
      */
-    performActivityWithSynchronousWaiting$usingBlock$(waitSynchronously: boolean, block: NobjcObject): void;
+    performActivityWithSynchronousWaiting$usingBlock$(waitSynchronously: boolean, block: (arg0: () => void) => void): void;
     /**
      * If a block that was passed to -performActivityWithSynchronousWaiting:usingBlock: is being invoked, invoke the passed-in block, having recorded state that makes inner invocations of -performActivityWithSynchronousWaiting:usingBlock: not wait. If this method is invoked outside of an invocation of a block passed to -performActivityWithSynchronousWaiting:usingBlock:, simply invoke the passed-in block. This method is useful when code executed in a block passed to -performActivityWithSynchronousWaiting:usingBlock: may also invoke that method. For example, -saveDocumentWithDelegate:didSaveSelector:contextInfo:, which uses -performActivityWithSynchronousWaiting:usingBlock:, uses this around its invocation of -runModalSavePanelForSaveOperation:delegate:didSaveSelector: or -saveToURL:ofType:forSaveOperation:delegate:didSaveSelector:contextInfo: because both of those methods also use -performActivityWithSynchronousWaiting:usingBlock:. Without the use of this method that inner invocation of -performActivityWithSynchronousWaiting:usingBlock: would wait forever.
      */
-    continueActivityUsingBlock$(block: NobjcObject): void;
+    continueActivityUsingBlock$(block: () => void): void;
     /**
      * Invoke the block on the main thread. If the main thread is blocked by an invocation of -performActivityWithSynchronousWaiting:usingBlock: or -performSynchronousFileAccessUsingBlock:, interrupt that blocking to invoke the block, and then resume blocking when the invocation of the block has returned. Invocations of this method always return before the passed-in block is invoked. You can invoke this method when work is being done on a non-main thread and part of the work must be continued on the main thread. For example, -saveToURL:ofType:forSaveOperation:completionHandler: uses this method when it has just completed the actual writing of the file during asynchronous saving and, to finish the saving operation, must invoke -updateChangeCountWithToken:forSaveOperation: and other methods on the main thread. This method can of course be invoked on any thread.
      */
-    continueAsynchronousWorkOnMainThreadUsingBlock$(block: NobjcObject): void;
+    continueAsynchronousWorkOnMainThreadUsingBlock$(block: () => void): void;
     /**
      * Given a block that will perform file access, wait for any file access scheduled by previous invocations of this method or -performAsynchronousFileAccessUsingBlock: to be complete, and then invoke the block. When the block invocation returns allow the next scheduled file access to to be performed, if any. Like -performActivityWithSynchronousWaiting:usingBlock: this method's primary use is to wait for asynchronous saving, but in contrast with that method it is only for use to wait for the part of an asynchronous saving operation that actually touches the document's file or values in memory that are in some way relative to the document's file. See the comment for -performAsynchronousFileAccessUsingBlock: for an explanation of why this distinction is important. In general you should use this method or -performAsynchronousFileAccessUsingBlock: around code that gets or sets values in memory that only make sense in the context of the document file's current state. For example, NSDocument itself consistently uses this mechanism around invocations of these methods: - -fileType, -fileURL, -fileModificationDate, -autosavedContentsFileURL:, and -isDraft, because you can't reliably make decisions based on a file's location, type, modification date, or draft status when it might be being asynchronously moved, renamed, or changed at that moment. - -setFileType:, -setFileURL:, -setFileModificationDate:, -setAutosavedContentsFileURL:, and -setDraft:, to make using this mechanism when invoking the previous list of methods meaningful. - -isDocumentEdited and -hasUnautosavedChanges, because you can't reliably make decisions based on whether the document's contents in memory have been saved to a file when it might be being asynchronously saved at that moment. - -updateChangeCountWithToken:forSaveOperation: and, sometimes, updateChangeCount:, to make using this mechanism when invoking -isDocumentEdited and -hasUnautosavedChanges meaningful. - -backupFileURL, since it depends on -fileURL.
      */
-    performSynchronousFileAccessUsingBlock$(block: NobjcObject): void;
+    performSynchronousFileAccessUsingBlock$(block: () => void): void;
     /**
      * Do the same sort of thing as -performSynchronousFileAccessUsingBlock:, but without ever blocking the main thread, and perhaps not invoking the block until after the method invocation has returned, though still always on the same thread as the method invocation. The block is passed another block, the file access completion handler, which must be invoked when the file access is complete, though it can be invoked from any thread. This method is for use with file access that might begin on one thread but continue on another before it is complete. saveToURL:ofType:forSaveOperation:completionHandler: for for example uses this method instead of -performSynchronousFileAccessUsingBlock: because if it does asynchronous saving then there is no way for it to actually complete all of its file access before returning from the file access block. The distinction between entire activities and the file accessing part of activities established by having both activity performing methods and file access performing methods is worthwhile because sometimes it is valuable to perform file access without any risk of waiting for the user to dismiss a modal panel. For example, NSDocument's implementation of -[NSFilePresenter relinquishPresentedItemToWriter:] uses -performAsynchronousFileAccessUsingBlock: to ensure that the uses of -performSynchronousFileAccessUsingBlock: described above wait while another process is moving, renaming, or changing the file. Using -performActivityWithSynchronousWaiting:usingBlock: instead would not be appropriate because that would introduce the possibility of the other process' writing being blocked until the user has dismissed a sheet that is being presented as part of a previously scheduled activity.
      */
-    performAsynchronousFileAccessUsingBlock$(block: NobjcObject): void;
+    performAsynchronousFileAccessUsingBlock$(block: (arg0: () => void) => void): void;
     /**
      * The action of the File menu's Revert to Saved item in a document-based application. The default implementation of this method presents a panel giving the user the opportunity to cancel the operation and, and if the user chooses to continue, makes sure that any editor registered using Cocoa Bindings' NSEditorRegistration protocol has discarded its changes and then invokes [self revertToContentsOfURL:[self url] ofType:[self fileType] error:outError]. If that returns NO, it presents the error to the user in an document-modal alert panel. If +autosavesInPlace returns YES and +preservesVersions returns NO, this method throws an exception.
      */
@@ -183,7 +183,7 @@ export declare class _NSDocument extends _NSObject {
     /**
      * Save the contents of the document to a file or file package located by a URL, formatted to a specified type, for a particular kind of save operation, and invoke the passed-in completion handler at some point in the future, perhaps after the method invocation has returned. The completion handler must be invoked on the main thread. If successful, pass a nil error. If not successful, pass an NSError that encapsulates the reason why the document could not be saved. The default implementation of this method invokes [self canAsynchronouslyWriteToURL:url ofType:typeName forSaveOperation:saveOperation]. If writing can't be done concurrently, it invokes [self writeSafelyToURL:url ofType:typeName forSaveOperation:saveOperation error:&anError] on the main thread thread. If writing can be done concurrently, it invokes that method on a different thread, but blocking the main thread until something invokes -unblockUserInteraction. Either way, if -writeSafelyToURL:ofType:forSaveOperation:error: returns YES, it also invokes some combination of -setFileModificationDate:, -setFileType:, -setFileURL:, -updateChangeCount:, and -setAutosavedContentsFileURL:, as appropriate for the kind of save operation, on the main thread. It also updates information that -saveDocumentWithDelegate:didSaveSelector:contextInfo: uses to check for modification, renaming, moving, deleting, and trashing of open documents, and deletes autosaved contents files when they have become obsolete. You can override this method to do things that need to be done before or after any save operation but, because this method does several different things, and because the things are likely to change in future releases of Mac OS X, it's probably not a good idea to override this method without invoking super. For backward binary compatibility with Mac OS 10.6 and earlier, the default implementation of this method instead invokes [self saveToURL:url ofType:typeName forSaveOperation:saveOperation error:&anError] if that method is overridden and this one is not, and passes any error to the completion handler.
      */
-    saveToURL$ofType$forSaveOperation$completionHandler$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, completionHandler: NobjcObject | null): void;
+    saveToURL$ofType$forSaveOperation$completionHandler$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, completionHandler: ((errorOrNil: _NSError) => void) | null): void;
     /**
      * Return whether the receiver can concurrently write to a file or file package located by a URL, formatted for a specific type, for a specific kind of save operation. The default implementation of this method returns NO. You are strongly encouraged to override it and make it return YES, after making sure your overrides of -write... methods can be safely invoked on a non-main thread, and making sure that -unblockUserInteraction will be invoked at some appropriate time during writing.
      */
@@ -203,7 +203,7 @@ export declare class _NSDocument extends _NSObject {
     /**
      * Autosave the document's contents at an appropriate location if it needs autosaving, and invoke the passed-in completion handler at some point in the future, perhaps after the method invocation has returned. The completion handler must be invoked on the main thread. If successful, pass a nil error. If not successful, pass an NSError that encapsulates the reason why the document could not be autosaved. autosavingIsImplicitlyCancellable becomes what -autosavingIsImplicitlyCancellable returns while the autosaving is happening. The default implementation of this method invokes [self hasUnautosavedChanges] and, if that returns YES, figures out where the autosaved document contents should go and invokes [self saveToURL:autosavedDocumentContentsURL ofType:[self autosavingFileType] forSaveOperation:oneOfTheAutosaveOperations completionHandler:aCompletionHandler]. oneOfTheAutosaveOperations will be NSAutosaveAsOperation if the document has been changed with NSChangeDone and the current document should be turned into a draft, NSAutosaveInPlaceOperation if [[self class] autosavesInPlace] returns YES and [self fileURL] returns non-nil, or NSAutosaveElsewhereOperation otherwise. The check of [self fileURL] is because there's no such thing as autosaving "in place" when the document does not yet have a permanent place.
      */
-    autosaveWithImplicitCancellability$completionHandler$(autosavingIsImplicitlyCancellable: boolean, completionHandler: NobjcObject | null): void;
+    autosaveWithImplicitCancellability$completionHandler$(autosavingIsImplicitlyCancellable: boolean, completionHandler: ((errorOrNil: _NSError) => void) | null): void;
     /**
      * The action of the Browse Saved Versions menu item in a document-based application. The default implementation causes the document's main window, specified by [self windowForSheet], to enter the Versions browser.
      */
@@ -211,7 +211,7 @@ export declare class _NSDocument extends _NSObject {
     /**
      * If the receiver is currently displaying the Versions browser, cleanly stop browsing versions (which includes waiting for any animations to complete). Then invoke the completion handler on the main thread.
      */
-    stopBrowsingVersionsWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    stopBrowsingVersionsWithCompletionHandler$(completionHandler: (() => void) | null): void;
     /**
      * If there are changes that have not yet been saved to the document's file and saving cannot be done without asking the user first, present a panel to the user informing them that the document is modified and asking if it should be saved. If the user indicates that it should be, then try to save it. When saving is completed, regardless of success or failure, or has been rejected one way or another by the user, send the message selected by shouldCloseSelector to the delegate, with the contextInfo as the last argument. If the document is not modified then just send the message selected by shouldCloseSelector right away. The method selected by shouldCloseSelector must have the same signature as: - (void)document:(NSDocument *)document shouldClose:(BOOL)shouldClose contextInfo:(void *)contextInfo; The default implementation of this method has two rather different behaviors. If [[self class] autosavesInPlace] returns YES and [self fileURL] returns non-nil then it simply invokes [self autosaveWithImplicitCancellability:NO completionHandler:aCompletionHandler] if [self hasUnautosavedChanges] returns YES after making sure that any editor registered using Cocoa Bindings' NSEditorRegistration protocol has committed its changes. Otherwise it presents a panel giving the user the choice of canceling, discarding changes, or saving. In that case the shouldClose value passed to the delegate will be YES if the document was not modified in the first place, or the user chose to discard modifications, or chose to save and the saving was successful. NO will be passed if the user chose to cancel the operation or saving was unsuccessful. Because -saveDocumentWithDelegate:didSaveSelector:contextInfo: is used, an alert panel will be presented before the delegate is messaged if saving is attempted but does not succeed.
      */
@@ -247,11 +247,11 @@ export declare class _NSDocument extends _NSObject {
     /**
      * Present a move panel to the user, then try to save the document if the user OKs the panel. When moving is completed, regardless of success, failure, or cancellation, invoke the given block. The default implementation of this method first makes sure that any editor registered using Cocoa Binding's NSEditorRegistration protocol has committed its changes if necessary. Then, if [self fileURL] is non-nil, it creates and presents a move panel. If the user OKs the panel, -moveToURL:completionHandler: is invoked. If a file already exists at the location the user chooses, the user will be asked to choose between replacing that file, renaming the current document, or canceling. If [self fileURL] is nil, then this method will instead invoke [self runModalSavePanelForSaveOperation:NSSaveAsOperation delegate:didSaveSelector:contextInfo:].
      */
-    moveDocumentWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    moveDocumentWithCompletionHandler$(completionHandler: ((didMove: boolean) => void) | null): void;
     /**
      * Move the document's file to the given URL and invoke the passed-in completion handler at some point in the future, perhaps after the method invocation has returned. The completion handler must be invoked on the main thread. If successful, pass a nil error. If not successful, pass an NSError that encapsulates the reason why the document could not be moved. The default implementation of this method does a coordinated move of the file at [self fileURL] to the given URL, replacing any file that may currently exist at that URL, and invokes -setFileURL: if the operation is successful. If [self fileURL] is nil, then this method will instead invoke [self saveToURL:url ofType:[self fileType] forSaveOperation:NSSaveAsOperation completionHandler:aCompletionHandler].
      */
-    moveToURL$completionHandler$(url: _NSURL, completionHandler: NobjcObject | null): void;
+    moveToURL$completionHandler$(url: _NSURL, completionHandler: ((arg0: _NSError) => void) | null): void;
     /**
      * The actions of the Lock and Unlock menu items in a document-based application. The default implementations of these method invoke -lockDocumentWithCompletionHandler: and -unlockDocumentWithCompletionHandler: respectively.
      */
@@ -260,19 +260,19 @@ export declare class _NSDocument extends _NSObject {
     /**
      * Lock the document to prevent the user from making further modifications. When locking is completed, regardless of success or failure, invoke the given block. The default implementation of this method first makes sure that any editor registered using Cocoa Binding's NSEditorRegistration protocol has committed its changes and immediately autosaves the document. If the autosave completes successfully or isn't necessary, this method invokes [self lockWithCompletionHandler:]. When locking succeeds, -isLocked will begin returning YES. Documents that return nil from [self fileURL] cannot be locked.
      */
-    lockDocumentWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    lockDocumentWithCompletionHandler$(completionHandler: ((didLock: boolean) => void) | null): void;
     /**
      * Lock the file at [self fileURL] to prevent further modifications. When locking is completed regardless of success or failure, invoke the given block. The default implementation of this method enables the "user immutable" flag on the file at [self fileURL].
      */
-    lockWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    lockWithCompletionHandler$(completionHandler: ((arg0: _NSError) => void) | null): void;
     /**
      * Unlock the document and allow the user to make modifications to the document. When unlocking is completed, regardless of success or failure, invoke the given block. The default implementation of this method invokes [self unlockWithCompletionHandler:]. This method also disables autosaving safety checking, meaning that -checkAutosavingSafetyAndReturnError: will no longer be invoked on this document. When unlocking succeeds, -isLocked will being returning NO.
      */
-    unlockDocumentWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    unlockDocumentWithCompletionHandler$(completionHandler: ((didUnlock: boolean) => void) | null): void;
     /**
      * Unlock the file at [self fileURL] to allow modifications. When unlocking is completed, regardless of success of failure, invoke the given block. The default implementation of this method tries to clear the "user immutable" flag and add write permissions (if necessary) to the file at [self fileURL].
      */
-    unlockWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    unlockWithCompletionHandler$(completionHandler: ((arg0: _NSError) => void) | null): void;
     /**
      * The action of the File menu's Page Setup... item in a document-based application. The default implementation of this method invokes [self printInfo], makes a copy of the print info object, and invokes [self runModalPageLayoutWithPrintInfo:printInfoCopy delegate:aPrivateDelegate didRunSelector:aSelectorForAPrivateMethod contextInfo:privateContextInfo]. If the user OKs the page layout panel, [self shouldChangePrintInfo:printInfoCopy] is invoked. If that returns YES, [self setPrintInfo:printInfoCopy] is invoked.
      */
@@ -312,7 +312,7 @@ export declare class _NSDocument extends _NSObject {
     /**
      * Share the document's file using the given NSSharingService. First, ensure the document is in a state where it can be properly shared by the given service by saving or relocating the receiver's file, if necessary. Then perform the given sharing service with 'self.fileURL' as the only item. When sharing is complete or fails, invoke the completion handler indicating whether the operation was successful. The default implementation of this method first ensures the document is saved by autosaving the document if possible, or else presenting the user with a save panel. If the given sharing service has the name NSSharingServiceNameCloudSharing, then it also ensures that file is located in an appropriate container for sharing (e.g. iCloud Drive). When the sharing service finishes, it displays an errors returned by the NSSharingService, then invokes the completion handler, passing a boolean indicating whether sharing succeeded or not. If the given sharing service had a delegate already set, the default implementation replaces it with its own delegate in order to get completion notifications. However, all NSSharingServiceDelegate methods will be forwarded to the original delegate as well. When an NSDocument is the only item being used with NSSharingServicePicker or NSSharingServicePickerTouchBarItem, it will invoke this method instead of calling -[NSSharingService performWithItems:] directly.
      */
-    shareDocumentWithSharingService$completionHandler$(sharingService: _NSSharingService, completionHandler: NobjcObject | null): void;
+    shareDocumentWithSharingService$completionHandler$(sharingService: _NSSharingService, completionHandler: ((success: boolean) => void) | null): void;
     /**
      * Given the NSSharingServicePicker used by an NSDocumentController-owned Share menu (either an automatically inserted one, or one returned by +[NSDocumentController standardShareMenuItem]), make any final changes before that menu is presented. Specifically, you may choose to set a custom NSSharingServicePickerDelegate to customize the construction of the resulting menu, or provide a custom NSSharingServiceDelegate for the chosen service.
      */
@@ -385,10 +385,10 @@ export declare class _NSDocument extends _NSObject {
      * Conformance to the NSUserInterfaceValidations protocol. NSDocument's implementation of this method conditionally enables menu items for all of the action methods listed in this header file.
      */
     validateUserInterfaceItem$(item: _NSValidatedUserInterfaceItem): boolean;
-    relinquishPresentedItemToReader$(reader: NobjcObject | null): void;
-    relinquishPresentedItemToWriter$(writer: NobjcObject | null): void;
-    savePresentedItemChangesWithCompletionHandler$(completionHandler: NobjcObject | null): void;
-    accommodatePresentedItemDeletionWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    relinquishPresentedItemToReader$(reader: ((arg0: () => void) => void) | null): void;
+    relinquishPresentedItemToWriter$(writer: ((arg0: () => void) => void) | null): void;
+    savePresentedItemChangesWithCompletionHandler$(completionHandler: ((errorOrNil: _NSError) => void) | null): void;
+    accommodatePresentedItemDeletionWithCompletionHandler$(completionHandler: ((errorOrNil: _NSError) => void) | null): void;
     presentedItemDidMoveToURL$(newURL: _NSURL): void;
     presentedItemDidChange(): void;
     presentedItemDidChangeUbiquityAttributes$(attributes: _NSSet): void;
@@ -453,7 +453,7 @@ export declare class _NSDocument extends _NSObject {
     /**
      * The following method is called by the default implementation of +[NSDocumentController restoreWindowWithIdentifier:state:completionHandler:] to restore a window that was associated with a document, after that document has been reopened. The default implementation first checks if the document has window controllers, and if not, it calls -makeWindowControllers. If there is then exactly one window controller, it invokes the completion handler with its window. If there is more than one, it searches the receiver's window controllers for a window that matches the given identifier, and then calls the completionHandler with it. If no window could be found, it invokes the completion handler with a nil window. If your document has variable or optional windows, you may override this to create the requested window, and then call the completion handler with it. This allows you to use the default document reopening behavior, but intervene at the point of creating the windows. The parameters are the same as in the class method +restoreWindowWithIdentifier:state:completionHandler:.
      */
-    restoreDocumentWindowWithIdentifier$state$completionHandler$(identifier: _NSString, state: _NSCoder, completionHandler: NobjcObject | null): void;
+    restoreDocumentWindowWithIdentifier$state$completionHandler$(identifier: _NSString, state: _NSCoder, completionHandler: ((arg0: _NSWindow, arg1: _NSError) => void) | null): void;
     /**
      * NSDocument implements the NSRestorableState methods, even though it itself is not an NSResponder.
      */

package/dist/AppKit/NSDocumentController.d.ts

@@ -64,15 +64,15 @@ export declare class _NSDocumentController extends _NSObject {
     /**
      * Present an open panel, which may or may not be application-modal, to the user and, if the user selects one or more files and indicates that they are to be opened, invoke the completion handler with an array of those files' URLs. Invoke the completion handler with nil otherwise. The default implementation of this method invokes -beginOpenPanel:forTypes:completionHandler:. However, for backward binary compatibility, it invokes -runModalOpenPanel:forTypes: instead if you override it in a subclass and not -beginOpenPanel:forTypes:completionHandler:. If you override -[NSDocumentController openDocument:], you would typically want to invoke this method instead of -beginOpenPanel:forTypes:completionHandler: or -URLsFromRunningOpenPanel directly. You typically would not override this method without calling super.
      */
-    beginOpenPanelWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    beginOpenPanelWithCompletionHandler$(completionHandler: ((arg0: _NSArray) => void) | null): void;
     /**
      * Present an open panel, which will always be non-modal, to the user, specifying a list of UTIs for openable files. Invoke the completion handler with NSOKButton or NSCancelButton depending on how the user dismisses the panel. You typically would not invoke this method directly. You can override it though if you need to customize the open panel before it gets displayed.
      */
-    beginOpenPanel$forTypes$completionHandler$(openPanel: _NSOpenPanel, inTypes: _NSArray | null, completionHandler: NobjcObject): void;
+    beginOpenPanel$forTypes$completionHandler$(openPanel: _NSOpenPanel, inTypes: _NSArray | null, completionHandler: (result: number) => void): void;
     /**
      * Open a document located by a URL, present its user interface if displayDocument is YES, and invoke the passed-in completion handler at some point in the future, perhaps after the method invocation has returned. The completion handler must be invoked on the main thread. If successful, pass the document to the completion handler, and also whether the document was already open or being opened before this method was invoked. If not successful, pass a nil document and an NSError that encapsulates the reason why the document could not be opened. The default implementation of this method checks to see if the document is already open or being opened, and if it is not determines the type of the document, invokes -makeDocumentWithContentsOfURL:ofType:error: to instantiate it, invokes -addDocument: to record its opening, and sends the document -makeWindowControllers and -showWindows messages if displayDocument is YES. If the document is already open it is just sent a -showWindows message if displayDocument is YES. If the relevant document class returns YES when sent +canConcurrentlyReadDocumentsOfType: then the invocation of -makeDocumentWithContentsOfURL:ofType:error: is done on a thread other than the main one and when that has returned the rest of the operation is done on the main thread. The default implementation of this method uses the file coordination mechanism that was added to the Foundation framework in Mac OS 10.7. All of the work it does is one big coordinated read, and it passes the document to +[NSFileCoordinator addFilePresenter:] right after -addDocument: is invoked. (The balancing invocation of +[NSFileCoordinator removeFilePresenter:] is in -[NSDocument close]). You can override this method to customize how documents are opened. Its implemention however is somewhat complex so unless your customization is to do additional work before invoking super, or to invoke super with a completion handler that does additional work before invoking the original completion handler, you should investigate overriding one of the methods that it invokes instead. If you do override this method you should investigate whether you should also override -reopenDocumentForURL:withContentsOfURL:display:completionHandler: to apply the same customization. In either cause take care to always invoke the completion handler on the main thread. You can of course invoke this method to open a document. For backward binary compatibility with Mac OS 10.6 and earlier, the default implementation of this method invokes [self openDocumentWithContentsOfURL:url display:displayDocument error:&anError] if that method or the even older -openDocumentWithContentsOfFile:display: method is overridden and this one is not, instead of invoking -makeDocumentWithContentsOfURL:ofType:error: and all the rest.
      */
-    openDocumentWithContentsOfURL$display$completionHandler$(url: _NSURL, displayDocument: boolean, completionHandler: NobjcObject | null): void;
+    openDocumentWithContentsOfURL$display$completionHandler$(url: _NSURL, displayDocument: boolean, completionHandler: ((document: _NSDocument, documentWasAlreadyOpen: boolean, error: _NSError) => void) | null): void;
     /**
      * Instantiate a document located by a URL, of a specified type, and return it if successful. If not successful, return nil after setting *outError to an NSError that encapsulates the reason why the document could not be instantiated. The default implementation of this method invokes -documentClassForType: to find out the class of document to instantiate, allocates a document object, and initializes it by sending it an -initWithContentsOfURL:ofType:error: message. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self makeDocumentWithContentsOfFile:[url path] ofType:typeName] if -makeDocumentWithContentsOfFile:ofType: is overridden and the URL uses the "file:" scheme.
      */
@@ -80,7 +80,7 @@ export declare class _NSDocumentController extends _NSObject {
     /**
      * Reopen a document, perhaps located by a URL, perhaps not, by reading the contents for the document from another URL, which may or may not be a different URL, present its user interface if displayDocument is YES, and invoke the passed-in completion handler at some point in the future, perhaps after the method invocation has returned. The completion handler must be invoked on the main thread. If successful, pass the document to the completion handler, and also whether the document was already open or being opened before this method was invoked. If not successful, pass a nil document and an NSError that encapsulates the reason why the document could not be opened. A nil URL indicates that the opened document is to have no fileURL, much like an untitled document has. The default implementation of this method is very similar to -openDocumentWithContentsOfURL:display:completionHandler:'s, the primary difference being that it invokes -makeDocumentForURL:withContentsOfURL:ofType:error: instead of -makeDocumentWithContentsOfURL:ofType:error:. You can override this method to customize how documents are reopened during application launching by the restorable state mechanism that was added to the AppKit framework in Mac OS 10.7. Its implemention however is somewhat complex so unless your customization is to do additional work before invoking super, or to invoke super with a completion handler that does additional work before invoking the original completion handler, you should investigate overriding one of the methods that it invokes instead. We don't anticipate any uses for an application to invoke this method directly, but you may discover one. For backward binary compatibility with Mac OS 10.6 and earlier, the default implementation of this method invokes [self reopenDocumentForURL:url withContentsOfURLcontentsURL error:&anError] if that method is overridden and this one is not, instead of invoking -makeDocumentForURL:withContentsOfURL:ofType:error: and all the rest.
      */
-    reopenDocumentForURL$withContentsOfURL$display$completionHandler$(urlOrNil: _NSURL | null, contentsURL: _NSURL, displayDocument: boolean, completionHandler: NobjcObject | null): void;
+    reopenDocumentForURL$withContentsOfURL$display$completionHandler$(urlOrNil: _NSURL | null, contentsURL: _NSURL, displayDocument: boolean, completionHandler: ((document: _NSDocument, documentWasAlreadyOpen: boolean, error: _NSError) => void) | null): void;
     /**
      * Instantiate a document, perhaps located by a URL, perhaps not, by reading the contents for the document from another URL, which may or may not be a different URL, and return it if successful. If not successful, return nil after setting *outError to an NSError that encapsulates the reason why the document could not be instantiated. The default implementation of this method invokes -documentClassForType: to find out the class of document to instantiate, allocates a document object, and initializes it by sending it an -initForURL:withContentsOfURL:ofType:error: message.
      */

package/dist/AppKit/NSDraggingInfo.d.ts

@@ -2,6 +2,7 @@ import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
+import type { _NSDraggingItem } from "./NSDraggingItem.js";
 import type { _NSImage } from "./NSImage.js";
 import type { _NSPasteboard } from "./NSPasteboard.js";
 import type { _NSView } from "./NSView.js";
@@ -19,7 +20,7 @@ export interface _NSDraggingInfo {
     /**
      * Enumerate through each dragging item. Any changes made to the properties of the draggingItem are reflected in the drag and are automatically removed when the drag exits. Classes in the provided array must implement the NSPasteboardReading protocol. Cocoa classes that implement this protocol include NSImage, NSString, NSURL, NSColor, NSAttributedString, and NSPasteboardItem. For every item on the pasteboard, each class in the provided array will be queried for the types it can read using -readableTypesForPasteboard:. An instance will be created of the first class found in the provided array whose readable types match a conforming type contained in that pasteboard item. If an Instance is created from the pasteboard item data, it is placed into an NSDraggingItem along with the dragging properties of that item such as the dragging image. The NSDraggingItem is then passed as a parameter to the provided block. Additional search options, such as restricting the search to file URLs with particular content types, can be specified with a search options dictionary. See the comments for the Pasteboard Reading Options keys in NSPasteboard.h for a full description. Note: all coordinate properties in the NSDraggingItem are in the coordinate system of view. If view is nil, the screen coordinate space is used.
      */
-    enumerateDraggingItemsWithOptions$forView$classes$searchOptions$usingBlock$?(enumOpts: NSDraggingItemEnumerationOptions, view: _NSView | null, classArray: _NSArray, searchOptions: _NSDictionary, block: NobjcObject): void;
+    enumerateDraggingItemsWithOptions$forView$classes$searchOptions$usingBlock$?(enumOpts: NSDraggingItemEnumerationOptions, view: _NSView | null, classArray: _NSArray, searchOptions: _NSDictionary, block: (draggingItem: _NSDraggingItem, idx: number, stop: NobjcObject) => void): void;
     /**
      * Used when the drag crosses two distinct but valid spring loading regions within the same destination. The hover timer is reset and if the user is currently in a force click, they must release and re-force click to highlight the new region.
      */

package/dist/AppKit/NSDraggingItem.d.ts

@@ -27,8 +27,8 @@ export declare class _NSDraggingItem extends _NSObject {
     /**
      * The dragging image is the composite of an array of NSDraggingImageComponents. The dragging image components may not be set directly. Instead, provide a block to generate the components and the block will be called if necessary. The block may be set to nil, meaning that this drag item has no image. Generally, only dragging destinations do this, and only if there is at least one valid item in the drop, and this is not it. The components are composited in painting order. That is, each component in the array is painted on top of the previous components in the array.
      */
-    imageComponentsProvider(): NobjcObject | null;
-    setImageComponentsProvider$(value: NobjcObject | null): void;
+    imageComponentsProvider(): (() => _NSArray) | null;
+    setImageComponentsProvider$(value: (() => _NSArray) | null): void;
     /**
      * An array of NSDraggingImageComponents that are used to create the drag image. Note: the array contains copies of the components. Changes made to these copies are not reflected in the drag. If needed, the imageComponentsProvider block is called to generate the image components.
      */

package/dist/AppKit/NSDraggingSession.d.ts

@@ -2,6 +2,7 @@ import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSDraggingItem } from "./NSDraggingItem.js";
 import type { _NSPasteboard } from "./NSPasteboard.js";
 import type { _NSView } from "./NSView.js";
 import type { CGPoint } from "../structs/CGPoint.js";
@@ -14,7 +15,7 @@ export declare class _NSDraggingSession extends _NSObject {
     /**
      * Enumerate through each dragging item. Any changes made to the properties of the draggingItem are reflected in the drag when the destination is not overriding them. Classes in the provided array must implement the NSPasteboardReading protocol. Cocoa classes that implement this protocol include NSImage, NSString, NSURL, NSColor, NSAttributedString, and NSPasteboardItem. For every item on the pasteboard, each class in the provided array will be queried for the types it can read using -readableTypesForPasteboard:. An instance will be created of the first class found in the provided array whose readable types match a conforming type contained in that pasteboard item. If an Instance is created from the pasteboard item data, it is placed into an NSDraggingItem along with the dragging properties of that item such as the drag image. The NSDraggingItem is then passed as a parameter to the provided block. Additional search options, such as restricting the search to file URLs with particular content types, can be specified with a search options dictionary. See the comments for the Pasteboard Reading Options keys in NSPasteboard.h for a full description. Note: all coordinate properties in the NSDraggingItem are in the coordinate system of view. If view is nil, the screen coordinate space is used.
      */
-    enumerateDraggingItemsWithOptions$forView$classes$searchOptions$usingBlock$(enumOpts: NSDraggingItemEnumerationOptions, view: _NSView | null, classArray: _NSArray, searchOptions: _NSDictionary, block: NobjcObject): void;
+    enumerateDraggingItemsWithOptions$forView$classes$searchOptions$usingBlock$(enumOpts: NSDraggingItemEnumerationOptions, view: _NSView | null, classArray: _NSArray, searchOptions: _NSDictionary, block: (draggingItem: _NSDraggingItem, idx: number, stop: NobjcObject) => void): void;
     /**
      * Controls the dragging formation when the drag is over the source. The default value is NSDraggingFormationNone.
      */

package/dist/AppKit/NSEvent.d.ts

@@ -43,8 +43,8 @@ export declare class _NSEvent extends _NSObject {
     /**
      * API for monitoring events in other processes, or in your own process. For either +addGlobal or +addLocal, pass an event mask specifying which events you wish to monitor, and a block that will be called with the event to monitor. Use +addGlobal to install an event monitor that receives copies of events posted to other applications. Events are delivered asynchronously to your app and you can only observe the event; you cannot modify or otherwise prevent the event from being delivered to its original target application. Key-related events may only be monitored if accessibility is enabled or if your application is trusted for accessibility access (see AXIsProcessTrusted in AXUIElement.h). Note that your handler will not be called for events that are sent to your own application. Use +addLocal to install an event monitor that receives events before they are dispatched by -[NSApplication sendEvent:]. In this case, your block should either return a valid NSEvent (which may be the same as the incoming NSEvent, or may be a newly created NSEvent) to cause the event to be dispatched, or it may return nil to stop dispatching of the event. Note that your handler will not be called for events that are consumed by nested event-tracking loops such as control tracking, menu tracking, or window dragging; only events that are dispatched through -[NSApplication sendEvent:] will be passed to your handler. In either case, the return value of the API is a retained NSObject. You typically do not need to retain and release the event monitor yourself, since the implementation will retain it while needed. To remove the event monitor, under both garbage collection and non-GC, pass the return value from the +add API to +removeMonitor.
      */
-    static addGlobalMonitorForEventsMatchingMask$handler$(mask: NobjcObject, block: NobjcObject): NobjcObject | null;
-    static addLocalMonitorForEventsMatchingMask$handler$(mask: NobjcObject, block: NobjcObject | null): NobjcObject | null;
+    static addGlobalMonitorForEventsMatchingMask$handler$(mask: NobjcObject, block: (event: _NSEvent) => void): NobjcObject | null;
+    static addLocalMonitorForEventsMatchingMask$handler$(mask: NobjcObject, block: ((event: _NSEvent) => _NSEvent) | null): NobjcObject | null;
     static removeMonitor$(eventMonitor: NobjcObject): void;
     /**
      * Enable or disable coalescing of mouse movement events, including mouse moved, mouse dragged, and tablet events. Coalescing is enabled by default.
@@ -93,7 +93,7 @@ export declare class _NSEvent extends _NSObject {
     /**
      * This method allows easy tracking and UI feedback of scroll events as fluid swipes. Fluid swipes are tracked not only to the end of the physical gesture phase by the user, but also to the completion of any UI animation that should be performed. Using this method allows your implementation to maintain a consistent fluid feel with other applications. Any gesture amount outside of the supplied minimum and maximum dampen amount is pre-dampened for you to provide an elastic feel. The trackingHandler has the following parameters: gestureAmount: the amount of gesture that you should display in the UI. This may be a fractional amount. Note: Upon completion, the gesture amount will animate to one of the following values: -1, 0, 1. phase: the phase of the physical gesture as performed by the user. When the phase is either NSPhaseEnded, or NSPhaseCancelled, the use has physically ended the gesture successfully or not, respectively. Your handler will continue to be called with updated progress values to complete the fluid swipe animation with a phase of NSPhaseNone. isComplete: Signifies the swipe and animation are complete and you should tear down any temporary animation objects. The trackingHandler is released and will not be called further. stop: A pointer to a BOOL allowing you to cancel further use of this trackingHandler by setting its value to YES. The trackingHandler is released appropriately. Note: This method returns immediately and tracking is performed asynchronously. Valid for Scroll events with a phase of NSEventPhaseBegan or NSEventPhaseChanged
      */
-    trackSwipeEventWithOptions$dampenAmountThresholdMin$max$usingHandler$(options: NSEventSwipeTrackingOptions, minDampenThreshold: number, maxDampenThreshold: number, trackingHandler: NobjcObject): void;
+    trackSwipeEventWithOptions$dampenAmountThresholdMin$max$usingHandler$(options: NSEventSwipeTrackingOptions, minDampenThreshold: number, maxDampenThreshold: number, trackingHandler: (gestureAmount: number, phase: NSEventPhase, isComplete: boolean, stop: NobjcObject) => void): void;
     /**
      * these messages are valid for all events
      * @deprecated This method always returns nil. If you need access to the current drawing context, use [NSGraphicsContext currentContext] inside of a draw operation.

package/dist/AppKit/NSFilePromiseProviderDelegate.d.ts

@@ -1,4 +1,4 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSOperationQueue } from "../Foundation/NSOperationQueue.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
@@ -11,7 +11,7 @@ export interface _NSFilePromiseProviderDelegate {
     /**
      * Write the contents of this promise item to the provided URL and call completionHandler when done. NSFilePromiseReceiver automatically wraps this message with NSFileCoordinator when the promise destination is an NSFilePromiseReceiver. Always use the supplied URL. Note: This request shall occur on the NSOperationQueue supplied by -promiseOperationQueue.
      */
-    filePromiseProvider$writePromiseToURL$completionHandler$?(filePromiseProvider: _NSFilePromiseProvider, url: _NSURL, completionHandler: NobjcObject | null): void;
+    filePromiseProvider$writePromiseToURL$completionHandler$?(filePromiseProvider: _NSFilePromiseProvider, url: _NSURL, completionHandler: ((errorOrNil: _NSError) => void) | null): void;
     /**
      * The operation queue that the write request will be issued from. If this method is not implemented, the mainOperationQueue is used.
      */

package/dist/AppKit/NSFilePromiseReceiver.d.ts

@@ -1,6 +1,6 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSOperationQueue } from "../Foundation/NSOperationQueue.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
@@ -16,7 +16,7 @@ export declare class _NSFilePromiseReceiver extends _NSObject {
     /**
      * This effectively calls in the promises. Therefore, only call once you are accepting the file promise. All file promisesReceiver's in a drag must specify the same destination location. This is an array, because legacy promises are an array of files on one pasteboard item. The reader block is called on the supplied operationQueue when the promised file is ready to be read. When the source is an NSFilePromiseProvider, the readerBlock call is wrapped in an NSFileCoordination read. Otherwise, a heuristic is used to determine when the promised file is ready to be read. The options dictionary is ignored for now. Note: Writing of the promised file may be cancelled or fail. When either occurs, the readerBlock is still called, but with a non-nil NSError. When NSError is non-nil, fileURL should be ignored.
      */
-    receivePromisedFilesAtDestination$options$operationQueue$reader$(destinationDir: _NSURL, options: _NSDictionary, operationQueue: _NSOperationQueue, reader: NobjcObject | null): void;
+    receivePromisedFilesAtDestination$options$operationQueue$reader$(destinationDir: _NSURL, options: _NSDictionary, operationQueue: _NSOperationQueue, reader: ((fileURL: _NSURL, errorOrNil: _NSError) => void) | null): void;
     /**
      * The UTI of the file types promised (Note: The count of fileTypes should tell you the number of promised files, however, that is not guaranteed. Historically, some legacy file promisers only list each unique fileType once and write one or more files per type.
      */

package/dist/AppKit/NSFontAssetRequest.d.ts

@@ -1,5 +1,5 @@
-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 { _NSProgress } from "../Foundation/NSProgress.js";
 import type { NSFontAssetRequestOptions } from "./NSFontAssetRequestOptions.js";
@@ -14,7 +14,7 @@ export declare class _NSFontAssetRequest extends _NSObject {
     /**
      * Start the download process. completionHandler will be called whenever encounters any error, or when all download has been completed without error. completionHandler should return NO if you wish to stop downloading from that point, or YES if you wish to continue trying downloading the next font.
      */
-    downloadFontAssetsWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    downloadFontAssetsWithCompletionHandler$(completionHandler: ((error: _NSError) => boolean) | null): void;
     /** The downloaded font descriptors up to this point. */
     downloadedFontDescriptors(): _NSArray;
     /**

package/dist/AppKit/NSImage.d.ts

@@ -52,7 +52,7 @@ export declare class _NSImage extends _NSObject {
     /**
      * Note that the block passed to the below method may be invoked whenever and on whatever thread the image itself is drawn on. Care should be taken to ensure that all state accessed within the drawingHandler block is done so in a thread safe manner.
      */
-    static imageWithSize$flipped$drawingHandler$(size: CGSize, drawingHandlerShouldBeCalledWithFlippedContext: boolean, drawingHandler: NobjcObject): _NSImage;
+    static imageWithSize$flipped$drawingHandler$(size: CGSize, drawingHandlerShouldBeCalledWithFlippedContext: boolean, drawingHandler: (dstRect: CGRect) => boolean): _NSImage;
     static canInitWithPasteboard$(pasteboard: _NSPasteboard): boolean;
     /**
      * These return union of all the types registered with NSImageRep.

package/dist/AppKit/NSLayoutManager.d.ts

@@ -227,11 +227,11 @@ export declare class _NSLayoutManager extends _NSObject {
      */
     getLineFragmentInsertionPointsForCharacterAtIndex$alternatePositions$inDisplayOrder$positions$characterIndexes$(charIndex: number, aFlag: boolean, dFlag: boolean, positions: NobjcObject | null, charIndexes: NobjcObject | null): number;
     /** Enumerates line fragments intersecting with glyphRange. */
-    enumerateLineFragmentsForGlyphRange$usingBlock$(glyphRange: NSRange, block: NobjcObject): void;
+    enumerateLineFragmentsForGlyphRange$usingBlock$(glyphRange: NSRange, block: (rect: CGRect, usedRect: CGRect, textContainer: _NSTextContainer, glyphRange: NSRange, stop: NobjcObject) => void): void;
     /**
      * Enumerates enclosing rects for glyphRange in textContainer. If a selected range is given in the second argument, the rectangles returned will be correct for drawing the selection. Selection rectangles are generally more complicated than enclosing rectangles and supplying a selected range is the clue these methods use to determine whether to go to the trouble of doing this special work. If the caller is interested in this more from an enclosing point of view rather than a selection point of view, pass {NSNotFound, 0} as the selected range. This method will do the minimum amount of work required to answer the question.
      */
-    enumerateEnclosingRectsForGlyphRange$withinSelectedGlyphRange$inTextContainer$usingBlock$(glyphRange: NSRange, selectedRange: NSRange, textContainer: _NSTextContainer, block: NobjcObject): void;
+    enumerateEnclosingRectsForGlyphRange$withinSelectedGlyphRange$inTextContainer$usingBlock$(glyphRange: NSRange, selectedRange: NSRange, textContainer: _NSTextContainer, block: (rect: CGRect, stop: NobjcObject) => void): void;
     /**
      * These methods are primitives for drawing. You can override these to perform additional drawing, or to replace text drawing entirely, but not to change layout. You can call them if you want, but focus must already be locked on the destination view or image. -drawBackgroundForGlyphRange:atPoint: draws the background color and selection and marked range aspects of the text display, along with block decoration such as table backgrounds and borders. -drawGlyphsForGlyphRange:atPoint: draws the actual glyphs, including attachments, as well as any underlines or strikethroughs. In either case all of the specified glyphs must lie in a single container.
      */

package/dist/AppKit/NSMenu.d.ts

@@ -37,11 +37,11 @@ export declare class _NSMenu extends _NSObject {
     /**
      * Creates a palette menu displaying user-selectable color tags using the provided array of colors and optional titles. Note that the palette menu is configured for display as an inline menu; you must set it as the submenu of another menu item, contained in a standard menu. The palette menu cannot be used to invoke the `popUpMenuPositioningItem` method, or attached directly to a popup button or toolbar item. @return An autoconfigured palette menu.
      */
-    static paletteMenuWithColors$titles$selectionHandler$(colors: _NSArray, itemTitles: _NSArray, onSelectionChange: NobjcObject | null): _NSMenu;
+    static paletteMenuWithColors$titles$selectionHandler$(colors: _NSArray, itemTitles: _NSArray, onSelectionChange: ((arg0: _NSMenu) => void) | null): _NSMenu;
     /**
      * Creates a palette menu displaying user-selectable color tags using the provided template image, tinted using the specified array of colors. Optionally allows observing changes to the selection state in the compact menu. The block is invoked after the selection has been updated. Currently selected items can be retrieved from the `selectedItems` property. Note that the palette menu is configured for display as an inline menu; you must set it as the submenu of another menu item, contained in a standard menu. The palette menu cannot be used to invoke the `popUpMenuPositioningItem` method, or attached directly to a popup button or toolbar item. @return An autoconfigured palette menu.
      */
-    static paletteMenuWithColors$titles$templateImage$selectionHandler$(colors: _NSArray, itemTitles: _NSArray, image: _NSImage, onSelectionChange: NobjcObject | null): _NSMenu;
+    static paletteMenuWithColors$titles$templateImage$selectionHandler$(colors: _NSArray, itemTitles: _NSArray, image: _NSImage, onSelectionChange: ((arg0: _NSMenu) => void) | null): _NSMenu;
     /**
      * Returns the zone used to allocate NSMenu objects. This is left in for compatibility and has returned NSDefaultMallocZone() since OS X 10.2. It is not necessary to use this - menus can be allocated the usual way.
      * @deprecated

package/dist/AppKit/NSMenuItem.d.ts

@@ -11,6 +11,7 @@ import type { _NSMenu } from "./NSMenu.js";
 import type { _NSMenuItemBadge } from "./NSMenuItemBadge.js";
 import type { _NSUserInterfaceItemIdentification } from "./NSUserInterfaceItemIdentification.js";
 import type { _NSView } from "./NSView.js";
+import type { NSControlStateValue } from "./NSControlStateValue.js";
 import type { NSEventModifierFlags } from "./NSEventModifierFlags.js";
 export declare class _NSMenuItem extends _NSObject {
     static alloc(): _NSMenuItem;
@@ -83,8 +84,8 @@ export declare class _NSMenuItem extends _NSObject {
     setAllowsAutomaticKeyEquivalentMirroring$(value: boolean): void;
     image(): _NSImage | null;
     setImage$(value: _NSImage | null): void;
-    state(): number;
-    setState$(value: number): void;
+    state(): NSControlStateValue;
+    setState$(value: NSControlStateValue): void;
     /** checkmark by default */
     onStateImage(): _NSImage;
     setOnStateImage$(value: _NSImage): void;

package/dist/AppKit/NSModalResponse.d.ts

@@ -0,0 +1,11 @@
+export declare const NSModalResponse: {
+    readonly Stop: -1000;
+    readonly Abort: -1001;
+    readonly Continue: -1002;
+    readonly OK: 1;
+    readonly Cancel: 0;
+    readonly NSAlertFirstButtonReturn: 1000;
+    readonly NSAlertSecondButtonReturn: 1001;
+    readonly NSAlertThirdButtonReturn: 1002;
+};
+export type NSModalResponse = typeof NSModalResponse[keyof typeof NSModalResponse];

package/dist/AppKit/NSModalResponse.js

@@ -0,0 +1,11 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const NSModalResponse = {
+    Stop: -1000,
+    Abort: -1001,
+    Continue: -1002,
+    OK: 1,
+    Cancel: 0,
+    NSAlertFirstButtonReturn: 1000,
+    NSAlertSecondButtonReturn: 1001,
+    NSAlertThirdButtonReturn: 1002,
+};

package/dist/AppKit/NSPDFPanel.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSPDFInfo } from "./NSPDFInfo.js";
@@ -14,7 +13,7 @@ export declare class _NSPDFPanel extends _NSObject {
     /**
      * Present a print panel to the user, document-modally. When the user has dismissed it, invoke the completionHandler block. If the user didn't click the 'Cancel' button, the given NSPDFInfo will be modified to reflect the user's chosen settings, if any.
      */
-    beginSheetWithPDFInfo$modalForWindow$completionHandler$(pdfInfo: _NSPDFInfo, docWindow: _NSWindow | null, completionHandler: NobjcObject): void;
+    beginSheetWithPDFInfo$modalForWindow$completionHandler$(pdfInfo: _NSPDFInfo, docWindow: _NSWindow | null, completionHandler: (arg0: number) => void): void;
     /**
      * Controller for the accessory views that will be presented in the panel by the methods below. When the panel is presented to the user the controller is automatically sent a -setRepresentedObject: message with an NSPDFInfo equivalent to those one passed to -beginSheetWithPDFInfo:modalForWindow:completionHandler:.
      */

package/dist/AppKit/NSPageLayout.d.ts

@@ -5,6 +5,7 @@ import type { _NSPrintInfo } from "./NSPrintInfo.js";
 import type { _NSView } from "./NSView.js";
 import type { _NSViewController } from "./NSViewController.js";
 import type { _NSWindow } from "./NSWindow.js";
+import type { NSPageLayoutResult } from "./NSPageLayoutResult.js";
 export declare class _NSPageLayout extends _NSObject {
     static alloc(): _NSPageLayout;
     static new(): _NSPageLayout;
@@ -19,7 +20,7 @@ export declare class _NSPageLayout extends _NSObject {
     /**
      * Displays a page layout panel as a sheet on a window. This method returns immediately. When the page layout panel is dismissed, calls the completion handler with NSPageLayoutResult as the argument.
      */
-    beginSheetUsingPrintInfo$onWindow$completionHandler$(printInfo: _NSPrintInfo, parentWindow: _NSWindow, handler: NobjcObject | null): void;
+    beginSheetUsingPrintInfo$onWindow$completionHandler$(printInfo: _NSPrintInfo, parentWindow: _NSWindow, handler: ((result: NSPageLayoutResult) => void) | null): void;
     /**
      * Present a page setup panel to the user, document-modally. When the user has dismissed it, send the message selected by didEndSelector to the delegate, with the contextInfo as the last argument. The method selected by didEndSelector must have the same signature as: - (void)pageLayoutDidEnd:(NSPageLayout *)pageLayout returnCode:(NSInteger)returnCode contextInfo:(void *)contextInfo;
      * @deprecated This method will be deprecated in a future release. Use -[NSPageLayout beginSheetUsingPrintInfo:onWindow:completionHandler:] instead.

package/dist/AppKit/NSPasteboard.d.ts

@@ -2,6 +2,7 @@ import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSData } from "../Foundation/NSData.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSFileWrapper } from "../Foundation/NSFileWrapper.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
@@ -72,15 +73,15 @@ export declare class _NSPasteboard extends _NSObject {
     /**
      * Determines whether the first pasteboard item matches the specified patterns, without notifying the person using the app. This method only gives an indication of whether the first pasteboard item matches a particular pattern, and doesn’t allow the app to access the item's contents. As a result, the system doesn’t notify the person using the app about reading the contents of the pasteboard. The following example shows how to use this method to find email and postal addresses in the first pasteboard item: ```obj-c [NSPasteboard.generalPasteboard detectPatternsForPatterns:[NSSet setWithArray:@[NSPasteboardDetectionPatternEmailAddress, NSPasteboardDetectionPatternPostalAddress]] completionHandler:^(NSSet<NSPasteboardDetectionPattern> *matchedPatterns, NSError *error) { if (error) { NSLog(@"Error: %@", error); return; } BOOL matchedEmail = [matchedPatterns containsObject:NSPasteboardDetectionPatternEmailAddress]; BOOL matchedPostal = [matchedPatterns containsObject: NSPasteboardDetectionPatternPostalAddress]; if (matchedEmail) { NSLog(@"Email address(es) detected"); } if (matchedPostal) { NSLog(@"Postal address(es) detected"); } if (!matchedEmail && !matchedPostal) { NSLog(@"Matched neither email nor postal addresses."); } }]; ``` - Parameters: - patterns: The patterns to detect on the pasteboard. - completionHandler: A block the system invokes after detecting patterns on the pasteboard. The block receives either a set with the patterns the system finds on the pasteboard or an error if detection fails.
      */
-    detectPatternsForPatterns$completionHandler$(patterns: _NSSet, completionHandler: NobjcObject | null): void;
+    detectPatternsForPatterns$completionHandler$(patterns: _NSSet, completionHandler: ((detectedPatterns: _NSSet, error: _NSError) => void) | null): void;
     /**
      * Determines whether the first pasteboard item matches the specified patterns, reading the contents if it finds a match. For details about the types returned for each pattern, see ``NSPasteboardDetectionPattern``. The following example shows how to use this method to find web URLs and web search terms in the first pasteboard item: ```obj-c [NSPasteboard.generalPasteboard detectValuesForPatterns:[NSSet setWithArray:@[NSPasteboardDetectionPatternProbableWebSearch, NSPasteboardDetectionPatternProbableWebURL]] completionHandler:^(NSDictionary<NSPasteboardDetectionPattern, id> *patternValues, NSError *error) { if (error) { NSLog(@"Error: %@", error); return; } NSString *searchString = (NSString*)patternValues[NSPasteboardDetectionPatternProbableWebSearch]; NSString *urlString = (NSString*)patternValues[NSPasteboardDetectionPatternProbableWebURL] ; if (searchString != nil) { NSLog(@"Web search retrieved: %@", searchString); } if (urlString != nil) { NSLog(@"Web URL retrieved: %@", urlString); } if (searchString == nil && urlString == nil) { NSLog(@"No web patterns retrieved."); } }]; ``` > Important: If the system finds a match when calling this method, the system informs the person using the app that the app is trying to read the contents of the pasteboard. If the person denies access to the pasteboard, the completion handler receives an error. - Parameters: - patterns: The patterns to detect on the pasteboard. - completionHandler: A block the system invokes after detecting patterns on the pasteboard. The block returns either a dictionary with the patterns the system finds on the pasteboard or an error if detection fails. The dictionary keys specify the matched patterns and the values specify the corresponding content of the pasteboard.
      */
-    detectValuesForPatterns$completionHandler$(patterns: _NSSet, completionHandler: NobjcObject | null): void;
+    detectValuesForPatterns$completionHandler$(patterns: _NSSet, completionHandler: ((detectedValues: _NSDictionary, error: _NSError) => void) | null): void;
     /**
      * Determines available metadata from the specified metadata types for the first pasteboard item, without notifying the person using the app. This method only gives access to limited types of metadata and doesn’t allow the app to access the contents. As a result, the system doesn’t notify the person using the app about reading the contents of the pasteboard. For details about the metadata returned for each type, see ``NSPasteboardMetadataType``. The following example shows how to use this method to find the content type of a file reference in the first item on the pasteboard: ```obj-c [NSPasteboard.generalPasteboard detectMetadataForTypes:[NSSet setWithArray:@[NSPasteboardMetadataTypeContentType]] completionHandler:^(NSDictionary<NSPasteboardMetadataType, id> *metadata, NSError *error) { if (error) { NSLog(@"Error: %@", error); return; } UTType *contentType = (UTType*)metadata[NSPasteboardMetadataTypeContentType]; if (contentType) { NSLog(@"Content type is: %@", contentType.identifier); } else { NSLog(@"Couldn't get content type"); } }]; ``` - Parameters: - types: The metadata types to detect on the pasteboard. - completionHandler: A block the system invokes after detecting metadata on the pasteboard. The block receives either a dictionary with the metadata types the system finds on the pasteboard or an error if detection fails. The dictionary keys specify the matched metadata types and the values specify the corresponding metadata.
      */
-    detectMetadataForTypes$completionHandler$(types: _NSSet, completionHandler: NobjcObject | null): void;
+    detectMetadataForTypes$completionHandler$(types: _NSSet, completionHandler: ((detectedMetadata: _NSDictionary, error: _NSError) => void) | null): void;
     writeFileContents$(filename: _NSString): boolean;
     readFileContentsType$toFile$(type: _NSString | null, filename: _NSString): _NSString | null;
     writeFileWrapper$(wrapper: _NSFileWrapper): boolean;

package/dist/AppKit/NSPasteboardItem.d.ts

@@ -1,6 +1,8 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.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 { _NSSet } from "../Foundation/NSSet.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -30,15 +32,15 @@ export declare class _NSPasteboardItem extends _NSObject {
     /**
      * Determines whether this pasteboard item matches the specified patterns, without notifying the person using the app. This method only gives an indication of whether a pasteboard item matches a particular pattern and doesn’t allow the app to access the item's contents. As a result, the system doesn’t notify the person using the app about reading the contents of the pasteboard. The following example shows how to use this method to find email and postal addresses in each item on the pasteboard: ```obj-c NSArray<NSPasteboardItem*> *items = NSPasteboard.generalPasteboard.pasteboardItems; __block NSUInteger idx = 0; for (NSPasteboardItem *item in items) { NSUInteger itemIndex = idx++; [item detectPatternsForPatterns:[NSSet setWithArray:@[NSPasteboardDetectionPatternEmailAddress, NSPasteboardDetectionPatternPostalAddress]] completionHandler:^(NSSet<NSPasteboardDetectionPattern> *matchedPatterns, NSError *error) { if (error) { NSLog(@"Item %lu: Error: %@", itemIndex, error); return; } BOOL matchedEmail = [matchedPatterns containsObject:NSPasteboardDetectionPatternEmailAddress]; BOOL matchedPostal = [matchedPatterns containsObject: NSPasteboardDetectionPatternPostalAddress]; if (matchedEmail) { NSLog(@"Item %lu - Email address(es) detected", itemIndex); } if (matchedPostal) { NSLog(@"Item %lu - Postal address(es) detected", itemIndex); } if (!matchedEmail && !matchedPostal) { NSLog(@"Item %lu - Matched neither email nor postal addresses.", itemIndex); } }]; } ``` - Parameters: - patterns: The patterns to detect on the pasteboard item. - completionHandler: A block that the system invokes after detecting patterns on the pasteboard item. The block receives either a set with the patterns the system finds on the pasteboard item or an error if detection fails.
      */
-    detectPatternsForPatterns$completionHandler$(patterns: _NSSet, completionHandler: NobjcObject | null): void;
+    detectPatternsForPatterns$completionHandler$(patterns: _NSSet, completionHandler: ((detectedPatterns: _NSSet, error: _NSError) => void) | null): void;
     /**
      * Determines whether this pasteboard item matches the specified patterns, reading the contents if it finds a match. For details about the types returned for each pattern, see ``NSPasteboardDetectionPattern``. The following example shows how to use this method to find web URLs and web search terms in each item on the pasteboard: ```obj-c NSArray<NSPasteboardItem*> *items = NSPasteboard.generalPasteboard.pasteboardItems; __block NSUInteger idx = 0; for (NSPasteboardItem *item in items) { NSUInteger itemIndex = idx++; [item detectValuesForPatterns:[NSSet setWithArray:@[NSPasteboardDetectionPatternProbableWebSearch, NSPasteboardDetectionPatternProbableWebURL]] completionHandler:^(NSDictionary<NSPasteboardDetectionPattern, id> *patternValues, NSError *error) { if (error) { NSLog(@"Item %lu: Error: %@", itemIndex, error); return; } NSString *searchString = (NSString*)patternValues[NSPasteboardDetectionPatternProbableWebSearch]; NSString *urlString = (NSString*)patternValues[NSPasteboardDetectionPatternProbableWebURL] ; if (searchString != nil) { NSLog(@"Item %lu - Web search retrieved: %@", itemIndex, searchString); } if (urlString != nil) { NSLog(@"Item %lu - Web URL retrieved: %@", itemIndex, urlString); } if (searchString == nil && urlString == nil) { NSLog(@"Item %lu - No web patterns retrieved.", itemIndex); } }]; } ``` > Important: If the system finds a match when calling this method, the system informs the person using the app that the app is trying to read the contents of the pasteboard. If the person denies access to the pasteboard, the completion handler receives an error. - Parameters: - patterns: The patterns to detect on the pasteboard item. - completionHandler: A block the system invokes after detecting patterns on the pasteboard item. The block returns either a dictionary with the patterns the system finds on the pasteboard item or an error if detection fails. The dictionary keys specify the matched patterns, and the values specify the corresponding content of the pasteboard.
      */
-    detectValuesForPatterns$completionHandler$(patterns: _NSSet, completionHandler: NobjcObject | null): void;
+    detectValuesForPatterns$completionHandler$(patterns: _NSSet, completionHandler: ((detectedValues: _NSDictionary, error: _NSError) => void) | null): void;
     /**
      * Determines available metadata from the specified metadata types for this pasteboard item, without notifying the person using the app. This method only gives access to limited types of metadata and doesn’t allow the app to access the contents. As a result, the system doesn’t notify the person using the app about reading the contents of the pasteboard. For details about the metadata returned for each type, see ``NSPasteboardMetadataType``. The following example shows how to iterate over each pasteboard item and, if the item is a URL that points to a file, get its content type with this method: ```obj-c NSArray<NSPasteboardItem*> *items = NSPasteboard.generalPasteboard.pasteboardItems; __block NSUInteger idx = 0; for (NSPasteboardItem *item in items) { NSUInteger itemIndex = idx++; [item detectMetadataForTypes:[NSSet setWithArray:@[NSPasteboardMetadataTypeContentType]] completionHandler:^(NSDictionary<NSPasteboardMetadataType, id> *metadata, NSError *error) { if (error) { NSLog(@"Item %lu - Error: %@", itemIndex, error); return; } UTType *contentType = (UTType*)metadata[NSPasteboardMetadataTypeContentType]; if (contentType) { NSLog(@"Item %lu - Content type is: %@", itemIndex, contentType.identifier); } else { NSLog(@"Item %lu - Couldn't get content type", itemIndex); } }]; } ``` - Parameters: - types: The metadata types to detect on the pasteboard item. - completionHandler: A block the system invokes after detecting metadata on the pasteboard item. The block receives either a dictionary with the metadata types the system finds on the pasteboard item or an error if detection fails. The dictionary keys specify the matched metadata types, and the values specify the corresponding metadata.
      */
-    detectMetadataForTypes$completionHandler$(types: _NSSet, completionHandler: NobjcObject | null): void;
+    detectMetadataForTypes$completionHandler$(types: _NSSet, completionHandler: ((detectedMetadata: _NSDictionary, error: _NSError) => void) | null): void;
     /** Returns an array of UTI strings of the data types supported by the receiver. */
     types(): _NSArray;
 }

package/dist/AppKit/NSPrintPanel.d.ts

@@ -8,6 +8,7 @@ import type { _NSViewController } from "./NSViewController.js";
 import type { _NSWindow } from "./NSWindow.js";
 import type { NSPrintPanelJobStyleHint } from "./NSPrintPanelJobStyleHint.js";
 import type { NSPrintPanelOptions } from "./NSPrintPanelOptions.js";
+import type { NSPrintPanelResult } from "./NSPrintPanelResult.js";
 export declare class _NSPrintPanel extends _NSObject {
     static alloc(): _NSPrintPanel;
     static new(): _NSPrintPanel;
@@ -27,7 +28,7 @@ export declare class _NSPrintPanel extends _NSObject {
     /**
      * Displays the print panel as a sheet on a window. This method returns immediately. When the print panel is dismissed, calls the completion handler with NSPrintPanelResult as the argument.
      */
-    beginSheetUsingPrintInfo$onWindow$completionHandler$(printInfo: _NSPrintInfo, parentWindow: _NSWindow, handler: NobjcObject | null): void;
+    beginSheetUsingPrintInfo$onWindow$completionHandler$(printInfo: _NSPrintInfo, parentWindow: _NSWindow, handler: ((result: NSPrintPanelResult) => void) | null): void;
     /**
      * Present a print panel to the user, document-modally. When the user has dismissed it, send the message selected by didEndSelector to the delegate, with the contextInfo as the last argument. The method selected by didEndSelector must have the same signature as: - (void)printPanelDidEnd:(NSPrintPanel *)printPanel returnCode:(NSInteger)returnCode contextInfo:(void *)contextInfo;
      * @deprecated This method will be deprecated in a future release. Use -[NSPrintPanel beginSheetUsingPrintInfo:onWindow:completionHandler:] instead.

package/dist/AppKit/NSSavePanel.d.ts

@@ -20,11 +20,11 @@ export declare class _NSSavePanel extends _NSPanel {
     /**
      * `NSSavePanel`/`NSOpenPanel`: Presents the panel as a sheet modal to `window` and returns immediately. Configure the panel before calling this method. The completion handler block will be called after the user has closed the panel, however, the open/save panel sheet may still be on screen. If you require the sheet to be offscreen (for example, to show an alert), first call `[savePanel orderOut:nil]` to close it. The `result` will be `NSModalResponseOK`, `NSModalResponseCancel`, or if the panel fails to display, `NSModalResponseAbort`.
      */
-    beginSheetModalForWindow$completionHandler$(window: _NSWindow, handler: NobjcObject): void;
+    beginSheetModalForWindow$completionHandler$(window: _NSWindow, handler: (result: number) => void): void;
     /**
      * `NSSavePanel`/`NSOpenPanel`: Presents the panel as a modeless window and returns immediately. Configure the panel before calling this method. The completion handler block will be called after the user has closed the panel. The `result` will be `NSModalResponseOK`, `NSModalResponseCancel`, or if the panel fails to display, `NSModalResponseAbort`.
      */
-    beginWithCompletionHandler$(handler: NobjcObject): void;
+    beginWithCompletionHandler$(handler: (result: number) => void): void;
     /**
      * `NSSavePanel`/`NSOpenPanel`: Presents the panel as an application modal window. Returns after the user has closed the panel. - Returns: `NSModalResponseOK`, `NSModalResponseCancel` or if the panel fails to display, `NSModalResponseAbort`.
      */

package/dist/AppKit/NSScrubber.d.ts

@@ -26,7 +26,7 @@ export declare class _NSScrubber extends _NSView {
     /**
      * Updates inside the @c performSequentialBatchUpdates block are processed and displayed all at once, including insertion, removal, moving, reloading items, and changing the selected index. Changes are performed iteratively using the same semantics as @c NSMutableArray. NSScrubber expects its dataSource to reflect the changes made inside @c -performSequentialBatchUpdates: immediately after the @c updateBlock finishes executing.
      */
-    performSequentialBatchUpdates$(updateBlock: NobjcObject): void;
+    performSequentialBatchUpdates$(updateBlock: () => void): void;
     /**
      * Inserts new items at the specified indexes. NSScrubber will request views for each new index from the @c dataSource. This method uses the same semantics as @c NSMutableArray; each index in the set specifies the destination index after all previous insertions have occurred. Therefore, an NSIndexSet of [1,2,3] will result in three new contiguous items.
      */