objcjs-types 0.4.0 → 0.5.0

package/dist/AppKit/NSDocumentController.d.ts

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

package/dist/AppKit/NSDraggingInfo.d.ts

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

package/dist/AppKit/NSDraggingItem.d.ts

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

package/dist/AppKit/NSDraggingSession.d.ts

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

package/dist/AppKit/NSEvent.d.ts

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

package/dist/AppKit/NSFilePromiseProviderDelegate.d.ts

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

package/dist/AppKit/NSFilePromiseReceiver.d.ts

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

package/dist/AppKit/NSFontAssetRequest.d.ts

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

package/dist/AppKit/NSImage.d.ts

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

package/dist/AppKit/NSLayoutManager.d.ts

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

package/dist/AppKit/NSMenu.d.ts

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

package/dist/AppKit/NSMenuItem.d.ts

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

package/dist/AppKit/NSModalResponse.d.ts

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

package/dist/AppKit/NSModalResponse.js

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

package/dist/AppKit/NSPDFPanel.d.ts

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

package/dist/AppKit/NSPageLayout.d.ts

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

package/dist/AppKit/NSPasteboard.d.ts

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

package/dist/AppKit/NSPasteboardItem.d.ts

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

package/dist/AppKit/NSPrintPanel.d.ts

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

package/dist/AppKit/NSSavePanel.d.ts

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

package/dist/AppKit/NSScrubber.d.ts

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

package/dist/AppKit/NSSharingService.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -20,7 +19,7 @@ export declare class _NSSharingService extends _NSObject {
     /**
      * Creates a custom NSSharingService object. Custom sharing services can be added to the NSSharingServicePicker with the sharingServicePicker:sharingServicesForItems:proposedSharingServices: delegate method.
      */
-    initWithTitle$image$alternateImage$handler$(title: _NSString, image: _NSImage, alternateImage: _NSImage | null, block: NobjcObject): _NSSharingService;
+    initWithTitle$image$alternateImage$handler$(title: _NSString, image: _NSImage, alternateImage: _NSImage | null, block: () => void): _NSSharingService;
     /**
      * Returns whether a service can do something with all the provided items. This can be used to validate a custom UI such as a dedicated Twitter button. If items is nil, the method will return YES when the service is configured. Therefore you could call it once at launch time with nil items to check whether to display the button or not, and then with real items to enable and disable the button depending on the context or selection. The items represent the objects to be shared and must conform to the <NSPasteboardWriting > protocol or be an NSItemProvider or an NSDocument. (e.g. NSString, NSImage, NSURL, etc.)
      */

package/dist/AppKit/NSSliderAccessoryBehavior.d.ts

@@ -14,7 +14,7 @@ export declare class _NSSliderAccessoryBehavior extends _NSObject {
     /**
      * The handler block is invoked on interaction. This variant is not codable and will assert in `-encodeWithCoder:`.
      */
-    static behaviorWithHandler$(handler: NobjcObject): _NSSliderAccessoryBehavior;
+    static behaviorWithHandler$(handler: (arg0: _NSSliderAccessory) => void): _NSSliderAccessoryBehavior;
     /**
      * The behavior is automatically picked to be the system standard for the slider's current context, e.g. NSTouchBarItems have `.valueStep` behavior.
      */

package/dist/AppKit/NSSpellChecker.d.ts

@@ -57,11 +57,11 @@ export declare class _NSSpellChecker extends _NSObject {
     /**
      * Requests unified text checking in the background. The return value is a monotonically increasing sequence number that can be used to keep track of requests in flight. The completion handler will be called (in an arbitrary context) when results are available, with the sequence number and results. The arguments and results are otherwise the same as for the previous method.
      */
-    requestCheckingOfString$range$types$options$inSpellDocumentWithTag$completionHandler$(stringToCheck: _NSString, range: NSRange, checkingTypes: number, options: _NSDictionary | null, tag: number, completionHandler: NobjcObject | null): number;
+    requestCheckingOfString$range$types$options$inSpellDocumentWithTag$completionHandler$(stringToCheck: _NSString, range: NSRange, checkingTypes: number, options: _NSDictionary | null, tag: number, completionHandler: ((sequenceNumber: number, results: _NSArray, orthography: _NSOrthography, wordCount: number) => void) | null): number;
     /**
      * Requests candidate generation in the background. The return value is a monotonically increasing sequence number that can be used to keep track of requests in flight. The completion handler will be called (in an arbitrary context) when results are available, with the sequence number and results.
      */
-    requestCandidatesForSelectedRange$inString$types$options$inSpellDocumentWithTag$completionHandler$(selectedRange: NSRange, stringToCheck: _NSString, checkingTypes: number, options: _NSDictionary | null, tag: number, completionHandler: NobjcObject | null): number;
+    requestCandidatesForSelectedRange$inString$types$options$inSpellDocumentWithTag$completionHandler$(selectedRange: NSRange, stringToCheck: _NSString, checkingTypes: number, options: _NSDictionary | null, tag: number, completionHandler: ((sequenceNumber: number, candidates: _NSArray) => void) | null): number;
     /**
      * Provides a menu containing contextual menu items suitable for certain kinds of detected results (notably date/time/address results). The options dictionary allows clients to pass in information associated with the document.
      */
@@ -109,7 +109,7 @@ export declare class _NSSpellChecker extends _NSObject {
      */
     closeSpellDocumentWithTag$(tag: number): void;
     recordResponse$toCorrection$forWord$language$inSpellDocumentWithTag$(response: NSCorrectionResponse, correction: _NSString, word: _NSString, language: _NSString | null, tag: number): void;
-    showCorrectionIndicatorOfType$primaryString$alternativeStrings$forStringInRect$view$completionHandler$(type: NSCorrectionIndicatorType, primaryString: _NSString, alternativeStrings: _NSArray, rectOfTypedString: CGRect, view: _NSView, completionBlock: NobjcObject | null): void;
+    showCorrectionIndicatorOfType$primaryString$alternativeStrings$forStringInRect$view$completionHandler$(type: NSCorrectionIndicatorType, primaryString: _NSString, alternativeStrings: _NSArray, rectOfTypedString: CGRect, view: _NSView, completionBlock: ((arg0: _NSString) => void) | null): void;
     dismissCorrectionIndicatorForView$(view: _NSView): void;
     /**
      * Clients may use this to cause inline prediction candidates to be shown. The candidates passed in should come from calling requestCandidates with the NSTextCheckingGenerateInlinePredictionsKey option set. The inline prediction (if any) will be sent to the client for display using NSTextInputClient methods.

package/dist/AppKit/NSStepperTouchBarItem.d.ts

@@ -2,6 +2,7 @@ import type { NobjcObject } from "objc-js";
 import type { _NSTouchBarItem } from "./NSTouchBarItem.js";
 import type { _NSFormatter } from "../Foundation/NSFormatter.js";
 import type { _NSString } from "../Foundation/NSString.js";
+import type { CGRect } from "../structs/CGRect.js";
 export declare class _NSStepperTouchBarItem extends _NSTouchBarItem {
     static alloc(): _NSStepperTouchBarItem;
     static new(): _NSStepperTouchBarItem;
@@ -13,7 +14,7 @@ export declare class _NSStepperTouchBarItem extends _NSTouchBarItem {
     /**
      * Creates an `NSStepperTouchBarItem` using the result of `drawingHandler` to display the stepper's value as an image @param drawingHandler A block that draws a graphical representation of the stepper's value in the specified rectangle. The coordinates of this rectangle are specified in points.
      */
-    static stepperTouchBarItemWithIdentifier$drawingHandler$(identifier: _NSString, drawingHandler: NobjcObject): _NSStepperTouchBarItem;
+    static stepperTouchBarItemWithIdentifier$drawingHandler$(identifier: _NSString, drawingHandler: (rect: CGRect, value: number) => void): _NSStepperTouchBarItem;
     /** The stepper's maximum value. The default is 59.0. */
     maxValue(): number;
     setMaxValue$(value: number): void;

package/dist/AppKit/NSStoryboard.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSBundle } from "../Foundation/NSBundle.js";
+import type { _NSCoder } from "../Foundation/NSCoder.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 export declare class _NSStoryboard extends _NSObject {
@@ -21,7 +22,7 @@ export declare class _NSStoryboard extends _NSObject {
     /**
      * Every storyboard may have an initial view or window controller. Each invocation of this method instantiates an instance of the initial controller. The developer chooses the initial controller in an inspector within Interface Builder. A creator can be specified for controller instantiation, giving the developer a chance to call an initalizer that takes an NSCoder and additional arguments. If the block returns nil, the initial view controller will be created using the standard initWithCoder: initializer.
      */
-    instantiateInitialControllerWithCreator$(block: NobjcObject | null): NobjcObject | null;
+    instantiateInitialControllerWithCreator$(block: ((arg0: _NSCoder) => NobjcObject) | null): NobjcObject | null;
     /**
      * Controllers in Interface Builder have an optional identifier within the storyboard. That identifier is set from the inspector in Interface Builder. The identifiers are optional, meaning that the developer only has to assign an identifier to a controller if they want to be able to manually invoke this method from code.
      */
@@ -29,5 +30,5 @@ export declare class _NSStoryboard extends _NSObject {
     /**
      * Controllers in Interface Builder have an optional identifier within the storyboard. That identifier is set from the inspector in Interface Builder. The identifiers are optional, meaning that the developer only has to assign an identifier to a controller if they want to be able to manually invoke this method from code. A creator can be specified for controller instantiation, giving the developer a chance to call an initalizer that takes an NSCoder and additional arguments. If the block returns nil, the view controller will be created using the standard initWithCoder: initializer.
      */
-    instantiateControllerWithIdentifier$creator$(identifier: _NSString, block: NobjcObject | null): NobjcObject;
+    instantiateControllerWithIdentifier$creator$(identifier: _NSString, block: ((arg0: _NSCoder) => NobjcObject) | null): NobjcObject;
 }

package/dist/AppKit/NSStoryboardSegue.d.ts

@@ -8,7 +8,7 @@ export declare class _NSStoryboardSegue extends _NSObject {
     /**
      * Convenience constructor for returning a segue that performs a handler block in its -perform method.
      */
-    static segueWithIdentifier$source$destination$performHandler$(identifier: _NSString, sourceController: NobjcObject, destinationController: NobjcObject, performHandler: NobjcObject): _NSStoryboardSegue;
+    static segueWithIdentifier$source$destination$performHandler$(identifier: _NSString, sourceController: NobjcObject, destinationController: NobjcObject, performHandler: () => void): _NSStoryboardSegue;
     /**
      * This is the designated initializer for NSStoryboardSegue. If a developer implements a NSStoryboardSegue subclass, they can override this method to perform init-time logic. When a segue starts, a new instance of NSStoryboardSegue will be created with this method, and then perform will subsequently be invoked.
      */

package/dist/AppKit/NSSwitch.d.ts

@@ -1,4 +1,5 @@
 import type { _NSControl } from "./NSControl.js";
+import type { NSControlStateValue } from "./NSControlStateValue.js";
 export declare class _NSSwitch extends _NSControl {
     static alloc(): _NSSwitch;
     static new(): _NSSwitch;
@@ -6,6 +7,6 @@ export declare class _NSSwitch extends _NSControl {
     /**
      * The current position of the switch. The values `NSControlStateValueOff` and `NSControlStateValueOn` indicate that the switch is in either the off or on position respectively. If the state property is set to any other value, it is interpreted as on. If set through the animator proxy, the switch animates to the new value.
      */
-    state(): number;
-    setState$(value: number): void;
+    state(): NSControlStateValue;
+    setState$(value: NSControlStateValue): void;
 }

package/dist/AppKit/NSTableView.d.ts

@@ -175,7 +175,7 @@ export declare class _NSTableView extends _NSControl {
     /**
      * Enumerates all available NSTableRowViews. This includes all views in the -visibleRect, however, it may also include ones that are "in flight" due to animations or other various attributes of the table.
      */
-    enumerateAvailableRowViewsUsingBlock$(handler: NobjcObject): void;
+    enumerateAvailableRowViewsUsingBlock$(handler: (rowView: _NSTableRowView, row: number) => void): void;
     /**
      * View Based TableView: Multiple row changes (inserts/deletes/moves/scrolling) can be animated simultaneously by surrounding calls around a beginUpdates/endUpdates pair. When changing rows, the prior state before -beginUpdates is the starting point assumed for all deletion and move calls. Calls are nestable. -selectedRowIndexes is properly maintained based on the series of inserts/deletes/moves. If a selected row is deleted, a selection changed notification will happen after endUpdates is called. It is not necessary to call beginUpdates/endUpdates if only one insertion/deletion/move is happening. Note that these methods should be called to reflect changes in your model; they do not make any underlying model changes. Cell Based TableView: Any row modifications must first be wrapped in a -beginUpdates/-endUpdates block -- this is required to properly maintain state and to allow animations to happen.
      */