objcjs-types 0.1.0 → 0.2.1

package/dist/AppKit/NSDocument.d.ts

@@ -17,12 +17,15 @@ import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 import type { _NSUndoManager } from "../Foundation/NSUndoManager.js";
 import type { _NSUserActivity } from "../Foundation/NSUserActivity.js";
+import type { _NSEditorRegistration } from "./NSEditorRegistration.js";
+import type { _NSMenuItemValidation } from "./NSMenuItemValidation.js";
 import type { _NSPageLayout } from "./NSPageLayout.js";
 import type { _NSPrintInfo } from "./NSPrintInfo.js";
 import type { _NSPrintOperation } from "./NSPrintOperation.js";
 import type { _NSSavePanel } from "./NSSavePanel.js";
 import type { _NSSharingService } from "./NSSharingService.js";
 import type { _NSSharingServicePicker } from "./NSSharingServicePicker.js";
+import type { _NSUserActivityRestoring } from "./NSUserActivityRestoring.js";
 import type { _NSValidatedUserInterfaceItem } from "./NSValidatedUserInterfaceItem.js";
 import type { _NSWindow } from "./NSWindow.js";
 import type { _NSWindowController } from "./NSWindowController.js";
@@ -72,15 +75,15 @@ export declare class _NSDocument extends _NSObject {
     /**
      * Initialize a new empty document 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 initialized. The default implementation of this method just invokes [self init] and [self setFileType:typeName]. You can override this method to perform initialization that must be done when creating new documents but should not be done when opening existing documents. Your override should typically invoke super, or at least it must invoke -init, NSDocument's designated initializer, to initialize NSDocument's private instance variables.
      */
-    initWithType$error$(typeName: _NSString, outError: NobjcObject): _NSDocument | null;
+    initWithType$error$(typeName: _NSString, outError: NobjcObject | null): _NSDocument | null;
     /**
      * Initialize 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 initialized. The default implementation of this method invokes [self init], [self readFromURL:url ofType:typeName error:outError], [self setFileURL:url], [self setFileType:typeName], and [self setFileModificationDate:theModificationDate]. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self initWithContentsOfFile:url ofType:typeName] if -initWithContentsOfFile:ofType: is overridden and the URL uses the "file:" scheme. It still invokes [self setFileModificationDate:theModificationDate] in this situation.
      */
-    initWithContentsOfURL$ofType$error$(url: _NSURL, typeName: _NSString, outError: NobjcObject): _NSDocument | null;
+    initWithContentsOfURL$ofType$error$(url: _NSURL, typeName: _NSString, outError: NobjcObject | null): _NSDocument | null;
     /**
      * Initialize a document located by a URL, of a specified type, but by reading the contents for the document from another 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 initialized. The default implementation of this method invokes [self readFromURL:contentsURL ofType:typeName error:outError], [self setFileURL:urlOrNil], [self setAutosavedContentsFileURL:contentsURL], [self setFileType:typeName], and [self setFileModificationDate:theModificationDate]. It also invokes [self updateChangeCount:NSChangeReadOtherContents] if the two URLs aren't identical, so that -isDocumentEdited will always return YES until the user saves or reverts the document. To ease the adoption of the autosaving feature introduced in Mac OS 10.4, the default implementation of this method invokes [self initWithContentsOfFile:[contentsURL path] ofType:typeName] if -initWithContentsOfFile:ofType: is overridden and the URL uses the "file:" scheme. It still invokes [self setFileModificationDate:theModificationDate] and [self updateChangeCount:NSChangeReadOtherContents] in this situation. It still also invokes [self setFileURL:urlOrNil], to overwrite the incorrect invocation of -setFileName: that the override of -initWithContentsOfFile:ofType: likely did. urlOrNil will be nil if the initializing is being done as part of the reopening of an autosaved document when the autosaved document had never been saved in the first place.
      */
-    initForURL$withContentsOfURL$ofType$error$(urlOrNil: _NSURL | null, contentsURL: _NSURL, typeName: _NSString, outError: NobjcObject): _NSDocument | null;
+    initForURL$withContentsOfURL$ofType$error$(urlOrNil: _NSURL | null, contentsURL: _NSURL, typeName: _NSString, outError: NobjcObject | null): _NSDocument | null;
     /**
      * 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.
      */
@@ -104,35 +107,35 @@ export declare class _NSDocument extends _NSObject {
     /**
      * 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.
      */
-    revertDocumentToSaved$(sender: NobjcObject): void;
+    revertDocumentToSaved$(sender: NobjcObject | null): void;
     /**
      * Discard all unsaved document modifications and replace the document's contents by reading a file or file package located by a URL, of a specified type, and return YES if successful. If not successful, return NO after setting *outError to an NSError that encapsulates the reason why the document could not be reverted. The default implementation of this method invokes [self readFromURL:url ofType:typeName error:outError], [self setFileModificationDate:theModificationDate], [self updateChangeCount:NSChangeCleared], and, if the document has an undo manager, [[self undoManager] removeAllActions]. It also deletes autosaved contents files when they have become obsolete. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self revertToSavedFromFile:[url path] ofType:typeName] if -revertToSavedFromFile:ofType: is overridden and the URL uses the "file:" scheme. It still invokes [self updateChangeCount:NSChangeCleared] and [[self undoManager] removeAllActions] in this situation (because the default implementation of -revertToSavedFromFile:ofType: does not; -revertDocumentToSaved: used to, but doesn't any longer).
      */
-    revertToContentsOfURL$ofType$error$(url: _NSURL, typeName: _NSString, outError: NobjcObject): boolean;
+    revertToContentsOfURL$ofType$error$(url: _NSURL, typeName: _NSString, outError: NobjcObject | null): boolean;
     /**
      * Set the contents of this document by reading from a file or file package located by a URL, of a specified type, and return YES if successful. If not successful, return NO after setting *outError to an NSError that encapsulates the reason why the document could not be read. The default implementation of this method just creates an NSFileWrapper and invokes [self readFromFileWrapper:theFileWrapper ofType:typeName error:outError]. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self readFromFile:[url path] ofType:typeName] if -readFromFile:ofType: is overridden and the URL uses the "file:" scheme.
      */
-    readFromURL$ofType$error$(url: _NSURL, typeName: _NSString, outError: NobjcObject): boolean;
+    readFromURL$ofType$error$(url: _NSURL, typeName: _NSString, outError: NobjcObject | null): boolean;
     /**
      * Set the contents of this document by reading from a file wrapper of a specified type, and return YES if successful. If not successful, return NO after setting *outError to an NSError that encapsulates the reason why the document could not be read. The default implementation of this method invokes [self readFromData:[fileWrapper regularFileContents] ofType:typeName error:outError]. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self loadFileWrapperRepresentation:fileWrapper ofType:typeName] if -loadFileWrapperRepresentation:ofType: is overridden.
      */
-    readFromFileWrapper$ofType$error$(fileWrapper: _NSFileWrapper, typeName: _NSString, outError: NobjcObject): boolean;
+    readFromFileWrapper$ofType$error$(fileWrapper: _NSFileWrapper, typeName: _NSString, outError: NobjcObject | null): boolean;
     /**
      * Set the contents of this document by reading from data of a specified type, and return YES if successful. If not successful, return NO after setting *outError to an NSError that encapsulates the reason why the document could not be read. The default implementation of this method throws an exception because at least one of these three reading methods, or every method that may invoke -readFromURL:ofType:error: (!), must be overridden. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self loadDataRepresentation:data ofType:typeName] if -loadDataRepresentation:ofType: is overridden.
      */
-    readFromData$ofType$error$(data: _NSData, typeName: _NSString, outError: NobjcObject): boolean;
+    readFromData$ofType$error$(data: _NSData, typeName: _NSString, outError: NobjcObject | null): boolean;
     /**
      * Write the contents of this document to a file or file package located by a URL, formatted to a specified type, and return YES if successful. If not successful, return NO after setting *outError to an NSError that encapsulates the reason why the document could not be written. The default implementation of this method just invokes [self fileWrapperOfType:typeName error:outError], invokes [self unblockUserInteraction], and writes the returned file wrapper to disk. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self writeToFile:[url path] ofType:typeName] if -writeToFile:ofType: is overridden and the URL uses the "file:" scheme.
      */
-    writeToURL$ofType$error$(url: _NSURL, typeName: _NSString, outError: NobjcObject): boolean;
+    writeToURL$ofType$error$(url: _NSURL, typeName: _NSString, outError: NobjcObject | null): boolean;
     /**
      * Create and return a file wrapper that contains the contents of this document, formatted to a specified type, or return nil after setting *outError to an NSError that encapsulates the reason why the file wrapper could not be created. The default implementation of this method just invokes [self dataOfType:typeName], makes a file wrapper for that data, and returns the file wrapper. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self fileWrapperRepresentationOfType:typeName] if -fileWrapperRepresentationOfType: is overridden.
      */
-    fileWrapperOfType$error$(typeName: _NSString, outError: NobjcObject): _NSFileWrapper | null;
+    fileWrapperOfType$error$(typeName: _NSString, outError: NobjcObject | null): _NSFileWrapper | null;
     /**
      * Create and return a data object that contains the contents of this document, formatted to a specified type, or return nil after setting *outError to an NSError that encapsulates the reason why the data object could not be created. The default implementation of this method throws an exception because at least one of these three writing methods, or -writeToURL:ofType:saveOperation:originalContentsURL:error:, must be overridden. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self dataRepresentationOfType:typeName] if -dataRepresentationOfType: is overridden.
      */
-    dataOfType$error$(typeName: _NSString, outError: NobjcObject): _NSData | null;
+    dataOfType$error$(typeName: _NSString, outError: NobjcObject | null): _NSData | null;
     /**
      * If -saveToURL:ofType:forSaveOperation:completionHandler: is writing on a non-main thread because -canAsynchronouslyWriteToURL:ofType:forSaveOperation: has returned YES, but is still blocking the main thread, unblock the main thread. Otherwise, do nothing. For example, the default implementation of -fileWrapperOfType:error: invokes this when it has created the NSFileWrapper to return. Assuming that the NSFileWrapper will not be mutated by subsequent user actions, it is effectively a "snapshot" of the document's contents, and once it is created it is safe to resume handling user events on the main thread, even though some of those user events might change the document's contents before the NSFileWrapper has been safely written. You can invoke this method to make asynchronous saving actually asynchronous if you've overridden -writeSafelyToURL:ofType:forSaveOperation:error:, -writeToURL:forSaveOperation:originalContentsURL:error:, or -writeToURL:ofType:error: in such a way that the invocation of this method done by -writeToURL:ofType:error:'s default implementation won't happen during writing.
      */
@@ -140,35 +143,35 @@ export declare class _NSDocument extends _NSObject {
     /**
      * Write 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 return YES if successful. If not successful, return NO after setting *outError to an NSError that encapsulates the reason why the document could not be written. The default implementation of this method: 1) Either creates a temporary directory in which the document writing should be done, or renames the old on-disk version of the document, depending on what sort of save operation is being done, whether or not there's already a copy of the document on disk, and the capabilities of the file system to which writing is being done. The details of this are subject to change. 2) Invokes -writeToURL:ofType:forSaveOperation:originalContentsURL:error:. 3) Invokes -fileAttributesToWriteToURL:ofType:forSaveOperation:originalContentsURL:error: and writes the returned attributes, if any, to the file. Some attributes from the old on-disk version of the document may be copied at the same time, if applicable. 4) Moves the just-written file to its final location, or deletes the old on-disk version of the document, and deletes any temporary directories, depending on the same factors listed for step 1. For documents that return NO from +preservesVersions, the default implementation of this method invokes -keepBackupFile for NSSaveOperation to determine whether or not the old on-disk version of the document, if there was one, should be preserved after being renamed. If -keepBackupFile returns YES, or for documents that return YES from +preservesVersions, the default implementation of this method invokes [self backupFileURL] to determine the location for the old on-disk version of the document; if it returns nil, no backup file will be kept. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self writeWithBackupToFile:[url path] ofType:typeName saveOperation:aSaveOperation] if -writeWithBackupToFile:ofType:saveOperation: is overridden and the URL uses the "file:" scheme. The save operation used in this case will never be one of the autosaving ones; NSSaveToOperation will be used instead. This method is responsible for doing document writing in a way that minimizes the danger of leaving the disk to which writing is being done in an inconsistent state in the event of an application crash, system crash, hardware failure, power outage, etc. Because it 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 (the same was true of -writeWithBackupToFile:ofType:saveOperation:).
      */
-    writeSafelyToURL$ofType$forSaveOperation$error$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, outError: NobjcObject): boolean;
+    writeSafelyToURL$ofType$forSaveOperation$error$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, outError: NobjcObject | null): boolean;
     /**
      * Write 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 return YES if successful. If not successful, return NO after setting *outError to an NSError that encapsulates the reason why the document could not be written. The default implementation of this method merely invokes [self writeToURL:url ofType:typeName error:outError]. You can override this method instead of one of the methods in the "Simple Reading and Writing" section above if your document writing machinery needs access to the on-disk representation of the document version that is about to be overwritten. url will often not be the same value as [self fileURL]. Other times it will not be the same as the URL for the final save destination. Likewise, absoluteOriginalContentsURL will often not be the same value as [self fileURL], though it will be nil for documents that have never been saved. It will point to nothing if the document's on-disk representation has been deleted. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self writeToFile:[url path] ofType:typeName originalFile:[absoluteOriginalContentsURL path] saveOperation:aSaveOperation] if -writeToFile:ofType:originalFile:saveOperation: is overridden and both URLs use the "file:" scheme. The save operation used in this case will never be one of the autosaving ones; NSSaveToOperation will be used instead.
      */
-    writeToURL$ofType$forSaveOperation$originalContentsURL$error$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, absoluteOriginalContentsURL: _NSURL | null, outError: NobjcObject): boolean;
+    writeToURL$ofType$forSaveOperation$originalContentsURL$error$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, absoluteOriginalContentsURL: _NSURL | null, outError: NobjcObject | null): boolean;
     /**
      * Given that a file is being saved, return the attributes that should be written to a file or file package located by a URL, formatted to a specified type, for a particular kind of save operation. If not successful, return nil after setting *outError to an NSError that encapsulates the reason why attributes could not be returned. The set of valid file attributes is a subset of those understood by the NSFileManager class. The default implementation of this method returns an empty dictionary for an NSSaveOperation or NSAutosaveInPlaceOperation, or a dictionary with an appropriate NSFileExtensionHidden entry for any other kind of save operation. You can override this method to customize the attributes that are written to document files. For backward binary compatibility with Mac OS 10.5 and earlier the default implementation of this method instead returns a dictionary with NSFileHFSCreatorCode and NSFileHFSTypeCode entries that have a value of 0 for NSSaveOperation, in applications linked against Mac OS 10.5 or earlier. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self fileAttributesToWriteToFile:[url path] ofType:typeName saveOperation:aSaveOperation] if -fileAttributesToWriteToFile:ofType:saveOperation: is overridden and the URL uses the "file:" scheme. The save operation used in this case will never be one of the autosaving ones; NSSaveToOperation will be used instead. The default implementation of -[NSDocument writeSafelyToURL:ofType:forSaveOperation:error:] automatically copies important attributes like file permissions, creation date, and Finder info from the old on-disk version of a document to the new one during an NSSaveOperation or NSAutosaveInPlaceOperation. This method is meant to be used just for attributes that need to be written for the first time, for NSSaveAsOperations, NSSaveToOperations, and NSAutosaveAsOperations. Actually, url and absoluteOriginalContentsURL are passed in just for completeness; NSDocument's default implementation for instance doesn't even need to use them.
      */
-    fileAttributesToWriteToURL$ofType$forSaveOperation$originalContentsURL$error$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, absoluteOriginalContentsURL: _NSURL | null, outError: NobjcObject): _NSDictionary | null;
+    fileAttributesToWriteToURL$ofType$forSaveOperation$originalContentsURL$error$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, absoluteOriginalContentsURL: _NSURL | null, outError: NobjcObject | null): _NSDictionary | null;
     /**
      * The action of the File menu's Save item in a document-based application. The default implementation of this method merely invokes [self saveDocumentWithDelegate:nil didSaveSelector:NULL contextInfo:NULL].
      */
-    saveDocument$(sender: NobjcObject): void;
+    saveDocument$(sender: NobjcObject | null): void;
     /**
      * The action of the File menu's Save As... item in a document-based application. The default implementation of this method merely invokes [self runModalSavePanelForSaveOperation:NSSaveAsOperation delegate:nil didSaveSelector:NULL contextInfo:NULL].
      */
-    saveDocumentAs$(sender: NobjcObject): void;
+    saveDocumentAs$(sender: NobjcObject | null): void;
     /**
      * The action of the File menu's Export... item in a document-based application (actually, the menu item goes by different names in different applications; check the Human Interface Guidelines). The default implementation of this method merely invokes [self runModalSavePanelForSaveOperation:NSSaveToOperation delegate:nil didSaveSelector:NULL contextInfo:NULL].
      */
-    saveDocumentTo$(sender: NobjcObject): void;
+    saveDocumentTo$(sender: NobjcObject | null): void;
     /**
      * If a save operation can be performed without further user intervention (at the very least, neither -fileURL nor -fileType return nil), then save the document. Otherwise, present a save panel to the user and then save the document if the user OKs the panel. When saving is completed or has been cancelled, send the message selected by didSaveSelector to the delegate, with the contextInfo as the last argument. The method selected by didSaveSelector must have the same signature as: - (void)document:(NSDocument *)document didSave:(BOOL)didSaveSuccessfully contextInfo:(void *)contextInfo; The default implementation of this method first makes sure that any editor registered using Cocoa Bindings' NSEditorRegistration protocol has committed its changes, then invokes [self runModalSavePanelForSaveOperation:NSSaveAsOperation delegate:delegate didSaveSelector:didSaveSelector contextInfo:inContextInfo] right away if a save panel must be presented. Otherwise, it may present a panel asking the user to make a decision for any of the following situations: 1) The document's file or file package was modified by something other than the current application since it was opened or most recently saved. 2) The document's file or file package was moved or renamed since it was opened or most recently saved. 3) The document's file or file package was deleted or trashed since it was opened or most recently saved. The list of conditions for which NSDocument checks is subject to change. Regardless, the default implementation of this method always invokes either -runModalSavePanelForSaveOperation:delegate:didSaveSelector:contextInfo: or -saveToURL:ofType:forSaveOperation:delegate:didSaveSelector:contextInfo: unless the user cancels one of the panels it presents.
      */
-    saveDocumentWithDelegate$didSaveSelector$contextInfo$(delegate: NobjcObject, didSaveSelector: string | null, contextInfo: Uint8Array | null): void;
+    saveDocumentWithDelegate$didSaveSelector$contextInfo$(delegate: NobjcObject | null, didSaveSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * Present a save panel to the user, then try to save the document if the user OKs the panel. When saving is completed, regardless of success or failure, or has been cancelled, send the message selected by didSaveSelector to the delegate, with the contextInfo as the last argument. The method selected by didSaveSelector must have the same signature as: - (void)document:(NSDocument *)document didSave:(BOOL)didSaveSuccessfully contextInfo:(void *)contextInfo; The default implementation of this method first makes sure that any editor registered using Cocoa Bindings' NSEditorRegistration protocol has committed its changes. It then creates a save panel, adds a standard file formats selection control if there is more than one file type for the user to choose from and self.savePanelShowsFileFormatsControl returns YES, sets various attributes of the panel, invokes [self prepareSavePanel:theSavePanel] to provide an opportunity for customization, and presents the panel. If the user OKs the panel -saveToURL:ofType:forSaveOperation:delegate:didSaveSelector:contextInfo: is invoked. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self saveToFile:nil saveOperation:saveOperation delegate:delegate didSaveSelector:contextInfo:] if -saveToFile:saveOperation:delegate:didSaveSelector:contextInfo: is overridden, even if the user cancels the panel (because that's what 10.3 did).
      */
-    runModalSavePanelForSaveOperation$delegate$didSaveSelector$contextInfo$(saveOperation: NSSaveOperationType, delegate: NobjcObject, didSaveSelector: string | null, contextInfo: Uint8Array | null): void;
+    runModalSavePanelForSaveOperation$delegate$didSaveSelector$contextInfo$(saveOperation: NSSaveOperationType, delegate: NobjcObject | null, didSaveSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * Given the save panel that -runModalSavePanelForSaveOperation:delegate:didSaveSelector:contextInfo: is about to present to the user, make any final changes before it is presented, and return YES for success. Return NO for failure, to cancel the save operation. The default implementation of this method just returns YES.
      */
@@ -176,11 +179,11 @@ 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. When saving is completed, regardless of success or failure, send the message selected by didSaveSelector to the delegate, with the contextInfo as the last argument. The method selected by didSaveSelector must have the same signature as: - (void)document:(NSDocument *)document didSave:(BOOL)didSaveSuccessfully contextInfo:(void *)contextInfo; The default implementation of this method first makes sure that any editor registered using Cocoa Bindings' NSEditorRegistration protocol has committed its changes (except for autosave operations), then invokes [self saveToURL:url ofType:typeName forSaveOperation:saveOperation completionHandler:aCompletionHandler] and, if that completion handler is passed an NSError when it is invoked, presents the error to the user in a document-modal panel before messaging the delegate.
      */
-    saveToURL$ofType$forSaveOperation$delegate$didSaveSelector$contextInfo$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, delegate: NobjcObject, didSaveSelector: string | null, contextInfo: Uint8Array | null): void;
+    saveToURL$ofType$forSaveOperation$delegate$didSaveSelector$contextInfo$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, delegate: NobjcObject | null, didSaveSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * 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): void;
+    saveToURL$ofType$forSaveOperation$completionHandler$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, completionHandler: NobjcObject | 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.
      */
@@ -188,7 +191,7 @@ export declare class _NSDocument extends _NSObject {
     /**
      * Return YES if saving the user's changes to the document file is probably what they want, or NO after setting *outError to an NSError that encapsulates the reason why it might not be. The default implementation of this method checks for documents that have not been changed in a while ("a while" is subject to change) or are saved in folders where the user typically does not edit documents (the ~/Downloads folder, for example; also subject to change). When it senses one of those cases it returns NO with an NSError that has recovery options like "Duplicate," "Cancel", and "Unlock." In an application that has adopted Mac OS 10.7's new document model by overriding +autosavesInPlace and making it return YES, you can override this method to customize the autosaving safety checking that NSDocument does by default. You can remove NSDocument's default checking by overriding this method and not invoking super. You can add to NSDocument's default checking by invoking super and then doing your own checking if [super checkAutosavingSafetyAndReturnError:] did not signal an error. For example, TextEdit overrides this method to ask the user what to do when opening a document file has been lossy and overwriting that file might therefore be lossy. Other combinations of your override invoking super are possible. When autosaving in place is turned on an NSDocument may invoke this method when it receives notification from its NSUndoManager that the user changed the document, or undid or redid a change. (Or it may not. NSDocument does not invoke this method for scripted changes or after some kinds of reverting.) If an error is returned it presents the error to the user, allowing the user to choose a recovery option. If the error is recovered from then it repeats this until no error is signalled, to make sure that all checks have been done. This means that when you signal an error and the user's choice of recovery option indicates that they have seen and disregarded a safety concern you must record that fact, and not do that particular safety check again. Once all errors are recovered from NSDocument continues on by invoking -updateChangeCount:, which it has done in response to NSUndoManager notifications since Mac OS 10.0. If an error is not recovered from then NSDocument invokes -[NSUndoManager undo] or -[NSUndoManager redo] to roll back the change. So, some of the NSError recovery options you let the user select, like NSDocument's own "Duplicate and "Cancel," should indicate failed recovery and that will cause the document to be unchanged afterward.
      */
-    checkAutosavingSafetyAndReturnError$(outError: NobjcObject): boolean;
+    checkAutosavingSafetyAndReturnError$(outError: NobjcObject | null): boolean;
     /**
      * Schedule periodic autosaving for the purpose of crash protection. The default implementation of this method generally checks to see if autosaving is turned on and if so, and if [self hasUnautosavedChanges] returns YES, schedules an NSTimer to invoke -autosaveDocumentWithDelegate:didAutosaveSelector:contextInfo: in the future. If [self hasUnautosavedChanges] returns NO it will unschedule any previously scheduled timer. It takes care not to cause -autosaveDocumentWithDelegate:didAutosaveSelector:contextInfo: to be invoked before a previous invocation caused by it has finished. The exact timings it uses are complicated and subject to change in future releases of Mac OS X. You can override this method to control when exactly periodic autosaving happens. It is invoked by -updateChangeCount: and -updateChangeCountWithToken:forSaveOperation:.
      */
@@ -196,19 +199,19 @@ export declare class _NSDocument extends _NSObject {
     /**
      * Autosave the document's contents if it needs autosaving, and then send the message selected by didAutosaveSelector to the delegate, with the contextInfo as the last argument. The method selected by didAutosaveSelector must have the same signature as: - (void)document:(NSDocument *)document didAutosave:(BOOL)didAutosaveSuccessfully contextInfo:(void *)contextInfo; If any error occurs while autosaving, it must be reported to the user, typically in a document-modal alert panel, before the delegate is messaged with succeeded:NO. The default implementation of this method simply invokes [self autosaveWithImplicitCancellability:YES completionHandler:aCompletionHandler] and then presents to the user any error that occurs. This method is only invoked by AppKit itself as a result of -scheduleAutosaving being invoked. It is not invoked for any of the purposes of autosaving introduced by Mac OS 10.7's new document model that is triggered by +autosavesInPlace returning YES.
      */
-    autosaveDocumentWithDelegate$didAutosaveSelector$contextInfo$(delegate: NobjcObject, didAutosaveSelector: string | null, contextInfo: Uint8Array | null): void;
+    autosaveDocumentWithDelegate$didAutosaveSelector$contextInfo$(delegate: NobjcObject | null, didAutosaveSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * 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): void;
+    autosaveWithImplicitCancellability$completionHandler$(autosavingIsImplicitlyCancellable: boolean, completionHandler: NobjcObject | 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.
      */
-    browseDocumentVersions$(sender: NobjcObject): void;
+    browseDocumentVersions$(sender: NobjcObject | null): void;
     /**
      * 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): void;
+    stopBrowsingVersionsWithCompletionHandler$(completionHandler: NobjcObject | 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.
      */
@@ -220,64 +223,64 @@ export declare class _NSDocument extends _NSObject {
     /**
      * The action of the File menu's Duplicate item in a document-based application. The default implementation of this method merely invokes [self duplicateDocumentWithDelegate:nil didDuplicateSelector:NULL contextInfo:NULL].
      */
-    duplicateDocument$(sender: NobjcObject): void;
+    duplicateDocument$(sender: NobjcObject | null): void;
     /**
      * Create a new document whose contents are the same as the receiver's and that doesn't yet have a fileURL. When duplicating is completed, regardless of success or failure, or has been rejected one way or another by the user, send the message selected by didDuplicateSelector to the delegate, with the contextInfo as the last argument. The method selected by didDuplicateSelector must have the same signature as: - (void)document:(NSDocument *)document didDuplicate:(BOOL)didDuplicate contextInfo:(void *)contextInfo; The default implementation of this method first makes sure that any editor registered using Cocoa Bindings' NSEditorRegistration protocol has committed its changes, then checks to see if there are recent changes that might have been inadvertent and, if so, presents a panel giving the user the choice of canceling, duplicating, or duplicating then also discarding recent changes. Unless the user cancels duplicating, or if no panel was presented, it then invokes -duplicateAndReturnError:. If the user chose duplicating and discarding it also discards recent changes after duplicating.
      */
-    duplicateDocumentWithDelegate$didDuplicateSelector$contextInfo$(delegate: NobjcObject, didDuplicateSelector: string | null, contextInfo: Uint8Array | null): void;
+    duplicateDocumentWithDelegate$didDuplicateSelector$contextInfo$(delegate: NobjcObject | null, didDuplicateSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * Create and return a new document whose contents are the same as the receiver and that doesn't yet have a fileURL, 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 duplicated. The default implementation of this method first uses -writeSafelyToURL:ofType:forSaveOperation:error: to write the document's current contents to a file located in the same directory that is used for the autosaved contents of untitled documents and with the same sort of name, then invokes [[NSDocumentController sharedDocumentController] duplicateDocumentWithContentsOfURL:newContentsURL copying:NO displayName:aDisplayName error:outError]. The display name parameter is either [self displayName] if self has its own name, the display name of the original document if self is a duplicate, or nil if self is untitled. You can override this method to customize what is done during document duplication, but if your override does not invoke -[NSDocumentController duplicateDocumentWithContentsOfURL:copying:displayName:error:] you must take care to do things that that method does, especially invoking -[NSDocumentController addDocument:] and +[NSFileCoordinator addFilePresenter:].
      */
-    duplicateAndReturnError$(outError: NobjcObject): _NSDocument | null;
+    duplicateAndReturnError$(outError: NobjcObject | null): _NSDocument | null;
     /**
      * The action of the Rename menu item in a document-based application. The default implementation of this method initiates a renaming session in the window returned by [self windowForSheet].
      */
-    renameDocument$(sender: NobjcObject): void;
+    renameDocument$(sender: NobjcObject | null): void;
     /**
      * The action of the Move to iCloud… menu item in a document-based application. The default implementation of this method presents an alert, asking the user to confirm the move, then invokes -moveToURL:completionHandler: with a URL in the application's default ubiquity container.
      */
-    moveDocumentToUbiquityContainer$(sender: NobjcObject): void;
+    moveDocumentToUbiquityContainer$(sender: NobjcObject | null): void;
     /**
      * The action of the Move To… menu item in a document-based application. The default implementation of this method merely invokes [self moveDocumentWithCompletionHandler:nil].
      */
-    moveDocument$(sender: NobjcObject): void;
+    moveDocument$(sender: NobjcObject | null): void;
     /**
      * 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): void;
+    moveDocumentWithCompletionHandler$(completionHandler: NobjcObject | 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): void;
+    moveToURL$completionHandler$(url: _NSURL, completionHandler: NobjcObject | 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.
      */
-    lockDocument$(sender: NobjcObject): void;
-    unlockDocument$(sender: NobjcObject): void;
+    lockDocument$(sender: NobjcObject | null): void;
+    unlockDocument$(sender: NobjcObject | null): void;
     /**
      * 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): void;
+    lockDocumentWithCompletionHandler$(completionHandler: NobjcObject | 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): void;
+    lockWithCompletionHandler$(completionHandler: NobjcObject | 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): void;
+    unlockDocumentWithCompletionHandler$(completionHandler: NobjcObject | 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): void;
+    unlockWithCompletionHandler$(completionHandler: NobjcObject | 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.
      */
-    runPageLayout$(sender: NobjcObject): void;
+    runPageLayout$(sender: NobjcObject | null): void;
     /**
      * Present a page layout panel to the user. When the page layout panel has been dismissed, regardless of whether the user cancelled or OK'ed it, send the message selected by didRunSelector to the delegate, with the contextInfo as the last argument. The method selected by didRunSelector must have the same signature as: - (void)document:(NSDocument *)document didRunPageLayoutAndUserAccepted:(BOOL)userAccepted contextInfo:(void *)contextInfo; The default implementation of this method creates a page layout panel, invokes [self preparePageLayout:thePageLayoutPanel] to provide an opportunity for customization, then presents the panel.
      */
-    runModalPageLayoutWithPrintInfo$delegate$didRunSelector$contextInfo$(printInfo: _NSPrintInfo, delegate: NobjcObject, didRunSelector: string | null, contextInfo: Uint8Array | null): void;
+    runModalPageLayoutWithPrintInfo$delegate$didRunSelector$contextInfo$(printInfo: _NSPrintInfo, delegate: NobjcObject | null, didRunSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * Given the page layout panel that -runModalPageLayoutWithPrintInfo:delegate:didRunSelector:contextInfo: is about to present to the user, make any final changes before it is presented, and return YES for success. Return NO for failure, to cancel the presentation of the panel. The default implementation of this method just returns YES.
      */
@@ -289,27 +292,27 @@ export declare class _NSDocument extends _NSObject {
     /**
      * The action of the File menu's Print... item in a document-based application. The default implementation of this method merely invokes [self printDocumentWithSettings:[NSDictionary dictionary] showPrintPanel:YES delegate:nil didPrintSelector:NULL contextInfo:NULL].
      */
-    printDocument$(sender: NobjcObject): void;
+    printDocument$(sender: NobjcObject | null): void;
     /**
      * Print the document. If showing of the print panel is specified, present it first, and print only if the user OKs the panel. The NSPrintInfo attributes in the passed-in printSettings dictionary should be added to a copy of the document's print info, and the resulting print info should be used for the operation. When printing is completed or has been cancelled, send the message selected by didPrintSelector to the delegate, with the contextInfo as the last argument. The method selected by didPrintSelector must have the same signature as: - (void)document:(NSDocument *)document didPrint:(BOOL)didPrintSuccessfully contextInfo:(void *)contextInfo; The default implementation of this method first makes sure that any editor registered using Cocoa Bindings' NSEditorRegistration protocol has committed its changes, then invokes [self printOperationWithSettings:printSettings error:&anError]. If nil is returned it presents the error to the user in a document-modal panel before messaging the delegate. Otherwise it invokes [thePrintOperation setShowsPrintPanel:showPrintPanel] then [self runModalPrintOperation:thePrintOperation delegate:delegate didRunSelector:didPrintSelector contextInfo:contextInfo]. Starting in OS X 10.6, if the printSettings dictionary has an NSPrintJobDisposition entry whose value is NSPrintSaveJob, while lacking an NSPrintJobSavingURL or NSPrintSavePath entry indicating where the PDF file should be written, then the default implementation of this method will present a save panel asking the user where the PDF file should be saved. Additionally, starting in OS X 10.9, the default implementation of this method will invoke -PDFPrintOperation instead of -printOperationWithSettings:error: in this scenario. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method invokes [self printShowingPrintPanel:showPrintPanel] if -printShowingPrintPanel: is overridden. When doing this it uses private functionality to arrange for 1) the print settings to take effect despite the fact that the override of -printShowingPrintPanel: can't possibly know about them, and 2) getting notified when the print operation has been completed, so it can message the delegate at the correct time. Correct messaging of the delegate is necessary for correct handling of the Print Apple event.
      */
-    printDocumentWithSettings$showPrintPanel$delegate$didPrintSelector$contextInfo$(printSettings: _NSDictionary, showPrintPanel: boolean, delegate: NobjcObject, didPrintSelector: string | null, contextInfo: Uint8Array | null): void;
+    printDocumentWithSettings$showPrintPanel$delegate$didPrintSelector$contextInfo$(printSettings: _NSDictionary, showPrintPanel: boolean, delegate: NobjcObject | null, didPrintSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * Create a print operation that can be run to print the document's current contents, and return it if successful. If not successful, return nil after setting *outError to an NSError that encapsulates the reason why the print operation could not be created. The NSPrintInfo attributes in the passed-in printSettings dictionary should be added to a copy of the document's print info, and the resulting print info should be used for the operation. The default implementation of this method does nothing. You must override it to enable printing in your application.
      */
-    printOperationWithSettings$error$(printSettings: _NSDictionary, outError: NobjcObject): _NSPrintOperation | null;
+    printOperationWithSettings$error$(printSettings: _NSDictionary, outError: NobjcObject | null): _NSPrintOperation | null;
     /**
      * Run a print operation, possibly with printing UI presented document-modally. When printing is completed, regardless of success or failure, or has been cancelled, send the message selected by didRunSelector to the delegate, with the contextInfo as the last argument. The method selected by didRunSelector must have the same signature as: - (void)document:(NSDocument *)document didRunPrintOperation:(BOOL)didPrintSuccessfully contextInfo:(void *)contextInfo;
      */
-    runModalPrintOperation$delegate$didRunSelector$contextInfo$(printOperation: _NSPrintOperation, delegate: NobjcObject, didRunSelector: string | null, contextInfo: Uint8Array | null): void;
+    runModalPrintOperation$delegate$didRunSelector$contextInfo$(printOperation: _NSPrintOperation, delegate: NobjcObject | null, didRunSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * The action of the File menu's Export As PDF... item in a document-based application. The default implementation of this method merely invokes [self printDocumentWithSettings:@{ NSPrintJobDisposition : NSPrintSaveJob } showPrintPanel:NO delegate:nil didPrintSelector:NULL contextInfo:NULL].
      */
-    saveDocumentToPDF$(sender: NobjcObject): void;
+    saveDocumentToPDF$(sender: NobjcObject | null): void;
     /**
      * 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): void;
+    shareDocumentWithSharingService$completionHandler$(sharingService: _NSSharingService, completionHandler: NobjcObject | 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.
      */
@@ -329,7 +332,7 @@ export declare class _NSDocument extends _NSObject {
     /**
      * Methods that are declared by NSResponder and also implemented by NSDocument, even though for historical reasons NSDocument is not a subclass of NSResponder. NSDocument's default implementations are equivalent to NSResponder's while treating the shared NSDocumentController as the "next responder" and forwarding error presentation messages to it, despite the fact that for historical reasons NSDocumentController is not a subclass of NSResponder either. NSWindowController has overrides of -presentError:modalForWindow:delegate:didPresentSelector:contextInfo: and -presentError: that treat the window controller's document as the "next responder" and forward these messages to it, if the window controller has a document (some do, some don't). The default implementations of several NSDocument methods invoke -presentError:modalForWindow:delegate:didPresentSelector:contextInfo:. You can customize the presentation of errors on a per-NSDocument-subclass basis by overriding -willPresentError:. Your override should follow the advice given for overriding of -[NSResponder willPresentError:].
      */
-    presentError$modalForWindow$delegate$didPresentSelector$contextInfo$(error: _NSError, window: _NSWindow, delegate: NobjcObject, didPresentSelector: string | null, contextInfo: Uint8Array | null): void;
+    presentError$modalForWindow$delegate$didPresentSelector$contextInfo$(error: _NSError, window: _NSWindow, delegate: NobjcObject | null, didPresentSelector: string | null, contextInfo: Uint8Array | null): void;
     presentError$(error: _NSError): boolean;
     willPresentError$(error: _NSError): _NSError;
     /**
@@ -361,7 +364,7 @@ export declare class _NSDocument extends _NSObject {
     /**
      * If the window controller is one whose closing results in the document being closed too, or there is only one window controller attached to the document, do the exact same thing that -canCloseDocumentWithDelegate:shouldCloseSelector:contextInfo: would do. Otherwise send the message selected by shouldCloseSelector to the delegate, with the contextInfo as the last argument, specifying that the window controller should be closed. 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 sends the window controller a -shouldCloseDocument message and, if the result is YES or the current count of window controllers is one, merely invokes [self canCloseDocumentWithDelegate:delegate shouldCloseSelector:shouldCloseSelector contextInfo:contextInfo]. Otherwise it messages the delegate as described above. You can override this method, but typically you would not invoke it. NSWindow invokes this method for any window that has a window controller and a document associated with it, before sending the window delegate any -windowShouldClose: message.
      */
-    shouldCloseWindowController$delegate$shouldCloseSelector$contextInfo$(windowController: _NSWindowController, delegate: NobjcObject, shouldCloseSelector: string | null, contextInfo: Uint8Array | null): void;
+    shouldCloseWindowController$delegate$shouldCloseSelector$contextInfo$(windowController: _NSWindowController, delegate: NobjcObject | null, shouldCloseSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * Set the name for this document that is fit for presentation to the user. If the value is nil then a name based on -defaultDraftName is used.
      */
@@ -382,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): void;
-    relinquishPresentedItemToWriter$(writer: NobjcObject): void;
-    savePresentedItemChangesWithCompletionHandler$(completionHandler: NobjcObject): void;
-    accommodatePresentedItemDeletionWithCompletionHandler$(completionHandler: NobjcObject): void;
+    relinquishPresentedItemToReader$(reader: NobjcObject | null): void;
+    relinquishPresentedItemToWriter$(writer: NobjcObject | null): void;
+    savePresentedItemChangesWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    accommodatePresentedItemDeletionWithCompletionHandler$(completionHandler: NobjcObject | null): void;
     presentedItemDidMoveToURL$(newURL: _NSURL): void;
     presentedItemDidChange(): void;
     presentedItemDidChangeUbiquityAttributes$(attributes: _NSSet): void;
@@ -396,7 +399,7 @@ export declare class _NSDocument extends _NSObject {
      * Methods that were deprecated in Mac OS 10.6. See the comments above for information about when your overrides of them are still invoked, for backward binary compatibility.
      * @deprecated Use -saveToURL:ofType:forSaveOperation:completionHandler: instead
      */
-    saveToURL$ofType$forSaveOperation$error$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, outError: NobjcObject): boolean;
+    saveToURL$ofType$forSaveOperation$error$(url: _NSURL, typeName: _NSString, saveOperation: NSSaveOperationType, outError: NobjcObject | null): boolean;
     /**
      * Methods that were deprecated in Mac OS 10.4. See the comments above for information about when your overrides of them are still invoked, for backward binary compatibility.
      * @deprecated
@@ -409,9 +412,9 @@ export declare class _NSDocument extends _NSObject {
     /** @deprecated */
     fileWrapperRepresentationOfType$(type: _NSString): _NSFileWrapper | null;
     /** @deprecated */
-    initWithContentsOfFile$ofType$(absolutePath: _NSString, typeName: _NSString): NobjcObject;
+    initWithContentsOfFile$ofType$(absolutePath: _NSString, typeName: _NSString): NobjcObject | null;
     /** @deprecated */
-    initWithContentsOfURL$ofType$(url: _NSURL, typeName: _NSString): NobjcObject;
+    initWithContentsOfURL$ofType$(url: _NSURL, typeName: _NSString): NobjcObject | null;
     /** @deprecated */
     loadDataRepresentation$ofType$(data: _NSData, type: _NSString): boolean;
     /** @deprecated */
@@ -429,7 +432,7 @@ export declare class _NSDocument extends _NSObject {
     /** @deprecated */
     runModalPageLayoutWithPrintInfo$(printInfo: _NSPrintInfo): number;
     /** @deprecated */
-    saveToFile$saveOperation$delegate$didSaveSelector$contextInfo$(fileName: _NSString, saveOperation: NSSaveOperationType, delegate: NobjcObject, didSaveSelector: string | null, contextInfo: Uint8Array | null): void;
+    saveToFile$saveOperation$delegate$didSaveSelector$contextInfo$(fileName: _NSString, saveOperation: NSSaveOperationType, delegate: NobjcObject | null, didSaveSelector: string | null, contextInfo: Uint8Array | null): void;
     /** @deprecated */
     setFileName$(fileName: _NSString | null): void;
     /** @deprecated */
@@ -444,13 +447,13 @@ export declare class _NSDocument extends _NSObject {
      * On macOS, the default implementation of this will put the fileURL into the userInfo with the NSUserActivityDocumentURLKey. NSDocument will automatically call needsSave on the userActivity when the fileURL changes.
      */
     updateUserActivityState$(activity: _NSUserActivity): void;
-    handleSaveScriptCommand$(command: _NSScriptCommand): NobjcObject;
-    handleCloseScriptCommand$(command: _NSCloseCommand): NobjcObject;
-    handlePrintScriptCommand$(command: _NSScriptCommand): NobjcObject;
+    handleSaveScriptCommand$(command: _NSScriptCommand): NobjcObject | null;
+    handleCloseScriptCommand$(command: _NSCloseCommand): NobjcObject | null;
+    handlePrintScriptCommand$(command: _NSScriptCommand): NobjcObject | null;
     /**
      * 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): void;
+    restoreDocumentWindowWithIdentifier$state$completionHandler$(identifier: _NSString, state: _NSCoder, completionHandler: NobjcObject | null): void;
     /**
      * NSDocument implements the NSRestorableState methods, even though it itself is not an NSResponder.
      */
@@ -539,8 +542,8 @@ export declare class _NSDocument extends _NSObject {
      */
     allowsDocumentSharing(): boolean;
     /** Preview representable activity items, used for sharing and collaboration. */
-    previewRepresentableActivityItems(): NobjcObject;
-    setPreviewRepresentableActivityItems$(value: NobjcObject): void;
+    previewRepresentableActivityItems(): _NSArray;
+    setPreviewRepresentableActivityItems$(value: _NSArray): void;
     /**
      * Return YES if the document has changes that have not been saved, NO otherwise, primarily determined by the history of previous invocations of -updateChangeCount:. The default implementation of this method returns NO immediately after invocation of -updateChangeCount:NSChangeCleared. It will then return YES if subsequent invocations of -updateChangeCount: have recorded a situation in which the document has changes that have not been saved. Also, it will always return YES after invocation of -updateChangeCount:NSChangeReadOtherContents, until the next invocation of -updateChangeCount:NSChangeCleared. (-updateChangeCount:NSChangeAutosaved has no effect on what the default implementation of this method returns.) Lastly, because NSDocument implements Cocoa Bindings' NSEditorRegistration protocol, the default implementation will return YES whenever there are registered key-value binding editors.
      */
@@ -595,3 +598,5 @@ export declare class _NSDocument extends _NSObject {
     setLastComponentOfFileName$(value: _NSString): void;
     objectSpecifier(): _NSScriptObjectSpecifier;
 }
+export interface _NSDocument extends _NSEditorRegistration, _NSMenuItemValidation, _NSUserActivityRestoring {
+}