objcjs-types 0.1.0 → 0.2.1

package/dist/AppKit/NSDocumentController.d.ts

@@ -7,9 +7,11 @@ import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 import type { _NSDocument } from "./NSDocument.js";
 import type { _NSMenuItem } from "./NSMenuItem.js";
+import type { _NSMenuItemValidation } from "./NSMenuItemValidation.js";
 import type { _NSOpenPanel } from "./NSOpenPanel.js";
 import type { _NSValidatedUserInterfaceItem } from "./NSValidatedUserInterfaceItem.js";
 import type { _NSWindow } from "./NSWindow.js";
+import type { _NSWindowRestoration } from "./NSWindowRestoration.js";
 export declare class _NSDocumentController extends _NSObject {
     static alloc(): _NSDocumentController;
     static new(): _NSDocumentController;
@@ -38,19 +40,19 @@ export declare class _NSDocumentController extends _NSObject {
     /**
      * The action of the File menu's New item in a document-based application. The default implementation of this method invokes -openUntitledDocumentAndDisplay:error: and, if nil is returned, presents the error in an application-modal panel.
      */
-    newDocument$(sender: NobjcObject): void;
+    newDocument$(sender: NobjcObject | null): void;
     /**
      * Create a new untitled document, present its user interface if displayDocument is YES, and return the document if successful. If not successful, return nil after setting *outError to an NSError that encapsulates the reason why a new untitled document could not be created. The default implementation of this method invokes [self defaultType] to determine the type of new document to create, invokes -makeUntitledDocumentOfType:error: to create it, then invokes -addDocument: to record its opening. If displayDocument is YES, it then sends the new document -makeWindowControllers and -showWindows messages. The default implementation of this method uses the file coordination mechanism that was added to the Foundation framework in Mac OS 10.7. It passes the document to +[NSFileCoordinator addFilePresenter:] right after -addDocument: is invoked. (The balancing invocation of +[NSFileCoordinator removeFilePresenter:] is in -[NSDocument close]). For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self openUntitledDocumentOfType:[self defaultType] display:displayDocument] if -openUntitledDocumentOfType:display: is overridden.
      */
-    openUntitledDocumentAndDisplay$error$(displayDocument: boolean, outError: NobjcObject): _NSDocument | null;
+    openUntitledDocumentAndDisplay$error$(displayDocument: boolean, outError: NobjcObject | null): _NSDocument | null;
     /**
      * Instantiate a new untitled document of the specified type and return it if successful. If not successful, return nil after setting *outError to an NSError that encapsulates the reason why a new untitled 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 -initWithType:error: message. For backward binary compatibility with Mac OS 10.3 and earlier, the default implementation of this method instead invokes [self makeUntitledDocumentOfType:typeName] if -makeUntitledDocumentOfType: is overridden.
      */
-    makeUntitledDocumentOfType$error$(typeName: _NSString, outError: NobjcObject): _NSDocument | null;
+    makeUntitledDocumentOfType$error$(typeName: _NSString, outError: NobjcObject | null): _NSDocument | null;
     /**
      * The action of the File menu's Open... item in a document-based application. The default implementation of this method invokes -beginOpenPanelWithCompletionHandler:, unless -fileNamesFromRunningOpenPanel is overridden, in which case that method is invoked instead for backward binary compatibility with Mac OS 10.3 and earlier. If an array other than nil is obtained from that call, it invokes -openDocumentWithContentsOfURL:display:completionHandler: for each URL and, if an error is signaled for any of them, presents the error in an application-modal panel.
      */
-    openDocument$(sender: NobjcObject): void;
+    openDocument$(sender: NobjcObject | null): void;
     /**
      * Present an application-modal open panel to the user and, if the user selects one or more files and indicates that they are to be opened, return an array of those files' URLs. Return nil otherwise. The default implementation of this method invokes -runModalOpenPanel:forTypes: after it has set up an open panel.
      */
@@ -62,7 +64,7 @@ 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): void;
+    beginOpenPanelWithCompletionHandler$(completionHandler: NobjcObject | 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.
      */
@@ -70,35 +72,35 @@ export declare class _NSDocumentController extends _NSObject {
     /**
      * 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): void;
+    openDocumentWithContentsOfURL$display$completionHandler$(url: _NSURL, displayDocument: boolean, completionHandler: NobjcObject | 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.
      */
-    makeDocumentWithContentsOfURL$ofType$error$(url: _NSURL, typeName: _NSString, outError: NobjcObject): _NSDocument | null;
+    makeDocumentWithContentsOfURL$ofType$error$(url: _NSURL, typeName: _NSString, outError: NobjcObject | null): _NSDocument | null;
     /**
      * 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): void;
+    reopenDocumentForURL$withContentsOfURL$display$completionHandler$(urlOrNil: _NSURL | null, contentsURL: _NSURL, displayDocument: boolean, completionHandler: NobjcObject | 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.
      */
-    makeDocumentForURL$withContentsOfURL$ofType$error$(urlOrNil: _NSURL | null, contentsURL: _NSURL, typeName: _NSString, outError: NobjcObject): _NSDocument | null;
+    makeDocumentForURL$withContentsOfURL$ofType$error$(urlOrNil: _NSURL | null, contentsURL: _NSURL, typeName: _NSString, outError: NobjcObject | null): _NSDocument | null;
     /**
      * The action of the File menu's Save All item in a document-based application. The default implementation of this method sends each modified document a -saveDocumentWithDelegate:didSaveSelector:contextInfo: message.
      */
-    saveAllDocuments$(sender: NobjcObject): void;
+    saveAllDocuments$(sender: NobjcObject | null): void;
     /**
      * If there is more than one modified document, present an application-modal alert panel telling the user that there are unsaved documents and giving the option of canceling, not saving the documents, or saving the documents. If the user indicates that saving should be done, or if there was only one modified document in the first place, invoke -closeAllDocumentsWithDelegate:didCloseAllSelector:didReviewAll:contextInfo: to attempt to close all modified documents, doing whatever saving is necessary to not lose data. Finally, send the message selected by didReviewAllSelector to the delegate, with the contextInfo as the last argument. The default implementation of this method ignores the passed-in title string (which is passed in only as the result of a historical quirk). The method selected by didReviewAllSelector must have the same signature as: - (void)documentController:(NSDocumentController *)documentController didReviewAll:(BOOL)didReviewAll contextInfo:(void *)contextInfo;
      */
-    reviewUnsavedDocumentsWithAlertTitle$cancellable$delegate$didReviewAllSelector$contextInfo$(title: _NSString | null, cancellable: boolean, delegate: NobjcObject, didReviewAllSelector: string | null, contextInfo: Uint8Array | null): void;
+    reviewUnsavedDocumentsWithAlertTitle$cancellable$delegate$didReviewAllSelector$contextInfo$(title: _NSString | null, cancellable: boolean, delegate: NobjcObject | null, didReviewAllSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * For each open, modified, document present a document-modal alert panel asking whether the document should be saved and giving the option of canceling, not saving the document, or saving the document. Stop presenting alert panels if the user indicates cancellation in any one of them. The default implementation of this merely sends each open document -canCloseDocumentWithDelegate:shouldCloseSelector:contextInfo: and -close messages until one of them cannot be closed. The method selected by didCloseAllSelector must have the same signature as: - (void)documentController:(NSDocumentController *)documentController didCloseAll:(BOOL)didCloseAll contextInfo:(void *)contextInfo;
      */
-    closeAllDocumentsWithDelegate$didCloseAllSelector$contextInfo$(delegate: NobjcObject, didCloseAllSelector: string | null, contextInfo: Uint8Array | null): void;
+    closeAllDocumentsWithDelegate$didCloseAllSelector$contextInfo$(delegate: NobjcObject | null, didCloseAllSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * Create a new document that will not yet have a location by reading the contents for the document from another URL, present its user interface, and return the document if successful. If not successful, return nil after setting *outError to an NSError that encapsulates the reason why a new document could not be created. If duplicateByCopying is YES then first copy the contents located at the passed-in URL into a file located in the same directory that is used for the autosaved contents of untitled documents and with the same sort of name. if displayNameOrNil is not nil then use that value to derive a display name for the new document that does not match one that is already in use by an open document. The default implementation of this method copies the file if specified, determines the type of the document, invokes -makeDocumentForURL:withContentsOfURL:ofType:error: to instantiate it, sends the document -setDisplayName: to name it if displayNameOrNil is not nil, invokes -addDocument: to record its opening, and sends the document -makeWindowControllers and -showWindows messages. The default implementation of this method uses the file coordination mechanism that was added to the Foundation framework in Mac OS 10.7. 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 duplicated. It is invoked by -[NSDocument duplicateAndReturnError:]. It may however also be invoked from other places in AppKit. We don't anticipate any uses for your application to invoke this method directly, but you may discover one.
      */
-    duplicateDocumentWithContentsOfURL$copying$displayName$error$(url: _NSURL, duplicateByCopying: boolean, displayNameOrNil: _NSString | null, outError: NobjcObject): _NSDocument | null;
+    duplicateDocumentWithContentsOfURL$copying$displayName$error$(url: _NSURL, duplicateByCopying: boolean, displayNameOrNil: _NSString | null, outError: NobjcObject | null): _NSDocument | null;
     /**
      * A menu item that can be used for sharing the current document. You would typically only use this if you make your NSDocument subclass return NO for allowsAutomaticShareMenu to do custom placement of the Share menu.
      */
@@ -106,11 +108,11 @@ export declare class _NSDocumentController extends _NSObject {
     /**
      * Methods that are declared by NSResponder and also implemented by NSDocumentController, even though for historical reasons NSDocumentController is not a subclass of NSResponder. NSDocumentController's default implementations are equivalent to NSResponder's while treating the application object as the "next responder" and forwarding error presentation messages to it. NSDocument has overrides of -presentError:modalForWindow:delegate:didPresentSelector:contextInfo: and -presentError: that treat the shared document controller as the "next responder" and forward these messages it. The default implementations of several NSDocumentController methods invoke -presentError:. You can customize the presentation of errors for all kinds of documents 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;
     /** The action of the Open Recent menu's Clear Menu item. */
-    clearRecentDocuments$(sender: NobjcObject): void;
+    clearRecentDocuments$(sender: NobjcObject | null): void;
     /**
      * Add an item corresponding to a document to the Open Recent menu, or replace an existing item for the same document.
      */
@@ -122,11 +124,11 @@ export declare class _NSDocumentController extends _NSObject {
     /**
      * Given a URL, return the name of the document type that should be used when opening the document at that location, if successful. If not successful, return nil after setting *outError to an NSError that encapsulates the reason why the document's type could not be determined, or the fact that the document's type is just unrecognized. The default implementation of this method merely returns the URL's NSURLTypeIdentifierKey resource value. You can override this to customize type determination for documents being opened. For backward binary compatibility with Mac OS 10.4 and earlier, the default implementation of this method actually first does the same thing that it did in Mac OS 10.4 (invoke -typeFromFileExtension:, possibly twice, passing an HFS file type string for the second invocation) if there are any CFBundleDocumentTypes Info.plist entries that don't have LSItemContentTypes subentries, and only gets the URL's NSURLTypeIdentifierKey resource value if that does not succeed.
      */
-    typeForContentsOfURL$error$(url: _NSURL, outError: NobjcObject): _NSString | null;
+    typeForContentsOfURL$error$(url: _NSURL, outError: NobjcObject | null): _NSString | null;
     /**
      * Given a document type name, return the subclass of NSDocument that should be instantiated when opening a document of that type, or nil for failure.
      */
-    documentClassForType$(typeName: _NSString): NobjcObject;
+    documentClassForType$(typeName: _NSString): NobjcObject | null;
     /**
      * Given a document type name, return a string describing the document type that is fit to present to the user, or nil for failure.
      */
@@ -139,11 +141,11 @@ export declare class _NSDocumentController extends _NSObject {
      * Methods that were deprecated in Mac OS 10.7. See the comments above for information about when your overrides of them are still invoked, for backward binary compatibility.
      * @deprecated Use -openDocumentWithContentsOfURL:display:completionHandler: instead
      */
-    openDocumentWithContentsOfURL$display$error$(url: _NSURL, displayDocument: boolean, outError: NobjcObject): NobjcObject;
+    openDocumentWithContentsOfURL$display$error$(url: _NSURL, displayDocument: boolean, outError: NobjcObject | null): NobjcObject | null;
     /**
      * @deprecated Use -reopenDocumentForURL:withContentsOfURL:display:completionHandler: instead
      */
-    reopenDocumentForURL$withContentsOfURL$error$(url: _NSURL | null, contentsURL: _NSURL, outError: NobjcObject): boolean;
+    reopenDocumentForURL$withContentsOfURL$error$(url: _NSURL | null, contentsURL: _NSURL, outError: NobjcObject | null): boolean;
     /**
      * Methods that were deprecated in Mac OS 10.5, and don't work well in applications whose document types are declared with UTIs. In general, if each of the application's CFBundleDocumentTypes Info.plist entries has a valid LSItemContentTypes subentry, and the application doesn't invoke deprecated methods like -fileNamesFromRunningOpenPanel, then these methods will never be invoked from within Cocoa.
      * @deprecated
@@ -155,21 +157,21 @@ export declare class _NSDocumentController extends _NSObject {
      * 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
      */
-    documentForFileName$(fileName: _NSString): NobjcObject;
+    documentForFileName$(fileName: _NSString): NobjcObject | null;
     /** @deprecated */
     fileNamesFromRunningOpenPanel(): _NSArray | null;
     /** @deprecated */
-    makeDocumentWithContentsOfFile$ofType$(fileName: _NSString, type: _NSString): NobjcObject;
+    makeDocumentWithContentsOfFile$ofType$(fileName: _NSString, type: _NSString): NobjcObject | null;
     /** @deprecated */
-    makeDocumentWithContentsOfURL$ofType$(url: _NSURL, type: _NSString): NobjcObject;
+    makeDocumentWithContentsOfURL$ofType$(url: _NSURL, type: _NSString): NobjcObject | null;
     /** @deprecated */
-    makeUntitledDocumentOfType$(type: _NSString): NobjcObject;
+    makeUntitledDocumentOfType$(type: _NSString): NobjcObject | null;
     /** @deprecated */
-    openDocumentWithContentsOfFile$display$(fileName: _NSString, display: boolean): NobjcObject;
+    openDocumentWithContentsOfFile$display$(fileName: _NSString, display: boolean): NobjcObject | null;
     /** @deprecated */
-    openDocumentWithContentsOfURL$display$(url: _NSURL, display: boolean): NobjcObject;
+    openDocumentWithContentsOfURL$display$(url: _NSURL, display: boolean): NobjcObject | null;
     /** @deprecated */
-    openUntitledDocumentOfType$display$(type: _NSString, display: boolean): NobjcObject;
+    openUntitledDocumentOfType$display$(type: _NSString, display: boolean): NobjcObject | null;
     /** @deprecated */
     setShouldCreateUI$(flag: boolean): void;
     /** @deprecated */
@@ -214,3 +216,5 @@ export declare class _NSDocumentController extends _NSObject {
      */
     documentClassNames(): _NSArray;
 }
+export interface _NSDocumentController extends _NSMenuItemValidation, _NSWindowRestoration {
+}

package/dist/AppKit/NSDraggingImageComponent.d.ts

@@ -17,8 +17,8 @@ export declare class _NSDraggingImageComponent extends _NSObject {
     /**
      * An object providing the image contents of the component, typically you set an NSImage, but may be anything CALayer accepts.
      */
-    contents(): NobjcObject;
-    setContents$(value: NobjcObject): void;
+    contents(): NobjcObject | null;
+    setContents$(value: NobjcObject | null): void;
     /**
      * The coordinate space is the bounds of the parent NSDraggingItem. That is, {{0,0}, {draggingFrame.size.width, draggingFrame.size.height}} Note: NSDraggingItem does not clip its components.
      */

package/dist/AppKit/NSDraggingItem.d.ts

@@ -14,7 +14,7 @@ export declare class _NSDraggingItem extends _NSObject {
     /**
      * Alternate single image component setter. This method simplifies modifiying the components of an NSDraggingItem when there is only one component. This method will set the draggingFrame and imageComponentsProvider properties. frame is in the same coordinate space that the draggingFrame property is. To hide this item, set contents to nil.
      */
-    setDraggingFrame$contents$(frame: CGRect, contents: NobjcObject): void;
+    setDraggingFrame$contents$(frame: CGRect, contents: NobjcObject | null): void;
     /**
      * When you create an NSDraggingItem, item is the pasteboardWriter passed to initWithPasteboardWriter. However, when enumerating dragging items in an NSDraggingSession or NSDraggingInfo object, item is not the original pasteboardWriter. It is an instance of one of the classes provided to the enumeration method.
      */
@@ -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;
-    setImageComponentsProvider$(value: NobjcObject): void;
+    imageComponentsProvider(): NobjcObject | null;
+    setImageComponentsProvider$(value: NobjcObject | 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/NSDrawer.d.ts

@@ -1,4 +1,5 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSAccessibility } from "./NSAccessibility.js";
 import type { _NSDrawerDelegate } from "./NSDrawerDelegate.js";
 import type { _NSResponder } from "./NSResponder.js";
 import type { _NSView } from "./NSView.js";
@@ -13,9 +14,9 @@ export declare class _NSDrawer extends _NSResponder {
     open(): void;
     openOnEdge$(edge: NSRectEdge): void;
     close(): void;
-    open$(sender: NobjcObject): void;
-    close$(sender: NobjcObject): void;
-    toggle$(sender: NobjcObject): void;
+    open$(sender: NobjcObject | null): void;
+    close$(sender: NobjcObject | null): void;
+    toggle$(sender: NobjcObject | null): void;
     parentWindow(): _NSWindow | null;
     setParentWindow$(value: _NSWindow | null): void;
     contentView(): _NSView | null;
@@ -37,3 +38,5 @@ export declare class _NSDrawer extends _NSResponder {
     trailingOffset(): number;
     setTrailingOffset$(value: number): void;
 }
+export interface _NSDrawer extends _NSAccessibility {
+}

package/dist/AppKit/NSEditor.d.ts

@@ -9,9 +9,9 @@ export interface _NSEditor {
     /**
      * Given that the receiver has been registered with -objectDidBeginEditing: as the editor of some object, and not yet deregistered by a subsequent invocation of -objectDidEndEditing:, attempt to commit the result of the editing. When committing has either succeeded or failed, send the selected message to the specified object with the context info as the last parameter. The method selected by didCommitSelector must have the same signature as: - (void)editor:(id)editor didCommit:(BOOL)didCommit contextInfo:(void *)contextInfo; If an error occurs while attempting to commit, because key-value coding validation fails for example, an implementation of this method should typically send the NSView in which editing is being done a -presentError:modalForWindow:delegate:didRecoverSelector:contextInfo: message, specifying the view's containing window.
      */
-    commitEditingWithDelegate$didCommitSelector$contextInfo$?(delegate: NobjcObject, didCommitSelector: string | null, contextInfo: Uint8Array | null): void;
+    commitEditingWithDelegate$didCommitSelector$contextInfo$?(delegate: NobjcObject | null, didCommitSelector: string | null, contextInfo: Uint8Array | null): void;
     /**
      * During autosaving, commit editing may fail, due to a pending edit. Rather than interrupt the user with an unexpected alert, this method provides the caller with the option to either present the error or fail silently, leaving the pending edit in place and the user's editing uninterrupted. This method attempts to commit editing, but if there is a failure the error is returned to the caller to be presented or ignored as appropriate. If an error occurs while attempting to commit, an implementation of this method should return NO as well as the generated error by reference. Returns YES if commit is successful. If you have enabled autosaving in your application, and your application has custom objects that implement or override the NSEditor protocol, you must also implement this method in those NSEditors.
      */
-    commitEditingAndReturnError$?(error: NobjcObject): boolean;
+    commitEditingAndReturnError$?(error: NobjcObject | null): boolean;
 }

package/dist/AppKit/NSEvent.d.ts

@@ -1,5 +1,7 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSCoding } from "../Foundation/NSCoding.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -41,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: number, block: NobjcObject): NobjcObject;
-    static addLocalMonitorForEventsMatchingMask$handler$(mask: number, block: NobjcObject): NobjcObject;
+    static addGlobalMonitorForEventsMatchingMask$handler$(mask: NobjcObject, block: NobjcObject): NobjcObject | null;
+    static addLocalMonitorForEventsMatchingMask$handler$(mask: NobjcObject, block: NobjcObject | 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.
@@ -247,7 +249,9 @@ export declare class _NSEvent extends _NSObject {
     /**
      * This message is valid for Mouse events. The event mask describing the various events that you may also get during this event sequence. Useful for determining if the input device issuing this mouse event can also simultaneously issue NSEventTypePressure events.
      */
-    associatedEventsMask(): number;
+    associatedEventsMask(): NobjcObject;
     /** this message is valid for NSEventTypePressure events */
     pressureBehavior(): NSPressureBehavior;
 }
+export interface _NSEvent extends _NSCopying, _NSCoding {
+}

package/dist/AppKit/NSFilePromiseProvider.d.ts

@@ -2,6 +2,7 @@ import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSFilePromiseProviderDelegate } from "./NSFilePromiseProviderDelegate.js";
+import type { _NSPasteboardWriting } from "./NSPasteboardWriting.js";
 export declare class _NSFilePromiseProvider extends _NSObject {
     static alloc(): _NSFilePromiseProvider;
     static new(): _NSFilePromiseProvider;
@@ -21,6 +22,8 @@ export declare class _NSFilePromiseProvider extends _NSObject {
     /**
      * When a simple string identifier is not enough. Store a pointer to an object that contains the source of the promised file data.
      */
-    userInfo(): NobjcObject;
-    setUserInfo$(value: NobjcObject): void;
+    userInfo(): NobjcObject | null;
+    setUserInfo$(value: NobjcObject | null): void;
+}
+export interface _NSFilePromiseProvider extends _NSPasteboardWriting {
 }

package/dist/AppKit/NSFilePromiseProviderDelegate.d.ts

@@ -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): void;
+    filePromiseProvider$writePromiseToURL$completionHandler$?(filePromiseProvider: _NSFilePromiseProvider, url: _NSURL, completionHandler: NobjcObject | 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

@@ -4,6 +4,7 @@ import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSOperationQueue } from "../Foundation/NSOperationQueue.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
+import type { _NSPasteboardReading } from "./NSPasteboardReading.js";
 export declare class _NSFilePromiseReceiver extends _NSObject {
     static alloc(): _NSFilePromiseReceiver;
     static new(): _NSFilePromiseReceiver;
@@ -15,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): void;
+    receivePromisedFilesAtDestination$options$operationQueue$reader$(destinationDir: _NSURL, options: _NSDictionary, operationQueue: _NSOperationQueue, reader: NobjcObject | 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.
      */
@@ -25,3 +26,5 @@ export declare class _NSFilePromiseReceiver extends _NSObject {
      */
     fileNames(): _NSArray;
 }
+export interface _NSFilePromiseReceiver extends _NSPasteboardReading {
+}

package/dist/AppKit/NSFont.d.ts

@@ -1,8 +1,10 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSAffineTransform } from "../Foundation/NSAffineTransform.js";
 import type { _NSCharacterSet } from "../Foundation/NSCharacterSet.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSFontDescriptor } from "./NSFontDescriptor.js";
 import type { _NSGraphicsContext } from "./NSGraphicsContext.js";
@@ -131,3 +133,5 @@ export declare class _NSFont extends _NSObject {
     screenFont(): _NSFont;
     renderingMode(): NSFontRenderingMode;
 }
+export interface _NSFont extends _NSCopying, _NSSecureCoding {
+}

package/dist/AppKit/NSFontAssetRequest.d.ts

@@ -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): void;
+    downloadFontAssetsWithCompletionHandler$(completionHandler: NobjcObject | null): void;
     /** The downloaded font descriptors up to this point. */
     downloadedFontDescriptors(): _NSArray;
     /**

package/dist/AppKit/NSFontCollection.d.ts

@@ -1,7 +1,10 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSCoding } from "../Foundation/NSCoding.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSLocale } from "../Foundation/NSLocale.js";
+import type { _NSMutableCopying } from "../Foundation/NSMutableCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { NSFontCollectionName } from "./NSFontCollectionName.js";
@@ -15,13 +18,13 @@ export declare class _NSFontCollection extends _NSObject {
     /** Return a collection with fonts for the specified locale. */
     static fontCollectionWithLocale$(locale: _NSLocale): _NSFontCollection | null;
     /** Make the font collection visible by giving it a name */
-    static showFontCollection$withName$visibility$error$(collection: _NSFontCollection, name: NSFontCollectionName, visibility: NSFontCollectionVisibility, error: NobjcObject): boolean;
+    static showFontCollection$withName$visibility$error$(collection: _NSFontCollection, name: NSFontCollectionName, visibility: NSFontCollectionVisibility, error: NobjcObject | null): boolean;
     /**
      * Remove font collection from view (for a persistent collection, deletes the named font collection from disk)
      */
-    static hideFontCollectionWithName$visibility$error$(name: NSFontCollectionName, visibility: NSFontCollectionVisibility, error: NobjcObject): boolean;
+    static hideFontCollectionWithName$visibility$error$(name: NSFontCollectionName, visibility: NSFontCollectionVisibility, error: NobjcObject | null): boolean;
     /** Rename named collection */
-    static renameFontCollectionWithName$visibility$toName$error$(oldName: NSFontCollectionName, visibility: NSFontCollectionVisibility, newName: NSFontCollectionName, outError: NobjcObject): boolean;
+    static renameFontCollectionWithName$visibility$toName$error$(oldName: NSFontCollectionName, visibility: NSFontCollectionVisibility, newName: NSFontCollectionName, outError: NobjcObject | null): boolean;
     /** Return the specified named collection */
     static fontCollectionWithName$(name: NSFontCollectionName): _NSFontCollection | null;
     /** Return the specified named collection with specified visibility */
@@ -47,3 +50,5 @@ export declare class _NSFontCollection extends _NSObject {
      */
     matchingDescriptors(): _NSArray | null;
 }
+export interface _NSFontCollection extends _NSCopying, _NSMutableCopying, _NSCoding {
+}

package/dist/AppKit/NSFontDescriptor.d.ts

@@ -1,8 +1,10 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSAffineTransform } from "../Foundation/NSAffineTransform.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { NSFontDescriptorAttributeName } from "./NSFontDescriptorAttributeName.js";
@@ -19,7 +21,7 @@ export declare class _NSFontDescriptor extends _NSObject {
     static fontDescriptorWithName$matrix$(fontName: _NSString, matrix: _NSAffineTransform): _NSFontDescriptor;
     /** Returns a font descriptor containing the text style. */
     static preferredFontDescriptorForTextStyle$options$(style: NSFontTextStyle, options: _NSDictionary): _NSFontDescriptor;
-    objectForKey$(attribute: NSFontDescriptorAttributeName): NobjcObject;
+    objectForKey$(attribute: NSFontDescriptorAttributeName): NobjcObject | null;
     initWithFontAttributes$(attributes: _NSDictionary | null): _NSFontDescriptor;
     /**
      * Returns "normalized" font descriptors matching the receiver. mandatoryKeys is an NSSet instance containing keys that are required to be identical in order to be matched. mandatoryKeys can be nil.
@@ -48,3 +50,5 @@ export declare class _NSFontDescriptor extends _NSObject {
     requiresFontAssetRequest(): boolean;
     fontAttributes(): _NSDictionary;
 }
+export interface _NSFontDescriptor extends _NSCopying, _NSSecureCoding {
+}

package/dist/AppKit/NSFontManager.d.ts

@@ -7,6 +7,7 @@ import type { _NSFont } from "./NSFont.js";
 import type { _NSFontDescriptor } from "./NSFontDescriptor.js";
 import type { _NSFontPanel } from "./NSFontPanel.js";
 import type { _NSMenu } from "./NSMenu.js";
+import type { _NSMenuItemValidation } from "./NSMenuItemValidation.js";
 import type { NSFontAction } from "./NSFontAction.js";
 import type { NSFontCollectionOptions } from "./NSFontCollectionOptions.js";
 import type { NSFontTraitMask } from "./NSFontTraitMask.js";
@@ -14,8 +15,8 @@ export declare class _NSFontManager extends _NSObject {
     static alloc(): _NSFontManager;
     static new(): _NSFontManager;
     init(): _NSFontManager;
-    static setFontPanelFactory$(factoryId: NobjcObject): void;
-    static setFontManagerFactory$(factoryId: NobjcObject): void;
+    static setFontPanelFactory$(factoryId: NobjcObject | null): void;
+    static setFontManagerFactory$(factoryId: NobjcObject | null): void;
     static sharedFontManager(): _NSFontManager;
     setSelectedFont$isMultiple$(fontObj: _NSFont, flag: boolean): void;
     setFontMenu$(newMenu: _NSMenu): void;
@@ -82,12 +83,12 @@ export declare class _NSFontManager extends _NSObject {
      */
     availableFontNamesWithTraits$(someTraits: NSFontTraitMask): _NSArray | null;
     /** These methods are action messages sent from Font Menu items: */
-    addFontTrait$(sender: NobjcObject): void;
-    removeFontTrait$(sender: NobjcObject): void;
-    modifyFontViaPanel$(sender: NobjcObject): void;
-    modifyFont$(sender: NobjcObject): void;
-    orderFrontFontPanel$(sender: NobjcObject): void;
-    orderFrontStylesPanel$(sender: NobjcObject): void;
+    addFontTrait$(sender: NobjcObject | null): void;
+    removeFontTrait$(sender: NobjcObject | null): void;
+    modifyFontViaPanel$(sender: NobjcObject | null): void;
+    modifyFont$(sender: NobjcObject | null): void;
+    orderFrontFontPanel$(sender: NobjcObject | null): void;
+    orderFrontStylesPanel$(sender: NobjcObject | null): void;
     multiple(): boolean;
     selectedFont(): _NSFont | null;
     /**
@@ -119,3 +120,5 @@ export declare class _NSFontManager extends _NSObject {
     target(): NobjcObject;
     setTarget$(value: NobjcObject): void;
 }
+export interface _NSFontManager extends _NSMenuItemValidation {
+}

package/dist/AppKit/NSGestureRecognizer.d.ts

@@ -17,7 +17,7 @@ export declare class _NSGestureRecognizer extends _NSObject {
     /**
      * valid action method signatures: -(void)handleGesture; -(void)handleGesture:(NSGestureRecognizer*)gestureRecognizer;
      */
-    initWithTarget$action$(target: NobjcObject, action: string | null): _NSGestureRecognizer;
+    initWithTarget$action$(target: NobjcObject | null, action: string | null): _NSGestureRecognizer;
     initWithCoder$(coder: _NSCoder): _NSGestureRecognizer | null;
     /**
      * individual NSGestureRecognizer subclasses may provide subclass-specific location information. see individual subclasses for details
@@ -61,8 +61,8 @@ export declare class _NSGestureRecognizer extends _NSObject {
     touchesMovedWithEvent$(event: _NSEvent): void;
     touchesEndedWithEvent$(event: _NSEvent): void;
     touchesCancelledWithEvent$(event: _NSEvent): void;
-    target(): NobjcObject;
-    setTarget$(value: NobjcObject): void;
+    target(): NobjcObject | null;
+    setTarget$(value: NobjcObject | null): void;
     action(): string | null;
     setAction$(value: string | null): void;
     /** the current state of the gesture recognizer */

package/dist/AppKit/NSGlyphGenerator.d.ts

@@ -6,5 +6,5 @@ export declare class _NSGlyphGenerator extends _NSObject {
     static new(): _NSGlyphGenerator;
     init(): _NSGlyphGenerator;
     static sharedGlyphGenerator(): _NSGlyphGenerator;
-    generateGlyphsForGlyphStorage$desiredNumberOfCharacters$glyphIndex$characterIndex$(glyphStorage: _NSGlyphStorage, nChars: number, glyphIndex: NobjcObject, charIndex: NobjcObject): void;
+    generateGlyphsForGlyphStorage$desiredNumberOfCharacters$glyphIndex$characterIndex$(glyphStorage: _NSGlyphStorage, nChars: number, glyphIndex: NobjcObject | null, charIndex: NobjcObject | null): void;
 }

package/dist/AppKit/NSGlyphInfo.d.ts

@@ -1,4 +1,6 @@
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSFont } from "./NSFont.js";
 import type { NSCharacterCollection } from "./NSCharacterCollection.js";
@@ -16,3 +18,5 @@ export declare class _NSGlyphInfo extends _NSObject {
     characterIdentifier(): number;
     characterCollection(): NSCharacterCollection;
 }
+export interface _NSGlyphInfo extends _NSCopying, _NSSecureCoding {
+}

package/dist/AppKit/NSGradient.d.ts

@@ -1,6 +1,7 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSCoder } from "../Foundation/NSCoder.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSBezierPath } from "./NSBezierPath.js";
 import type { _NSColor } from "./NSColor.js";
@@ -27,7 +28,7 @@ export declare class _NSGradient extends _NSObject {
     /**
      * Initializes a gradient by pairing the colors provided in the color array with the locations provided in the locations array. Each location should be a CGFloat between 0.0 and 1.0. The color array and location array should not be empty, and should contain the same number of items. If no color is provided for 0.0 or 1.0, the created color gradient will use the color provided at the locations closest to 0.0 and 1.0 for those values. This is the designated initializer.
      */
-    initWithColors$atLocations$colorSpace$(colorArray: _NSArray, locations: NobjcObject, colorSpace: _NSColorSpace): _NSGradient | null;
+    initWithColors$atLocations$colorSpace$(colorArray: _NSArray, locations: NobjcObject | null, colorSpace: _NSColorSpace): _NSGradient | null;
     initWithCoder$(coder: _NSCoder): _NSGradient | null;
     /**
      * Draws a linear gradient from start point to end point. The option flags control whether the gradient draws itself before the start point, or after the end point. The gradient is drawn in the current graphics context without performing any additinal clipping. This is the primitive method for drawing a linear gradient.
@@ -54,7 +55,7 @@ export declare class _NSGradient extends _NSObject {
      */
     drawInBezierPath$relativeCenterPosition$(path: _NSBezierPath, relativeCenterPosition: CGPoint): void;
     /** Returns the color and location at a particular index in the color gradient */
-    getColor$location$atIndex$(color: NobjcObject, location: NobjcObject, index: number): void;
+    getColor$location$atIndex$(color: NobjcObject | null, location: NobjcObject | null, index: number): void;
     /**
      * This method will return the interpolated gradient value at the given location. For example, in a two color gradient with white at location 0.0 and black at location 1.0, the interpolated color at location 0.5 would be 50% gray. You should not need to override this method, it reports the color value of the gradient at a particular location, and does not affect the drawn color values.
      */
@@ -64,3 +65,5 @@ export declare class _NSGradient extends _NSObject {
     /** The number of color stops in the color gradient */
     numberOfColorStops(): number;
 }
+export interface _NSGradient extends _NSCopying {
+}

package/dist/AppKit/NSGridCell.d.ts

@@ -1,4 +1,5 @@
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSCoding } from "../Foundation/NSCoding.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSGridColumn } from "./NSGridColumn.js";
 import type { _NSGridRow } from "./NSGridRow.js";
@@ -33,3 +34,5 @@ export declare class _NSGridCell extends _NSObject {
     customPlacementConstraints(): _NSArray;
     setCustomPlacementConstraints$(value: _NSArray): void;
 }
+export interface _NSGridCell extends _NSCoding {
+}

package/dist/AppKit/NSGridColumn.d.ts

@@ -1,3 +1,4 @@
+import type { _NSCoding } from "../Foundation/NSCoding.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSGridCell } from "./NSGridCell.js";
 import type { _NSGridView } from "./NSGridView.js";
@@ -32,3 +33,5 @@ export declare class _NSGridColumn extends _NSObject {
     hidden(): boolean;
     setHidden$(value: boolean): void;
 }
+export interface _NSGridColumn extends _NSCoding {
+}

package/dist/AppKit/NSGridRow.d.ts

@@ -1,3 +1,4 @@
+import type { _NSCoding } from "../Foundation/NSCoding.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSGridCell } from "./NSGridCell.js";
 import type { _NSGridView } from "./NSGridView.js";
@@ -35,3 +36,5 @@ export declare class _NSGridRow extends _NSObject {
     hidden(): boolean;
     setHidden$(value: boolean): void;
 }
+export interface _NSGridRow extends _NSCoding {
+}

package/dist/AppKit/NSGridView.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSGridCell } from "./NSGridCell.js";
 import type { _NSGridColumn } from "./NSGridColumn.js";
 import type { _NSGridRow } from "./NSGridRow.js";
@@ -18,7 +17,7 @@ export declare class _NSGridView extends _NSView {
     /**
      * Convenience initializer for an autoreleased GridView large enough to hold the provided rows. Each element in 'rows' is an array of views for that row.
      */
-    static gridViewWithViews$(rows: NobjcObject): _NSGridView;
+    static gridViewWithViews$(rows: _NSArray): _NSGridView;
     initWithFrame$(frameRect: CGRect): _NSGridView;
     initWithCoder$(coder: _NSCoder): _NSGridView | null;
     /**