objcjs-types 0.1.0 → 0.2.0

package/dist/AppKit/NSImage.d.ts

@@ -4,6 +4,8 @@ import type { _NSBundle } from "../Foundation/NSBundle.js";
 import type { _NSCoder } from "../Foundation/NSCoder.js";
 import type { _NSData } from "../Foundation/NSData.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSItemProviderReading } from "../Foundation/NSItemProviderReading.js";
+import type { _NSItemProviderWriting } from "../Foundation/NSItemProviderWriting.js";
 import type { _NSLocale } from "../Foundation/NSLocale.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -14,6 +16,8 @@ import type { _NSImageDelegate } from "./NSImageDelegate.js";
 import type { _NSImageRep } from "./NSImageRep.js";
 import type { _NSImageSymbolConfiguration } from "./NSImageSymbolConfiguration.js";
 import type { _NSPasteboard } from "./NSPasteboard.js";
+import type { _NSPasteboardReading } from "./NSPasteboardReading.js";
+import type { _NSPasteboardWriting } from "./NSPasteboardWriting.js";
 import type { CGPoint } from "../structs/CGPoint.js";
 import type { CGRect } from "../structs/CGRect.js";
 import type { CGSize } from "../structs/CGSize.js";
@@ -104,7 +108,7 @@ export declare class _NSImage extends _NSObject {
     /**
      * Returns a CGImage capturing the drawing of the receiver. This method returns an existing CGImage if one is available, or creates one if not. It behaves the same as drawing the image with respect to caching and related behaviors. This method is typically called, not overridden. An NSImage is potentially resolution independent, and may have representations that allow it to draw well in many contexts. A CGImage is more like a single pixel-based representation. This method produces a snapshot of how the NSImage would draw if it was asked to draw in *proposedDestRect in the passed context. Producing this snapshot may be more expensive than just drawing the NSImage, so prefer to use -[NSImage drawInRect:fromRect:operation:fraction:] unless you require a CGImage. The return value in *proposedDestRect tells the client where to draw the CGImage. This rect may be outset from the requested rect, because a CGImage must have pixel-integral dimensions while an NSImage need not. All input parameters are optional. They provide hints for how to choose among existing CGImages, or how to create one if there isn't already a CGImage available. The parameters are _only_ hints. Any CGImage is a valid return. If proposedDestRect is NULL, it defaults to the smallest pixel-integral rectangle containing {{0,0}, [self size]}. The proposedDestRect is in user space in the reference context. If referenceContext is nil, the method behaves as if a window context scaled by the default user space scaling factor was passed, though no context is actually created. The properties of the context are used as hints for choosing the best representation and for creating a CGImage if creation is necessary. It also provides the coordinate space in which the proposedDestRect is interpreted. Only the snapshotted state of the context at the moment its passed to this method is relevant. Future changes to the context have no bearing on image behavior. The hints provide more context for selecting or generating a CGImage, and may override properties of the referenceContext. Hints may be nil. Any entries in a device description dictionary (see NSScreen) are valid, as are all CIContext creation options, plus a few extra hints defined below. Unrecognized hints are ignored, but passed down to image reps (see -[NSImageRep CGImageForProposedRect:context:hints:]). Explicit hints are particularly useful when it is not draw time and you don't have a context to pass in. For example, if you want to pass a rect in pixels for proposedDestRect, you should pass a dictionary with the identity transform for NSImageHintCTM. This method will always return a valid CGImage provided the NSImage is able to draw. If the receiver is unable to draw for whatever reason, the error behavior is the same as when drawing the image. The CGImageRef returned is guaranteed to live as long as the current autorelease pool. The caller should not release the CGImage. This is the standard Cocoa convention, but people may not realize that it applies to CFTypes.
      */
-    CGImageForProposedRect$context$hints$(proposedDestRect: NobjcObject, referenceContext: _NSGraphicsContext | null, hints: _NSDictionary | null): NobjcObject;
+    CGImageForProposedRect$context$hints$(proposedDestRect: NobjcObject | null, referenceContext: _NSGraphicsContext | null, hints: _NSDictionary | null): NobjcObject;
     /**
      * Select best representation. The parameters have the same meaning and behavior as in -CGImageForProposedRect:context:hints:.
      */
@@ -244,3 +248,5 @@ export declare class _NSImage extends _NSObject {
      */
     locale(): _NSLocale;
 }
+export interface _NSImage extends _NSPasteboardReading, _NSPasteboardWriting, _NSItemProviderReading, _NSItemProviderWriting {
+}

package/dist/AppKit/NSImageRep.d.ts

@@ -25,11 +25,11 @@ export declare class _NSImageRep extends _NSObject {
     /** @deprecated Use +imageRepClassForType: instead */
     static unregisterImageRepClass$(imageRepClass: NobjcObject): void;
     /** @deprecated Use +imageRepClassForType: instead */
-    static imageRepClassForFileType$(type: _NSString): NobjcObject;
+    static imageRepClassForFileType$(type: _NSString): NobjcObject | null;
     /** @deprecated Use +imageRepClassForType: instead */
-    static imageRepClassForPasteboardType$(type: _NSString): NobjcObject;
-    static imageRepClassForType$(type: _NSString): NobjcObject;
-    static imageRepClassForData$(data: _NSData): NobjcObject;
+    static imageRepClassForPasteboardType$(type: _NSString): NobjcObject | null;
+    static imageRepClassForType$(type: _NSString): NobjcObject | null;
+    static imageRepClassForData$(data: _NSData): NobjcObject | null;
     /**
      * Should be overridden by subclassers to load an unfiltered image.
      * @deprecated Use +imageUnfilteredTypes instead
@@ -80,7 +80,7 @@ export declare class _NSImageRep extends _NSObject {
     /**
      * The parameters have the same meaning and behavior as in -[NSImage CGImageForProposedRect:context:hints:]. This method is intended to be overridden or called, though the primary caller is NSImage. At the NSImageRep level, it creates a CGImage by drawing the receiver into a new context. The passed context and hints are used as a model for the new context. If [self draw] returns NO, this method returns NULL. If your image rep subclass naturally uses a CGImage that it can return, override this method and return it. You should not need to take care to cache within an implementation of this method. This main caller of this method is typically NSImage, and NSImage will hold onto the resulting CGImage if appropriate. The CGImageRef returned is guaranteed to live as long as the current autorelease pool. The caller should not release the CGImage. This is the standard Cocoa convention, but people may not realize that it applies to CFTypes.
      */
-    CGImageForProposedRect$context$hints$(proposedDestRect: NobjcObject, context: _NSGraphicsContext | null, hints: _NSDictionary | null): NobjcObject;
+    CGImageForProposedRect$context$hints$(proposedDestRect: NobjcObject | null, context: _NSGraphicsContext | null, hints: _NSDictionary | null): NobjcObject;
     /**
      * Methods to return info about the image. NSImageRep provides storage for all of these; however, it's illegal to set them in some subclasses.
      */

package/dist/AppKit/NSImageSymbolConfiguration.d.ts

@@ -1,5 +1,6 @@
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _NSColor } from "./NSColor.js";
 import type { NSFontTextStyle } from "./NSFontTextStyle.js";
 import type { NSImageSymbolColorRenderingMode } from "./NSImageSymbolColorRenderingMode.js";
@@ -43,3 +44,5 @@ export declare class _NSImageSymbolConfiguration extends _NSObject {
      */
     configurationByApplyingConfiguration$(configuration: _NSImageSymbolConfiguration): _NSImageSymbolConfiguration;
 }
+export interface _NSImageSymbolConfiguration extends _NSSecureCoding {
+}

package/dist/AppKit/NSImageView.d.ts

@@ -2,6 +2,7 @@ import type { _NSColor } from "./NSColor.js";
 import type { _NSControl } from "./NSControl.js";
 import type { _NSImage } from "./NSImage.js";
 import type { _NSImageSymbolConfiguration } from "./NSImageSymbolConfiguration.js";
+import type { _NSMenuItemValidation } from "./NSMenuItemValidation.js";
 import type { _NSSymbolContentTransition } from "../Symbols/NSSymbolContentTransition.js";
 import type { _NSSymbolEffect } from "../Symbols/NSSymbolEffect.js";
 import type { _NSSymbolEffectOptions } from "../Symbols/NSSymbolEffectOptions.js";
@@ -94,3 +95,5 @@ export declare class _NSImageView extends _NSControl {
      */
     imageDynamicRange(): NSImageDynamicRange;
 }
+export interface _NSImageView extends _NSMenuItemValidation {
+}

package/dist/AppKit/NSInputManager.d.ts

@@ -4,6 +4,7 @@ import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSEvent } from "./NSEvent.js";
 import type { _NSImage } from "./NSImage.js";
 import type { _NSInputServer } from "./NSInputServer.js";
+import type { _NSTextInput } from "./NSTextInput.js";
 import type { NSRange } from "../structs/NSRange.js";
 export declare class _NSInputManager extends _NSObject {
     static alloc(): _NSInputManager;
@@ -18,9 +19,9 @@ export declare class _NSInputManager extends _NSObject {
      * Cycle through list of input managers. Called from NSKeyBindingManager via doCommandBySelector:.
      * @deprecated
      */
-    static cycleToNextInputLanguage$(sender: NobjcObject): void;
+    static cycleToNextInputLanguage$(sender: NobjcObject | null): void;
     /** @deprecated */
-    static cycleToNextInputServerInLanguage$(sender: NobjcObject): void;
+    static cycleToNextInputServerInLanguage$(sender: NobjcObject | null): void;
     /** @deprecated */
     initWithName$host$(inputServerName: _NSString, hostName: _NSString): _NSInputManager;
     /** @deprecated */
@@ -59,3 +60,5 @@ export declare class _NSInputManager extends _NSObject {
      */
     wantsToDelayTextChangeNotifications(): boolean;
 }
+export interface _NSInputManager extends _NSTextInput {
+}

package/dist/AppKit/NSInputServer.d.ts

@@ -1,6 +1,8 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
+import type { _NSInputServerMouseTracker } from "./NSInputServerMouseTracker.js";
+import type { _NSInputServiceProvider } from "./NSInputServiceProvider.js";
 export declare class _NSInputServer extends _NSObject {
     static alloc(): _NSInputServer;
     static new(): _NSInputServer;
@@ -8,3 +10,5 @@ export declare class _NSInputServer extends _NSObject {
     /** @deprecated */
     initWithDelegate$name$(delegate: NobjcObject, name: _NSString): _NSInputServer;
 }
+export interface _NSInputServer extends _NSInputServiceProvider, _NSInputServerMouseTracker {
+}

package/dist/AppKit/NSInputServiceProvider.d.ts

@@ -6,11 +6,11 @@ export interface _NSInputServiceProvider {
     /** @deprecated */
     doCommandBySelector$client$?(selector: string, sender: NobjcObject): void;
     /** @deprecated */
-    markedTextAbandoned$?(sender: NobjcObject): void;
+    markedTextAbandoned$?(sender: NobjcObject | null): void;
     /** @deprecated */
     markedTextSelectionChanged$client$?(newSel: NSRange, sender: NobjcObject): void;
     /** @deprecated */
-    terminate$?(sender: NobjcObject): void;
+    terminate$?(sender: NobjcObject | null): void;
     /**
      * Normally canBeDisabled returns YES and is implemented that way in the abstract NSInputServer class.
      * @deprecated
@@ -35,16 +35,16 @@ export interface _NSInputServiceProvider {
      * These methods are sent by current input manager when the application changes state so that the server can update its concept of who's current. The actually "active" sender is the last one to have sent a senderDidBecomeActive: message. They may not arrive in the expected order.
      * @deprecated
      */
-    inputClientBecomeActive$?(sender: NobjcObject): void;
+    inputClientBecomeActive$?(sender: NobjcObject | null): void;
     /** @deprecated */
-    inputClientResignActive$?(sender: NobjcObject): void;
+    inputClientResignActive$?(sender: NobjcObject | null): void;
     /**
      * These methods are sent by current input manger when it's enabled & the server returns YES to canBeDisabled. When disabled, the server is expected to send only insertText: or doCommandBySelector:.
      * @deprecated
      */
-    inputClientEnabled$?(sender: NobjcObject): void;
+    inputClientEnabled$?(sender: NobjcObject | null): void;
     /** @deprecated */
-    inputClientDisabled$?(sender: NobjcObject): void;
+    inputClientDisabled$?(sender: NobjcObject | null): void;
     /**
      * These methods are sent by input manager when the conversation within a particular sender changes.
      * @deprecated

package/dist/AppKit/NSLayoutAnchor.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSCoding } from "../Foundation/NSCoding.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSLayoutConstraint } from "./NSLayoutConstraint.js";
@@ -25,3 +26,5 @@ export declare class _NSLayoutAnchor extends _NSObject {
     hasAmbiguousLayout(): boolean;
     constraintsAffectingLayout(): _NSArray;
 }
+export interface _NSLayoutAnchor extends _NSCoding {
+}

package/dist/AppKit/NSLayoutConstraint.d.ts

@@ -3,6 +3,7 @@ import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
+import type { _NSAnimatablePropertyContainer } from "./NSAnimatablePropertyContainer.js";
 import type { _NSLayoutAnchor } from "./NSLayoutAnchor.js";
 import type { NSLayoutAttribute } from "./NSLayoutAttribute.js";
 import type { NSLayoutFormatOptions } from "./NSLayoutFormatOptions.js";
@@ -18,7 +19,7 @@ export declare class _NSLayoutConstraint extends _NSObject {
     /**
      * Create constraints explicitly. Constraints are of the form "view1.attr1 = view2.attr2 * multiplier + constant" If your equation does not have a second view and attribute, use nil and NSLayoutAttributeNotAnAttribute. Use of this method is not recommended. Constraints should be created using anchor objects on views and layout guides.
      */
-    static constraintWithItem$attribute$relatedBy$toItem$attribute$multiplier$constant$(view1: NobjcObject, attr1: NSLayoutAttribute, relation: NSLayoutRelation, view2: NobjcObject, attr2: NSLayoutAttribute, multiplier: number, c: number): _NSLayoutConstraint;
+    static constraintWithItem$attribute$relatedBy$toItem$attribute$multiplier$constant$(view1: NobjcObject, attr1: NSLayoutAttribute, relation: NSLayoutRelation, view2: NobjcObject | null, attr2: NSLayoutAttribute, multiplier: number, c: number): _NSLayoutConstraint;
     /**
      * Convenience method that activates each constraint in the contained array, in the same manner as setting active=YES. This is often more efficient than activating each constraint individually.
      */
@@ -37,8 +38,8 @@ export declare class _NSLayoutConstraint extends _NSObject {
     /**
      * accessors firstItem.firstAttribute {==,<=,>=} secondItem.secondAttribute * multiplier + constant Access to these properties is not recommended. Use the `firstAnchor` and `secondAnchor` properties instead.
      */
-    firstItem(): NobjcObject;
-    secondItem(): NobjcObject;
+    firstItem(): NobjcObject | null;
+    secondItem(): NobjcObject | null;
     firstAttribute(): NSLayoutAttribute;
     secondAttribute(): NSLayoutAttribute;
     /** accessors firstAnchor{==,<=,>=} secondAnchor * multiplier + constant */
@@ -62,3 +63,5 @@ export declare class _NSLayoutConstraint extends _NSObject {
     identifier(): _NSString | null;
     setIdentifier$(value: _NSString | null): void;
 }
+export interface _NSLayoutConstraint extends _NSAnimatablePropertyContainer {
+}

package/dist/AppKit/NSLayoutGuide.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 { _NSString } from "../Foundation/NSString.js";
 import type { _NSLayoutDimension } from "./NSLayoutDimension.js";
@@ -42,3 +43,5 @@ export declare class _NSLayoutGuide extends _NSObject {
     /** For debugging purposes: */
     hasAmbiguousLayout(): boolean;
 }
+export interface _NSLayoutGuide extends _NSCoding {
+}

package/dist/AppKit/NSLayoutManager.d.ts

@@ -65,11 +65,11 @@ export declare class _NSLayoutManager extends _NSObject {
     /**
      * This removes all glyphs for the old character range, adjusts the character indices of all the subsequent glyphs by the change in length, and invalidates the new character range. If actualCharRange is non-NULL it will be set to the actual range invalidated after any necessary expansion.
      */
-    invalidateGlyphsForCharacterRange$changeInLength$actualCharacterRange$(charRange: NSRange, delta: number, actualCharRange: NobjcObject): void;
+    invalidateGlyphsForCharacterRange$changeInLength$actualCharacterRange$(charRange: NSRange, delta: number, actualCharRange: NobjcObject | null): void;
     /**
      * This method invalidates the layout information for the given range of characters. If actualCharRange is non-NULL it will be set to the actual range invalidated after any necessary expansion.
      */
-    invalidateLayoutForCharacterRange$actualCharacterRange$(charRange: NSRange, actualCharRange: NobjcObject): void;
+    invalidateLayoutForCharacterRange$actualCharacterRange$(charRange: NSRange, actualCharRange: NobjcObject | null): void;
     /**
      * These methods invalidate display for the glyph or character range given. For the character range variant, unlaid parts of the range are remembered and will be redisplayed at some point later when the layout is available. For the glyph range variant any part of the range that does not yet have glyphs generated is ignored. Neither method actually causes layout.
      */
@@ -95,7 +95,7 @@ export declare class _NSLayoutManager extends _NSObject {
     /**
      * If non-contiguous layout is not enabled, these will cause generation of all glyphs up to and including glyphIndex. The first CGGlyphAtIndex variant returns kCGFontIndexInvalid if the requested index is out of the range (0, numberOfGlyphs), and optionally returns a flag indicating whether the requested index is in range. The second CGGlyphAtIndex variant raises a NSRangeError if the requested index is out of range.
      */
-    CGGlyphAtIndex$isValidIndex$(glyphIndex: number, isValidIndex: NobjcObject): number;
+    CGGlyphAtIndex$isValidIndex$(glyphIndex: number, isValidIndex: NobjcObject | null): number;
     CGGlyphAtIndex$(glyphIndex: number): number;
     isValidGlyphIndex$(glyphIndex: number): boolean;
     /**
@@ -113,7 +113,7 @@ export declare class _NSLayoutManager extends _NSObject {
     /**
      * Fills a passed-in buffer with a sequence of CGGlyphs. They will also optionally fill other passed-in buffers with the glyph properties, character indexes, and bidi levels corresponding to these glyphs. Each pointer passed in should either be NULL, or else point to sufficient memory to hold glyphRange.length elements. These methods return the number of glyphs filled in.
      */
-    getGlyphsInRange$glyphs$properties$characterIndexes$bidiLevels$(glyphRange: NSRange, glyphBuffer: NobjcObject, props: NobjcObject, charIndexBuffer: NobjcObject, bidiLevelBuffer: string | null): number;
+    getGlyphsInRange$glyphs$properties$characterIndexes$bidiLevels$(glyphRange: NSRange, glyphBuffer: NobjcObject | null, props: NobjcObject | null, charIndexBuffer: NobjcObject | null, bidiLevelBuffer: string | null): number;
     /**
      * Associates the given container with the given range of glyphs. This method should be called by the typesetter first, before setting line fragment rect or any of the layout bits, for each range of glyphs it lays out. This method will reset several key layout attributes (like not shown and draws outside line fragment) to their default values. In the course of layout, all glyphs should end up being included in a range passed to this method. The range passed in is not expected to be the entire range of glyphs for that text container; usually, in fact, it will be the range for a given line fragment being laid out in that container.
      */
@@ -145,14 +145,14 @@ export declare class _NSLayoutManager extends _NSObject {
     /**
      * Returns (by reference for the "get" method) the character index or glyph index or both of the first unlaid character/glyph in the layout manager at this time.
      */
-    getFirstUnlaidCharacterIndex$glyphIndex$(charIndex: NobjcObject, glyphIndex: NobjcObject): void;
+    getFirstUnlaidCharacterIndex$glyphIndex$(charIndex: NobjcObject | null, glyphIndex: NobjcObject | null): void;
     firstUnlaidCharacterIndex(): number;
     firstUnlaidGlyphIndex(): number;
     /**
      * Returns the container in which the given glyph is laid and (optionally) by reference the whole range of glyphs that are in that container. This will cause glyph generation and layout for the line fragment containing the specified glyph, or if non-contiguous layout is not enabled, up to and including that line fragment; if non-contiguous layout is not enabled and effectiveGlyphRange is non-NULL, this will additionally cause glyph generation and layout for the entire text container containing the specified glyph.
      */
-    textContainerForGlyphAtIndex$effectiveRange$(glyphIndex: number, effectiveGlyphRange: NobjcObject): _NSTextContainer | null;
-    textContainerForGlyphAtIndex$effectiveRange$withoutAdditionalLayout$(glyphIndex: number, effectiveGlyphRange: NobjcObject, flag: boolean): _NSTextContainer | null;
+    textContainerForGlyphAtIndex$effectiveRange$(glyphIndex: number, effectiveGlyphRange: NobjcObject | null): _NSTextContainer | null;
+    textContainerForGlyphAtIndex$effectiveRange$withoutAdditionalLayout$(glyphIndex: number, effectiveGlyphRange: NobjcObject | null, flag: boolean): _NSTextContainer | null;
     /**
      * Returns the container's currently used area. This determines the size that the view would need to be in order to display all the glyphs that are currently laid into the container. This causes neither glyph generation nor layout. Used rects are always in container coordinates.
      */
@@ -160,13 +160,13 @@ export declare class _NSLayoutManager extends _NSObject {
     /**
      * Returns the rect for the line fragment in which the given glyph is laid and (optionally) by reference the whole range of glyphs that are in that fragment. This will cause glyph generation and layout for the line fragment containing the specified glyph, or if non-contiguous layout is not enabled, up to and including that line fragment. Line fragment rects are always in container coordinates.
      */
-    lineFragmentRectForGlyphAtIndex$effectiveRange$(glyphIndex: number, effectiveGlyphRange: NobjcObject): CGRect;
-    lineFragmentRectForGlyphAtIndex$effectiveRange$withoutAdditionalLayout$(glyphIndex: number, effectiveGlyphRange: NobjcObject, flag: boolean): CGRect;
+    lineFragmentRectForGlyphAtIndex$effectiveRange$(glyphIndex: number, effectiveGlyphRange: NobjcObject | null): CGRect;
+    lineFragmentRectForGlyphAtIndex$effectiveRange$withoutAdditionalLayout$(glyphIndex: number, effectiveGlyphRange: NobjcObject | null, flag: boolean): CGRect;
     /**
      * Returns the usage rect for the line fragment in which the given glyph is laid and (optionally) by reference the whole range of glyphs that are in that fragment. This will cause glyph generation and layout for the line fragment containing the specified glyph, or if non-contiguous layout is not enabled, up to and including that line fragment. Line fragment used rects are always in container coordinates.
      */
-    lineFragmentUsedRectForGlyphAtIndex$effectiveRange$(glyphIndex: number, effectiveGlyphRange: NobjcObject): CGRect;
-    lineFragmentUsedRectForGlyphAtIndex$effectiveRange$withoutAdditionalLayout$(glyphIndex: number, effectiveGlyphRange: NobjcObject, flag: boolean): CGRect;
+    lineFragmentUsedRectForGlyphAtIndex$effectiveRange$(glyphIndex: number, effectiveGlyphRange: NobjcObject | null): CGRect;
+    lineFragmentUsedRectForGlyphAtIndex$effectiveRange$withoutAdditionalLayout$(glyphIndex: number, effectiveGlyphRange: NobjcObject | null, flag: boolean): CGRect;
     /**
      * Returns the location for the given glyph within its line fragment. If this glyph does not have an explicit location set for it (i.e., it is part of (but not first in) a sequence of nominally spaced characters), the location is calculated by glyph advancements from the location of the most recent preceding glyph with a location set. Glyph locations are relative to their line fragment rect's origin. This will cause glyph generation and layout for the line fragment containing the specified glyph, or if non-contiguous layout is not enabled, up to and including that line fragment.
      */
@@ -190,11 +190,11 @@ export declare class _NSLayoutManager extends _NSObject {
     /**
      * Returns the range of glyphs that are generated from the characters in the given charRange. If actualCharRange is not NULL, it will return by reference the actual range of characters that fully define the glyph range returned. This range may be identical to or slightly larger than the requested character range. For example, if the text storage contains the characters "o" and (umlaut) and the glyph store contains the single precomposed glyph (o-umlaut), and if the character range given encloses only the first or second character, then actualCharRange will be set to enclose both characters. If the length of charRange is zero, the resulting glyph range will be a zero-length range just after the glyph(s) corresponding to the preceding character, and actualCharRange will also be zero-length. If non-contiguous layout is not enabled, this will force the generation of glyphs for all characters up to and including the end of the specified range.
      */
-    glyphRangeForCharacterRange$actualCharacterRange$(charRange: NSRange, actualCharRange: NobjcObject): NSRange;
+    glyphRangeForCharacterRange$actualCharacterRange$(charRange: NSRange, actualCharRange: NobjcObject | null): NSRange;
     /**
      * Returns the range of characters that generated the glyphs in the given glyphRange. If actualGlyphRange is not NULL, it will return by reference the full range of glyphs generated by the character range returned. This range may be identical or slightly larger than the requested glyph range. For example, if the text storage contains the character (o-umlaut) and the glyph store contains the two atomic glyphs "o" and (umlaut), and if the glyph range given encloses only the first or second glyph, then actualGlyphRange will be set to enclose both glyphs. If the length of glyphRange is zero, the resulting character range will be a zero-length range just after the character(s) corresponding to the preceding glyph, and actualGlyphRange will also be zero-length. If non-contiguous layout is not enabled, this will force the generation of glyphs for all characters up to and including the end of the returned range.
      */
-    characterRangeForGlyphRange$actualGlyphRange$(glyphRange: NSRange, actualGlyphRange: NobjcObject): NSRange;
+    characterRangeForGlyphRange$actualGlyphRange$(glyphRange: NSRange, actualGlyphRange: NobjcObject | null): NSRange;
     /**
      * Returns the range of characters which have been laid into the given container. This is a less efficient method than the similar -textContainerForGlyphAtIndex:effectiveRange:.
      */
@@ -215,17 +215,17 @@ export declare class _NSLayoutManager extends _NSObject {
     /**
      * Returns the index of the glyph falling under the given point, expressed in the given container's coordinate system. If no glyph is under the point, the nearest glyph is returned, where nearest is defined according to the requirements of selection by touch or mouse. Clients who wish to determine whether the the point actually lies within the bounds of the glyph returned should follow this with a call to boundingRectForGlyphRange:inTextContainer: and test whether the point falls in the rect returned by that method. If partialFraction is non-NULL, it will return by reference the fraction of the distance between the location of the glyph returned and the location of the next glyph.
      */
-    glyphIndexForPoint$inTextContainer$fractionOfDistanceThroughGlyph$(point: CGPoint, container: _NSTextContainer, partialFraction: NobjcObject): number;
+    glyphIndexForPoint$inTextContainer$fractionOfDistanceThroughGlyph$(point: CGPoint, container: _NSTextContainer, partialFraction: NobjcObject | null): number;
     glyphIndexForPoint$inTextContainer$(point: CGPoint, container: _NSTextContainer): number;
     fractionOfDistanceThroughGlyphForPoint$inTextContainer$(point: CGPoint, container: _NSTextContainer): number;
     /**
      * Returns the index of the character falling under the given point, expressed in the given container's coordinate system. If no character is under the point, the nearest character is returned, where nearest is defined according to the requirements of selection by touch or mouse. This is not simply equivalent to taking the result of the corresponding glyph index method and converting it to a character index, because in some cases a single glyph represents more than one selectable character, for example an fi ligature glyph. In that case, there will be an insertion point within the glyph, and this method will return one character or the other, depending on whether the specified point lies to the left or the right of that insertion point. In general, this method will return only character indexes for which there is an insertion point (see next method). The partial fraction is a fraction of the distance from the insertion point logically before the given character to the next one, which may be either to the right or to the left depending on directionality.
      */
-    characterIndexForPoint$inTextContainer$fractionOfDistanceBetweenInsertionPoints$(point: CGPoint, container: _NSTextContainer, partialFraction: NobjcObject): number;
+    characterIndexForPoint$inTextContainer$fractionOfDistanceBetweenInsertionPoints$(point: CGPoint, container: _NSTextContainer, partialFraction: NobjcObject | null): number;
     /**
      * Allows clients to obtain all insertion points for a line fragment in one call. The caller specifies the line fragment by supplying one character index within it, and can choose whether to obtain primary or alternate insertion points, and whether they should be in logical or in display order. The return value is the number of insertion points returned. Each pointer passed in should either be NULL, or else point to sufficient memory to hold as many elements as there are insertion points in the line fragment (which cannot be more than the number of characters + 1). The positions buffer passed in will be filled in with the positions of the insertion points, in the order specified, and the charIndexes buffer passed in will be filled in with the corresponding character indexes. Positions indicate a transverse offset relative to the line fragment rect's origin. Internal caching is used to ensure that repeated calls to this method for the same line fragment (possibly with differing values for other arguments) will not be significantly more expensive than a single call.
      */
-    getLineFragmentInsertionPointsForCharacterAtIndex$alternatePositions$inDisplayOrder$positions$characterIndexes$(charIndex: number, aFlag: boolean, dFlag: boolean, positions: NobjcObject, charIndexes: NobjcObject): number;
+    getLineFragmentInsertionPointsForCharacterAtIndex$alternatePositions$inDisplayOrder$positions$characterIndexes$(charIndex: number, aFlag: boolean, dFlag: boolean, positions: NobjcObject | null, charIndexes: NobjcObject | null): number;
     /** Enumerates line fragments intersecting with glyphRange. */
     enumerateLineFragmentsForGlyphRange$usingBlock$(glyphRange: NSRange, block: NobjcObject): void;
     /**
@@ -269,18 +269,18 @@ export declare class _NSLayoutManager extends _NSObject {
     /**
      * Similar to the above, but they can be passed any index in the range and will return the range by reference if effectiveGlyphRange is not NULL.
      */
-    layoutRectForTextBlock$atIndex$effectiveRange$(block: _NSTextBlock, glyphIndex: number, effectiveGlyphRange: NobjcObject): CGRect;
-    boundsRectForTextBlock$atIndex$effectiveRange$(block: _NSTextBlock, glyphIndex: number, effectiveGlyphRange: NobjcObject): CGRect;
+    layoutRectForTextBlock$atIndex$effectiveRange$(block: _NSTextBlock, glyphIndex: number, effectiveGlyphRange: NobjcObject | null): CGRect;
+    boundsRectForTextBlock$atIndex$effectiveRange$(block: _NSTextBlock, glyphIndex: number, effectiveGlyphRange: NobjcObject | null): CGRect;
     /**
      * Temporary attributes provide a way to override attributes for drawing on a per-layout manager basis, without affecting the underlying stored text. Clients may set any attributes they wish, but the only attributes that the layout manager will recognize for drawing are those that do not affect layout (color, underline, etc.).
      */
-    temporaryAttributesAtCharacterIndex$effectiveRange$(charIndex: number, effectiveCharRange: NobjcObject): _NSDictionary;
+    temporaryAttributesAtCharacterIndex$effectiveRange$(charIndex: number, effectiveCharRange: NobjcObject | null): _NSDictionary;
     setTemporaryAttributes$forCharacterRange$(attrs: _NSDictionary, charRange: NSRange): void;
     addTemporaryAttributes$forCharacterRange$(attrs: _NSDictionary, charRange: NSRange): void;
     removeTemporaryAttribute$forCharacterRange$(attrName: _NSString, charRange: NSRange): void;
-    temporaryAttribute$atCharacterIndex$effectiveRange$(attrName: _NSString, location: number, range: NobjcObject): NobjcObject;
-    temporaryAttribute$atCharacterIndex$longestEffectiveRange$inRange$(attrName: _NSString, location: number, range: NobjcObject, rangeLimit: NSRange): NobjcObject;
-    temporaryAttributesAtCharacterIndex$longestEffectiveRange$inRange$(location: number, range: NobjcObject, rangeLimit: NSRange): _NSDictionary;
+    temporaryAttribute$atCharacterIndex$effectiveRange$(attrName: _NSString, location: number, range: NobjcObject | null): NobjcObject | null;
+    temporaryAttribute$atCharacterIndex$longestEffectiveRange$inRange$(attrName: _NSString, location: number, range: NobjcObject | null, rangeLimit: NSRange): NobjcObject | null;
+    temporaryAttributesAtCharacterIndex$longestEffectiveRange$inRange$(location: number, range: NobjcObject | null, rangeLimit: NSRange): _NSDictionary;
     addTemporaryAttribute$value$forCharacterRange$(attrName: _NSString, value: NobjcObject, charRange: NSRange): void;
     /**
      * Returns the default line height specified by the layout manager's typesetter behavior for the given font.
@@ -300,16 +300,16 @@ export declare class _NSLayoutManager extends _NSObject {
      */
     layoutManagerOwnsFirstResponderInWindow$(window: _NSWindow): boolean;
     /** Use -CGGlyphAtIndex:isValidIndex: instead */
-    glyphAtIndex$isValidIndex$(glyphIndex: number, isValidIndex: NobjcObject): number;
+    glyphAtIndex$isValidIndex$(glyphIndex: number, isValidIndex: NobjcObject | null): number;
     /** Use -CGGlyphAtIndex: instead */
     glyphAtIndex$(glyphIndex: number): number;
     /**
      * These two methods are soft deprecated starting with OS X 10.11. It will be officially deprecated in a future release. Use -enumerateEnclosingRectsForGlyphRange:withinSelectedGlyphRange:inTextContainer:usingBlock: instead
      * @deprecated
      */
-    rectArrayForCharacterRange$withinSelectedCharacterRange$inTextContainer$rectCount$(charRange: NSRange, selCharRange: NSRange, container: _NSTextContainer, rectCount: NobjcObject): NobjcObject;
+    rectArrayForCharacterRange$withinSelectedCharacterRange$inTextContainer$rectCount$(charRange: NSRange, selCharRange: NSRange, container: _NSTextContainer, rectCount: NobjcObject): NobjcObject | null;
     /** @deprecated */
-    rectArrayForGlyphRange$withinSelectedGlyphRange$inTextContainer$rectCount$(glyphRange: NSRange, selGlyphRange: NSRange, container: _NSTextContainer, rectCount: NobjcObject): NobjcObject;
+    rectArrayForGlyphRange$withinSelectedGlyphRange$inTextContainer$rectCount$(glyphRange: NSRange, selGlyphRange: NSRange, container: _NSTextContainer, rectCount: NobjcObject): NobjcObject | null;
     /** @deprecated */
     substituteFontForFont$(originalFont: _NSFont): _NSFont;
     /**
@@ -347,19 +347,19 @@ export declare class _NSLayoutManager extends _NSObject {
     /**
      * @deprecated Use -getGlyphsInRange:glyphs:properties:characterIndexes:bidiLevels: instead
      */
-    getGlyphsInRange$glyphs$characterIndexes$glyphInscriptions$elasticBits$(glyphRange: NSRange, glyphBuffer: NobjcObject, charIndexBuffer: NobjcObject, inscribeBuffer: NobjcObject, elasticBuffer: NobjcObject): number;
+    getGlyphsInRange$glyphs$characterIndexes$glyphInscriptions$elasticBits$(glyphRange: NSRange, glyphBuffer: NobjcObject | null, charIndexBuffer: NobjcObject | null, inscribeBuffer: NobjcObject | null, elasticBuffer: NobjcObject | null): number;
     /**
      * @deprecated Use -getGlyphsInRange:glyphs:properties:characterIndexes:bidiLevels: instead
      */
-    getGlyphsInRange$glyphs$characterIndexes$glyphInscriptions$elasticBits$bidiLevels$(glyphRange: NSRange, glyphBuffer: NobjcObject, charIndexBuffer: NobjcObject, inscribeBuffer: NobjcObject, elasticBuffer: NobjcObject, bidiLevelBuffer: string | null): number;
+    getGlyphsInRange$glyphs$characterIndexes$glyphInscriptions$elasticBits$bidiLevels$(glyphRange: NSRange, glyphBuffer: NobjcObject | null, charIndexBuffer: NobjcObject | null, inscribeBuffer: NobjcObject | null, elasticBuffer: NobjcObject | null, bidiLevelBuffer: string | null): number;
     /**
      * @deprecated Use -getGlyphsInRange:glyphs:properties:characterIndexes:bidiLevels: instead
      */
-    getGlyphs$range$(glyphArray: NobjcObject, glyphRange: NSRange): number;
+    getGlyphs$range$(glyphArray: NobjcObject | null, glyphRange: NSRange): number;
     /**
      * @deprecated Use -invalidateLayoutForCharacterRange:actualCharacterRange: instead
      */
-    invalidateLayoutForCharacterRange$isSoft$actualCharacterRange$(charRange: NSRange, flag: boolean, actualCharRange: NobjcObject): void;
+    invalidateLayoutForCharacterRange$isSoft$actualCharacterRange$(charRange: NSRange, flag: boolean, actualCharRange: NobjcObject | null): void;
     /**
      * @deprecated Use -processEditingForTextStorage:edited:range:changeInLength:invalidatedRange: instead
      */

package/dist/AppKit/NSLayoutManagerDelegate.d.ts

@@ -52,5 +52,5 @@ export interface _NSLayoutManagerDelegate {
     /**
      * This is sent when the layout manager is drawing and needs to decide whether to use temporary attributes or not. The delegate returns a dictionary of temporary attributes to be used, or nil to suppress the use of temporary attributes altogether. The effectiveCharRange argument is both an in and out by-reference effective range for those attributes. The default behavior if this method is not implemented is to use temporary attributes only when drawing to the screen, so an implementation to match that behavior would return attrs if toScreen is YES and nil otherwise, without changing effectiveCharRange.
      */
-    layoutManager$shouldUseTemporaryAttributes$forDrawingToScreen$atCharacterIndex$effectiveRange$?(layoutManager: _NSLayoutManager, attrs: _NSDictionary, toScreen: boolean, charIndex: number, effectiveCharRange: NobjcObject): _NSDictionary | null;
+    layoutManager$shouldUseTemporaryAttributes$forDrawingToScreen$atCharacterIndex$effectiveRange$?(layoutManager: _NSLayoutManager, attrs: _NSDictionary, toScreen: boolean, charIndex: number, effectiveCharRange: NobjcObject | null): _NSDictionary | null;
 }

package/dist/AppKit/NSMatrix.d.ts

@@ -5,6 +5,8 @@ import type { _NSControl } from "./NSControl.js";
 import type { _NSEvent } from "./NSEvent.js";
 import type { _NSMatrixDelegate } from "./NSMatrixDelegate.js";
 import type { _NSText } from "./NSText.js";
+import type { _NSUserInterfaceValidations } from "./NSUserInterfaceValidations.js";
+import type { _NSViewToolTipOwner } from "./NSViewToolTipOwner.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSNotification } from "../Foundation/NSNotification.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -18,20 +20,20 @@ export declare class _NSMatrix extends _NSControl {
     init(): _NSMatrix;
     initWithFrame$(frameRect: CGRect): _NSMatrix;
     initWithFrame$mode$prototype$numberOfRows$numberOfColumns$(frameRect: CGRect, mode: NSMatrixMode, cell: _NSCell, rowsHigh: number, colsWide: number): _NSMatrix;
-    initWithFrame$mode$cellClass$numberOfRows$numberOfColumns$(frameRect: CGRect, mode: NSMatrixMode, factoryId: NobjcObject, rowsHigh: number, colsWide: number): _NSMatrix;
+    initWithFrame$mode$cellClass$numberOfRows$numberOfColumns$(frameRect: CGRect, mode: NSMatrixMode, factoryId: NobjcObject | null, rowsHigh: number, colsWide: number): _NSMatrix;
     makeCellAtRow$column$(row: number, col: number): _NSCell;
     sendAction$to$forAllCells$(selector: string, object_: NobjcObject, flag: boolean): void;
     sortUsingSelector$(comparator: string): void;
-    sortUsingFunction$context$(compare: NobjcObject, context: Uint8Array | null): void;
+    sortUsingFunction$context$(compare: NobjcObject | null, context: Uint8Array | null): void;
     setSelectionFrom$to$anchor$highlight$(startPos: number, endPos: number, anchorPos: number, lit: boolean): void;
     deselectSelectedCell(): void;
     deselectAllCells(): void;
     selectCellAtRow$column$(row: number, col: number): void;
-    selectAll$(sender: NobjcObject): void;
+    selectAll$(sender: NobjcObject | null): void;
     selectCellWithTag$(tag: number): boolean;
     setScrollable$(flag: boolean): void;
     setState$atRow$column$(value: number, row: number, col: number): void;
-    getNumberOfRows$columns$(rowCount: NobjcObject, colCount: NobjcObject): void;
+    getNumberOfRows$columns$(rowCount: NobjcObject | null, colCount: NobjcObject | null): void;
     cellAtRow$column$(row: number, col: number): _NSCell | null;
     cellFrameAtRow$column$(row: number, col: number): CGRect;
     getRow$column$ofCell$(row: NobjcObject, col: NobjcObject, cell: _NSCell): boolean;
@@ -63,14 +65,12 @@ export declare class _NSMatrix extends _NSControl {
     textDidBeginEditing$(notification: _NSNotification): void;
     textDidEndEditing$(notification: _NSNotification): void;
     textDidChange$(notification: _NSNotification): void;
-    selectText$(sender: NobjcObject): void;
+    selectText$(sender: NobjcObject | null): void;
     selectTextAtRow$column$(row: number, col: number): _NSCell | null;
     acceptsFirstMouse$(event: _NSEvent | null): boolean;
     resetCursorRects(): void;
     setToolTip$forCell$(toolTipString: _NSString | null, cell: _NSCell): void;
     toolTipForCell$(cell: _NSCell): _NSString | null;
-    cellClass(): NobjcObject;
-    setCellClass$(value: NobjcObject): void;
     prototype(): _NSCell | null;
     setPrototype$(value: _NSCell | null): void;
     mode(): NSMatrixMode;
@@ -117,3 +117,5 @@ export declare class _NSMatrix extends _NSControl {
     keyCell(): _NSCell | null;
     setKeyCell$(value: _NSCell | null): void;
 }
+export interface _NSMatrix extends _NSUserInterfaceValidations, _NSViewToolTipOwner {
+}

package/dist/AppKit/NSMediaLibraryBrowserController.d.ts

@@ -7,7 +7,7 @@ export declare class _NSMediaLibraryBrowserController extends _NSObject {
     static new(): _NSMediaLibraryBrowserController;
     init(): _NSMediaLibraryBrowserController;
     static sharedMediaLibraryBrowserController(): _NSMediaLibraryBrowserController;
-    togglePanel$(sender: NobjcObject): void;
+    togglePanel$(sender: NobjcObject | null): void;
     visible(): boolean;
     setVisible$(value: boolean): void;
     frame(): CGRect;

package/dist/AppKit/NSMenu.d.ts

@@ -3,12 +3,16 @@ import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSCoder } from "../Foundation/NSCoder.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
+import type { _NSAccessibility } from "./NSAccessibility.js";
+import type { _NSAppearanceCustomization } from "./NSAppearanceCustomization.js";
 import type { _NSEvent } from "./NSEvent.js";
 import type { _NSFont } from "./NSFont.js";
 import type { _NSImage } from "./NSImage.js";
 import type { _NSMenuDelegate } from "./NSMenuDelegate.js";
 import type { _NSMenuItem } from "./NSMenuItem.js";
+import type { _NSUserInterfaceItemIdentification } from "./NSUserInterfaceItemIdentification.js";
 import type { _NSView } from "./NSView.js";
+import type { _PDFView } from "../PDFKit/PDFView.js";
 import type { CGPoint } from "../structs/CGPoint.js";
 import type { CGSize } from "../structs/CGSize.js";
 import type { NSMenuPresentationStyle } from "./NSMenuPresentationStyle.js";
@@ -32,11 +36,11 @@ export declare class _NSMenu extends _NSObject {
     /**
      * Creates a palette menu displaying user-selectable color tags using the provided array of colors and optional titles. Note that the palette menu is configured for display as an inline menu; you must set it as the submenu of another menu item, contained in a standard menu. The palette menu cannot be used to invoke the `popUpMenuPositioningItem` method, or attached directly to a popup button or toolbar item. @return An autoconfigured palette menu.
      */
-    static paletteMenuWithColors$titles$selectionHandler$(colors: _NSArray, itemTitles: _NSArray, onSelectionChange: NobjcObject): _NSMenu;
+    static paletteMenuWithColors$titles$selectionHandler$(colors: _NSArray, itemTitles: _NSArray, onSelectionChange: NobjcObject | null): _NSMenu;
     /**
      * Creates a palette menu displaying user-selectable color tags using the provided template image, tinted using the specified array of colors. Optionally allows observing changes to the selection state in the compact menu. The block is invoked after the selection has been updated. Currently selected items can be retrieved from the `selectedItems` property. Note that the palette menu is configured for display as an inline menu; you must set it as the submenu of another menu item, contained in a standard menu. The palette menu cannot be used to invoke the `popUpMenuPositioningItem` method, or attached directly to a popup button or toolbar item. @return An autoconfigured palette menu.
      */
-    static paletteMenuWithColors$titles$templateImage$selectionHandler$(colors: _NSArray, itemTitles: _NSArray, image: _NSImage, onSelectionChange: NobjcObject): _NSMenu;
+    static paletteMenuWithColors$titles$templateImage$selectionHandler$(colors: _NSArray, itemTitles: _NSArray, image: _NSImage, onSelectionChange: NobjcObject | null): _NSMenu;
     /**
      * Returns the zone used to allocate NSMenu objects. This is left in for compatibility and has returned NSDefaultMallocZone() since OS X 10.2. It is not necessary to use this - menus can be allocated the usual way.
      * @deprecated
@@ -92,9 +96,9 @@ export declare class _NSMenu extends _NSObject {
      */
     indexOfItemWithTitle$(title: _NSString): number;
     indexOfItemWithTag$(tag: number): number;
-    indexOfItemWithRepresentedObject$(object_: NobjcObject): number;
+    indexOfItemWithRepresentedObject$(object_: NobjcObject | null): number;
     indexOfItemWithSubmenu$(submenu: _NSMenu | null): number;
-    indexOfItemWithTarget$andAction$(target: NobjcObject, actionSelector: string | null): number;
+    indexOfItemWithTarget$andAction$(target: NobjcObject | null, actionSelector: string | null): number;
     /**
      * Returns the first item in the menu with the given property, or nil if no item in the menu matches.
      */
@@ -122,7 +126,7 @@ export declare class _NSMenu extends _NSObject {
      * Dismisses the menu immediately, without any fade or other effect, and ends all menu tracking
      */
     cancelTrackingWithoutAnimation(): void;
-    submenuAction$(sender: NobjcObject): void;
+    submenuAction$(sender: NobjcObject | null): void;
     /** @deprecated */
     setMenuRepresentation$(menuRep: NobjcObject): void;
     /** @deprecated */
@@ -170,7 +174,7 @@ export declare class _NSMenu extends _NSObject {
     /**
      * Set and get the delegate for the menu. The delegate is weakly referenced for zeroing-weak compatible objects on 10.9 and later. Otherwise the behavior of this property is 'assign'. See the NSMenuDelegate protocol for methods that the delegate may implement.
      */
-    delegate(): _NSMenuDelegate | null;
+    delegate(): _PDFView | null;
     setDelegate$(value: _NSMenuDelegate | null): void;
     /**
      * If called on the main menu, returns the height of the menu bar in pixels. If called on any other menu, returns 0.
@@ -239,3 +243,5 @@ export declare class _NSMenu extends _NSObject {
     /** @deprecated */
     tornOff(): boolean;
 }
+export interface _NSMenu extends _NSUserInterfaceItemIdentification, _NSAppearanceCustomization, _NSAccessibility {
+}

package/dist/AppKit/NSMenuDelegate.d.ts

@@ -9,7 +9,7 @@ export interface _NSMenuDelegate {
     numberOfItemsInMenu$?(menu: _NSMenu): number;
     menu$updateItem$atIndex$shouldCancel$?(menu: _NSMenu, item: _NSMenuItem, index: number, shouldCancel: boolean): boolean;
     /** implement either the first one or the next two to populate the menu */
-    menuHasKeyEquivalent$forEvent$target$action$?(menu: _NSMenu, event: _NSEvent, target: NobjcObject, action: NobjcObject): boolean;
+    menuHasKeyEquivalent$forEvent$target$action$?(menu: _NSMenu, event: _NSEvent, target: NobjcObject | null, action: NobjcObject | null): boolean;
     /**
      * indicates that the menu is being opened (displayed) or closed (hidden). Do not modify the structure of the menu or the menu items from within these callbacks.
      */

package/dist/AppKit/NSMenuItem.d.ts

@@ -4,9 +4,11 @@ import type { _NSAttributedString } from "../Foundation/NSAttributedString.js";
 import type { _NSCoder } from "../Foundation/NSCoder.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
+import type { _NSAccessibility } from "./NSAccessibility.js";
 import type { _NSImage } from "./NSImage.js";
 import type { _NSMenu } from "./NSMenu.js";
 import type { _NSMenuItemBadge } from "./NSMenuItemBadge.js";
+import type { _NSUserInterfaceItemIdentification } from "./NSUserInterfaceItemIdentification.js";
 import type { _NSView } from "./NSView.js";
 import type { NSEventModifierFlags } from "./NSEventModifierFlags.js";
 export declare class _NSMenuItem extends _NSObject {
@@ -97,14 +99,14 @@ export declare class _NSMenuItem extends _NSObject {
     setAlternate$(value: boolean): void;
     indentationLevel(): number;
     setIndentationLevel$(value: number): void;
-    target(): NobjcObject;
-    setTarget$(value: NobjcObject): void;
+    target(): NobjcObject | null;
+    setTarget$(value: NobjcObject | null): void;
     action(): string | null;
     setAction$(value: string | null): void;
     tag(): number;
     setTag$(value: number): void;
-    representedObject(): NobjcObject;
-    setRepresentedObject$(value: NobjcObject): void;
+    representedObject(): NobjcObject | null;
+    setRepresentedObject$(value: NobjcObject | null): void;
     /**
      * Set (and get) the view for a menu item. By default, a menu item has a nil view. A menu item with a view does not draw its title, state, font, or other standard drawing attributes, and assigns drawing responsibility entirely to the view. Keyboard equivalents and type-select continue to use the key equivalent and title as normal. A menu item with a view sizes itself according to the view's frame, and the width of the other menu items. The menu item will always be at least as wide as its view, but it may be wider. If you want your view to auto-expand to fill the menu item, then make sure that its autoresizing mask has NSViewWidthSizable set; in that case, the view's width at the time setView: is called will be treated as the minimum width for the view. A menu will resize itself as its containing views change frame size. Changes to the view's frame during tracking are reflected immediately in the menu. A view in a menu item will receive mouse and keyboard events normally. During non-sticky menu tracking (manipulating menus with the mouse button held down), a view in a menu item will receive mouseDragged: events. Animation is possible via the usual mechanism (set a timer to call setNeedsDisplay: or display), but because menu tracking occurs in the NSEventTrackingRunLoopMode, you must add the timer to the run loop in that mode. When the menu is opened, the view is added to a window; when the menu is closed the view is removed from the window. Override viewDidMoveToWindow in your view for a convenient place to start/stop animations, reset tracking rects, etc., but do not attempt to move or otherwise modify the window. When a menu item is copied via NSCopying, any attached view is copied via archiving/unarchiving. Menu item views are not supported in the Dock menu.
      */
@@ -126,3 +128,5 @@ export declare class _NSMenuItem extends _NSObject {
     badge(): _NSMenuItemBadge;
     setBadge$(value: _NSMenuItemBadge): void;
 }
+export interface _NSMenuItem extends _NSUserInterfaceItemIdentification, _NSAccessibility {
+}