objcjs-types 0.4.0 → 0.5.0

package/dist/AdServices/index.d.ts

@@ -3,3 +3,4 @@ export declare const AdServices: NobjcLibrary;
 import type { _AAAttribution } from "./AAAttribution.js";
 export declare const AAAttribution: typeof _AAAttribution;
 export type { _AAAttribution };
+export { AAAttributionErrorCode } from "./AAAttributionErrorCode.js";

package/dist/AdServices/index.js

@@ -3,3 +3,4 @@ import { NobjcLibrary } from "objc-js";
 import { _bindClass } from "../bind.js";
 export const AdServices = new NobjcLibrary("/System/Library/Frameworks/AdServices.framework/AdServices");
 export const AAAttribution = _bindClass(AdServices, "AAAttribution");
+export { AAAttributionErrorCode } from "./AAAttributionErrorCode.js";

package/dist/AppKit/NSAccessibilityCustomAction.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";
 export declare class _NSAccessibilityCustomAction extends _NSObject {
@@ -8,7 +7,7 @@ export declare class _NSAccessibilityCustomAction extends _NSObject {
     /**
      * Creates a custom action that performs the action via a block handler. The block should return whether the action was executed successfully or not. The return status will help accessibility clients know what to communicate back to the user.
      */
-    initWithName$handler$(name: _NSString, handler: NobjcObject | null): _NSAccessibilityCustomAction;
+    initWithName$handler$(name: _NSString, handler: (() => boolean) | null): _NSAccessibilityCustomAction;
     /**
      * Creates a custom action that performs the action via selector/target. The selector should have a signature that returns a BOOL for the success status of the execution.
      */
@@ -19,8 +18,8 @@ export declare class _NSAccessibilityCustomAction extends _NSObject {
     name(): _NSString;
     setName$(value: _NSString): void;
     /** The block that handles the execution of the action */
-    handler(): NobjcObject | null;
-    setHandler$(value: NobjcObject | null): void;
+    handler(): (() => boolean) | null;
+    setHandler$(value: (() => boolean) | null): void;
     /** The object that will perform the action via selector */
     target(): _NSObject | null;
     setTarget$(value: _NSObject | null): void;

package/dist/AppKit/NSAlert.d.ts

@@ -37,7 +37,7 @@ export declare class _NSAlert extends _NSObject {
     /**
      * Runs the alert modally as a sheet attached to the specified window. - Parameters: - sheetWindow: The window on which to display the sheet. - handler: The completion handler that gets called when the sheet’s modal session ends. This method uses the `NSWindow` sheet methods to display the alert. If the alert has an alert style of `NSCriticalAlertStyle`, it is presented as a critical sheet, which means that it can display on top of other sheets that might already be attached to the window. Otherwise, it is presented--or queued for presentation--as a standard sheet. Note that `-orderOut:` no longer needs to be called in the completion handler. If the alert isn’t don’t dismiss the alert, it will be done for you after the completion handler finishes.
      */
-    beginSheetModalForWindow$completionHandler$(sheetWindow: _NSWindow, handler: NobjcObject | null): void;
+    beginSheetModalForWindow$completionHandler$(sheetWindow: _NSWindow, handler: ((returnCode: number) => void) | null): void;
     /** @deprecated Use -beginSheetModalForWindow:completionHandler: instead */
     beginSheetModalForWindow$modalDelegate$didEndSelector$contextInfo$(window: _NSWindow, delegate: NobjcObject | null, didEndSelector: string | null, contextInfo: Uint8Array | null): void;
     /**

package/dist/AppKit/NSAnimationContext.d.ts

@@ -1,12 +1,11 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _CAMediaTimingFunction } from "../QuartzCore/CAMediaTimingFunction.js";
 export declare class _NSAnimationContext extends _NSObject {
     static alloc(): _NSAnimationContext;
     static new(): _NSAnimationContext;
     init(): _NSAnimationContext;
-    static runAnimationGroup$completionHandler$(changes: NobjcObject, completionHandler: NobjcObject | null): void;
-    static runAnimationGroup$(changes: NobjcObject): void;
+    static runAnimationGroup$completionHandler$(changes: (context: _NSAnimationContext) => void, completionHandler: (() => void) | null): void;
+    static runAnimationGroup$(changes: (context: _NSAnimationContext) => void): void;
     static beginGrouping(): void;
     static endGrouping(): void;
     static currentContext(): _NSAnimationContext;
@@ -14,8 +13,8 @@ export declare class _NSAnimationContext extends _NSObject {
     setDuration$(value: number): void;
     timingFunction(): _CAMediaTimingFunction;
     setTimingFunction$(value: _CAMediaTimingFunction): void;
-    completionHandler(): NobjcObject;
-    setCompletionHandler$(value: NobjcObject): void;
+    completionHandler(): () => void;
+    setCompletionHandler$(value: () => void): void;
     /**
      * Determine if animations are enabled or not. Using the -animator proxy will automatically set allowsImplicitAnimation to YES. When YES, other properties can implicitly animate along with the initially changed property. For instance, calling [[view animator] setFrame:frame] will allow subviews to also animate their frame positions. This is only applicable when layer backed on Mac OS 10.8 and later. The default value is NO.
      */

package/dist/AppKit/NSAppearance.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSBundle } from "../Foundation/NSBundle.js";
 import type { _NSCoder } from "../Foundation/NSCoder.js";
@@ -25,7 +24,7 @@ export declare class _NSAppearance extends _NSObject {
     /**
      * Make the receiver the active drawing appearance and perform the block. Saves and restores the previous current appearance.
      */
-    performAsCurrentDrawingAppearance$(block: NobjcObject): void;
+    performAsCurrentDrawingAppearance$(block: () => void): void;
     /**
      * Creates an NSAppearance by searching the specified bundle for a file with the specified name (without path extension). If bundle is nil, the main bundle is assumed.
      */

package/dist/AppKit/NSApplication.d.ts

@@ -17,6 +17,7 @@ import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSCoder } from "../Foundation/NSCoder.js";
 import type { _NSDate } from "../Foundation/NSDate.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSException } from "../Foundation/NSException.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { NSRange } from "../structs/NSRange.js";
@@ -80,7 +81,7 @@ export declare class _NSApplication extends _NSResponder {
     /**
      * Execute a block for each of the app's windows. Set `*stop = YES` if desired, to halt the enumeration early.
      */
-    enumerateWindowsWithOptions$usingBlock$(options: NSWindowListOptions, block: NobjcObject): void;
+    enumerateWindowsWithOptions$usingBlock$(options: NSWindowListOptions, block: (window: _NSWindow, stop: NobjcObject) => void): void;
     preventWindowOrdering(): void;
     setWindowsNeedUpdate$(needUpdate: boolean): void;
     updateWindows(): void;
@@ -181,7 +182,7 @@ export declare class _NSApplication extends _NSResponder {
     /**
      * The following message is the funnel point for all window restoration. The default behavior is to "demux:" decode the restoration class and send it the class method restoreWindowWithIdentifier:state:completionHandler: above. You should not call this method, but you may override it. Generally it is not necessary to override this method: it is better to set a restoration class on each window and implement the class method above. However, if some version of an app removes a class that is set as the restoration class of a window, you can override this method to detect that case and restore the window differently. Thus this method can be used to "patch up" old persistent state across changes in the class hierarchy. Unlike the class-level counterpart, this method returns BOOL. A YES return means that the window is recognized and that the completion handler will be called (or has already been called). A NO return means that the window was not recognized and the completion handler will not be called. If you override this and return YES, it is important that the completion handler be called, even if the window you pass to it is nil; otherwise the app will never finish restoring its state.
      */
-    restoreWindowWithIdentifier$state$completionHandler$(identifier: _NSString, state: _NSCoder, completionHandler: NobjcObject | null): boolean;
+    restoreWindowWithIdentifier$state$completionHandler$(identifier: _NSString, state: _NSCoder, completionHandler: ((arg0: _NSWindow, arg1: _NSError) => void) | null): boolean;
     /**
      * These methods allow the app to extend the period of state restoration. If the app crashes before state restoration is complete, then it may offer to discard restorable state on the next launch. If a window has some state that may take a long time to restore, such as a web page, you may use the following methods to extend the period of this crash protection beyond the default. Typically you would call -extendStateRestoration within your implementation of +restoreWindowWithIdentifier:state:completionHandler:. You would then call -completeStateRestoration some time after the window is fully restored (e.g. the web page has loaded). If the app crashes in the interim, then it may offer to discard restorable state on the next launch. These methods act as a counter. Each call to -extend increments the counter, and must be matched with a corresponding call to -complete which decrements it. When the counter reaches zero, the app is considered to have been fully restored, and any further calls are silently ignored. These methods are thread safe.
      */

package/dist/AppKit/NSApplicationDelegate.d.ts

@@ -58,7 +58,7 @@ export interface _NSApplicationDelegate {
     /**
      * This will be called on the main thread after the @c NSUserActivity object is available. Use the data you stored in the NSUserActivity object to re-create what the user was doing. @return @c YES to indicate that the activity was handled. Return @c NO (or leave it unimplemented) and AppKit will attempt to continue the user activity. You should create/fetch any restorable objects associated with the user activity, and pass them to the restorationHandler. They will then get the above `-restoreUserActivityState:` method invoked with the user activity. Invoking the @c restorationHandler is optional. It may be copied and invoked later, but must be invoked on the main thread. If this user activity was created automatically by having @c NSUbiquitousDocumentUserActivityType in a @c CFBundleDocumentTypes entry, AppKit can automatically restore the NSUserActivity on OS X if NO is returned, or this method is unimplemented. It will do so by creating a document of the appropriate type using the URL stored in the userInfo under the @c NSUserActivityDocumentURLKey. The document will have `-restoreUserActivity:` called on it.
      */
-    application$continueUserActivity$restorationHandler$?(application: _NSApplication, userActivity: _NSUserActivity, restorationHandler: NobjcObject): boolean;
+    application$continueUserActivity$restorationHandler$?(application: _NSApplication, userActivity: _NSUserActivity, restorationHandler: (restorableObjects: _NSArray) => void): boolean;
     /**
      * There are instances where continuing a @c NSUserActivity may fail. This will get called on the main thread if it does so. If it is unimplemented, AppKit will present the error.
      */

package/dist/AppKit/NSButton.d.ts

@@ -15,6 +15,7 @@ import type { NSBezelStyle } from "./NSBezelStyle.js";
 import type { NSButtonType } from "./NSButtonType.js";
 import type { NSCellImagePosition } from "./NSCellImagePosition.js";
 import type { NSControlBorderShape } from "./NSControlBorderShape.js";
+import type { NSControlStateValue } from "./NSControlStateValue.js";
 import type { NSEventModifierFlags } from "./NSEventModifierFlags.js";
 import type { NSImageScaling } from "./NSImageScaling.js";
 import type { NSTintProminence } from "./NSTintProminence.js";
@@ -171,8 +172,8 @@ export declare class _NSButton extends _NSControl {
     /**
      * The button's state. Buttons support the off and on states, and an additional mixed state depending on the value of the `allowsMixedState` property.
      */
-    state(): number;
-    setState$(value: number): void;
+    state(): NSControlStateValue;
+    setState$(value: NSControlStateValue): void;
     /**
      * A Boolean value that indicates whether the button allows a mixed state. If NO, the button has two states (on and off), and if YES, the button has three states (on, off, and mixed). The mixed state is commonly used with checkboxes and radio buttons to indicate a value which is partially on.
      */

package/dist/AppKit/NSCandidateListTouchBarItem.d.ts

@@ -4,6 +4,7 @@ import type { _NSTextView } from "./NSTextView.js";
 import type { _NSTouchBarItem } from "./NSTouchBarItem.js";
 import type { _NSView } from "./NSView.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSAttributedString } from "../Foundation/NSAttributedString.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { NSRange } from "../structs/NSRange.js";
 export declare class _NSCandidateListTouchBarItem extends _NSTouchBarItem {
@@ -41,8 +42,8 @@ export declare class _NSCandidateListTouchBarItem extends _NSTouchBarItem {
     /**
      * A block function for converting a candidate object into an NSAttributedString that will be displayed in the candidate bar. nil by default. Not required for displaying NSString, NSAttributedString, and NSTextCheckingResult candidates. In absence of NSFontAttributeName and NSForegroundColorAttributeName in the returned string, the standard bar appearance font and color are used instead of Helvetica 12.0 and +[NSColor blackColor].
      */
-    attributedStringForCandidate(): NobjcObject;
-    setAttributedStringForCandidate$(value: NobjcObject): void;
+    attributedStringForCandidate(): (arg0: NobjcObject, arg1: number) => _NSAttributedString;
+    setAttributedStringForCandidate$(value: (arg0: NobjcObject, arg1: number) => _NSAttributedString): void;
     /**
      * Returns an array of candidate objects previously set via -setCandidates:forSelectedRange:inString:view:
      */

package/dist/AppKit/NSCell.d.ts

@@ -24,6 +24,7 @@ import type { NSCellAttribute } from "./NSCellAttribute.js";
 import type { NSCellHitResult } from "./NSCellHitResult.js";
 import type { NSCellType } from "./NSCellType.js";
 import type { NSControlSize } from "./NSControlSize.js";
+import type { NSControlStateValue } from "./NSControlStateValue.js";
 import type { NSControlTint } from "./NSControlTint.js";
 import type { NSFocusRingType } from "./NSFocusRingType.js";
 import type { NSLineBreakMode } from "./NSLineBreakMode.js";
@@ -123,8 +124,8 @@ export declare class _NSCell extends _NSObject {
     setControlView$(value: _NSView | null): void;
     type(): NSCellType;
     setType$(value: NSCellType): void;
-    state(): number;
-    setState$(value: number): void;
+    state(): NSControlStateValue;
+    setState$(value: NSControlStateValue): void;
     /**
      * Target is weak for zeroing-weak compatible objects in apps linked on 10.10 or later. Otherwise the behavior of this property is 'assign'.
      */

package/dist/AppKit/NSCollectionLayoutGroup.d.ts

@@ -1,4 +1,4 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSCollectionLayoutEnvironment } from "./NSCollectionLayoutEnvironment.js";
 import type { _NSCollectionLayoutItem } from "./NSCollectionLayoutItem.js";
 import type { _NSCollectionLayoutSize } from "./NSCollectionLayoutSize.js";
 import type { _NSCollectionLayoutSpacing } from "./NSCollectionLayoutSpacing.js";
@@ -28,7 +28,7 @@ export declare class _NSCollectionLayoutGroup extends _NSCollectionLayoutItem {
     /**
      * Specifies a custom group with client-specified frames. During layout, the itemProvider will be called with the group's current geometry provided via the NSCollectionLayoutEnvironment supplied. The coordinate space for returned frames should be {0,0} relative to this group's geometry. Custom groups can be nested arbitrarily inside other groups.
      */
-    static customGroupWithLayoutSize$itemProvider$(layoutSize: _NSCollectionLayoutSize, itemProvider: NobjcObject): _NSCollectionLayoutGroup;
+    static customGroupWithLayoutSize$itemProvider$(layoutSize: _NSCollectionLayoutSize, itemProvider: (arg0: _NSCollectionLayoutEnvironment) => _NSArray): _NSCollectionLayoutGroup;
     /** for visual debugging; will print an ASCII art rendering to console */
     visualDescription(): _NSString;
     /** Supplementary items are "anchored" to the group's geometry. */

package/dist/AppKit/NSCollectionLayoutSection.d.ts

@@ -1,8 +1,9 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSCollectionLayoutEnvironment } from "./NSCollectionLayoutEnvironment.js";
 import type { _NSCollectionLayoutGroup } from "./NSCollectionLayoutGroup.js";
+import type { CGPoint } from "../structs/CGPoint.js";
 import type { NSDirectionalEdgeInsets } from "../structs/NSDirectionalEdgeInsets.js";
 import type { NSCollectionLayoutSectionOrthogonalScrollingBehavior } from "./NSCollectionLayoutSectionOrthogonalScrollingBehavior.js";
 export declare class _NSCollectionLayoutSection extends _NSObject {
@@ -28,8 +29,8 @@ export declare class _NSCollectionLayoutSection extends _NSObject {
     /**
      * Called for each layout pass to allow modification of item properties right before they are displayed.
      */
-    visibleItemsInvalidationHandler(): NobjcObject | null;
-    setVisibleItemsInvalidationHandler$(value: NobjcObject | null): void;
+    visibleItemsInvalidationHandler(): ((arg0: _NSArray, arg1: CGPoint, arg2: _NSCollectionLayoutEnvironment) => void) | null;
+    setVisibleItemsInvalidationHandler$(value: ((arg0: _NSArray, arg1: CGPoint, arg2: _NSCollectionLayoutEnvironment) => void) | null): void;
     /**
      * decoration views anchored to the section's geometry (e.g. background decoration view)
      */

package/dist/AppKit/NSCollectionView.d.ts

@@ -153,7 +153,7 @@ export declare class _NSCollectionView extends _NSView {
     /**
      * Animates multiple insert, delete, reload, and move operations as a group. You can use this method in cases where you want to make multiple changes to the collection view in one single animated operation, as opposed to in several separate animations. You might use this method to insert, delete, reload or move items or use it to change the layout parameters associated with one or more items. Use the block passed in the "updates" parameter to specify all of the operations you want to perform. Deletes are processed before inserts in batch operations. This means the indexes for the insertions are processed relative to the indexes of the state before the batch operation, and the indexes for the deletions are processed relative to the indexes of the state after all the insertions in the batch operation. Invocations of this method can be nested.
      */
-    performBatchUpdates$completionHandler$(updates: NobjcObject | null, completionHandler: NobjcObject | null): void;
+    performBatchUpdates$completionHandler$(updates: (() => void) | null, completionHandler: ((finished: boolean) => void) | null): void;
     /**
      * Toggles collapse of the CollectionView section that the sender resides in. Typically you'll wire this action from a section header view's "sectionCollapse" button. (See the NSCollectionViewSectionHeaderView protocol.)
      */

package/dist/AppKit/NSCollectionViewCompositionalLayout.d.ts

@@ -1,4 +1,4 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSCollectionLayoutEnvironment } from "./NSCollectionLayoutEnvironment.js";
 import type { _NSCollectionLayoutSection } from "./NSCollectionLayoutSection.js";
 import type { _NSCollectionViewCompositionalLayoutConfiguration } from "./NSCollectionViewCompositionalLayoutConfiguration.js";
 import type { _NSCollectionViewLayout } from "./NSCollectionViewLayout.js";
@@ -8,8 +8,8 @@ export declare class _NSCollectionViewCompositionalLayout extends _NSCollectionV
     init(): _NSCollectionViewCompositionalLayout;
     initWithSection$(section: _NSCollectionLayoutSection): _NSCollectionViewCompositionalLayout;
     initWithSection$configuration$(section: _NSCollectionLayoutSection, configuration: _NSCollectionViewCompositionalLayoutConfiguration): _NSCollectionViewCompositionalLayout;
-    initWithSectionProvider$(sectionProvider: NobjcObject): _NSCollectionViewCompositionalLayout;
-    initWithSectionProvider$configuration$(sectionProvider: NobjcObject, configuration: _NSCollectionViewCompositionalLayoutConfiguration): _NSCollectionViewCompositionalLayout;
+    initWithSectionProvider$(sectionProvider: (arg0: number, arg1: _NSCollectionLayoutEnvironment) => _NSCollectionLayoutSection): _NSCollectionViewCompositionalLayout;
+    initWithSectionProvider$configuration$(sectionProvider: (arg0: number, arg1: _NSCollectionLayoutEnvironment) => _NSCollectionLayoutSection, configuration: _NSCollectionViewCompositionalLayoutConfiguration): _NSCollectionViewCompositionalLayout;
     /**
      * Setting this property will invalidate the layout immediately to affect any changes Note: any changes made to properites directly will have no effect.
      */

package/dist/AppKit/NSCollectionViewDiffableDataSource.d.ts

@@ -1,9 +1,12 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSIndexPath } from "../Foundation/NSIndexPath.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSCollectionView } from "./NSCollectionView.js";
 import type { _NSCollectionViewDataSource } from "./NSCollectionViewDataSource.js";
+import type { _NSCollectionViewItem } from "./NSCollectionViewItem.js";
 import type { _NSDiffableDataSourceSnapshot } from "./NSDiffableDataSourceSnapshot.js";
+import type { _NSView } from "./NSView.js";
 export declare class _NSCollectionViewDiffableDataSource extends _NSObject {
     static alloc(): _NSCollectionViewDiffableDataSource;
     static new(): _NSCollectionViewDiffableDataSource;
@@ -11,7 +14,7 @@ export declare class _NSCollectionViewDiffableDataSource extends _NSObject {
     /**
      * Creates a new NSCollectionViewDiffableDataSource that automatically wires itself up as the given `collectionView`'s `dataSource`. The data source is initially empty. To put items into the `collectionView`, you must create an NSDiffableDataSourceSnapshot, add the desired section and item identifiers to the snapshot, and apply the snapshot to the diffable data source. The required `itemProvider` closure serves the same purpose as NSCollectionViewDataSource `-collectionView:itemForRepresentedObjectAtIndexPath:` method: Its job is to ask the `collectionView` to make an item of the desired type, configure its content and appearance to represent the model object specified by the given identifier and NSIndexPath, and return the configured item.
      */
-    initWithCollectionView$itemProvider$(collectionView: _NSCollectionView, itemProvider: NobjcObject): _NSCollectionViewDiffableDataSource;
+    initWithCollectionView$itemProvider$(collectionView: _NSCollectionView, itemProvider: (arg0: _NSCollectionView, arg1: _NSIndexPath, arg2: NobjcObject) => _NSCollectionViewItem): _NSCollectionViewDiffableDataSource;
     /**
      * Create a mutable "snapshot" of the data source state. This can be mutated via transactional updates which, when completed, can be "applied" back to a connected data source
      */
@@ -23,8 +26,8 @@ export declare class _NSCollectionViewDiffableDataSource extends _NSObject {
     /** IndexPath <-> item identifier conversion */
     itemIdentifierForIndexPath$(indexPath: _NSIndexPath): NobjcObject | null;
     indexPathForItemIdentifier$(identifier: NobjcObject): _NSIndexPath | null;
-    supplementaryViewProvider(): NobjcObject | null;
-    setSupplementaryViewProvider$(value: NobjcObject | null): void;
+    supplementaryViewProvider(): ((arg0: _NSCollectionView, arg1: _NSString, arg2: _NSIndexPath) => _NSView) | null;
+    setSupplementaryViewProvider$(value: ((arg0: _NSCollectionView, arg1: _NSString, arg2: _NSIndexPath) => _NSView) | null): void;
 }
 export interface _NSCollectionViewDiffableDataSource extends _NSCollectionViewDataSource {
 }

package/dist/AppKit/NSColor.d.ts

@@ -7,6 +7,7 @@ import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSAccessibilityColor } from "./NSAccessibilityColor.js";
+import type { _NSAppearance } from "./NSAppearance.js";
 import type { _NSColorSpace } from "./NSColorSpace.js";
 import type { _NSImage } from "./NSImage.js";
 import type { _NSPasteboard } from "./NSPasteboard.js";
@@ -53,7 +54,7 @@ export declare class _NSColor extends _NSObject {
     /**
      * Create a dynamic catalog color with a provider that is used to lazily resolve the exact color value. When methods are called on this color that need color component values, the provider is called with +NSAppearance.currentAppearance. The provider can use the appearance to return another color to be used for drawing. As much as possible, use the given appearance to make that decision, not other state. The `colorName` should be universally unique and equates to the identity of the color, if nil is provided a unique name will be generated. The name and the Aqua appearance color fallback will be encoded as part of the color. The decoded color is also able to 'join' to a color that gets registered with the same name and become dynamic again.
      */
-    static colorWithName$dynamicProvider$(colorName: _NSString | null, dynamicProvider: NobjcObject): _NSColor;
+    static colorWithName$dynamicProvider$(colorName: _NSString | null, dynamicProvider: (arg0: _NSAppearance) => _NSColor): _NSColor;
     /** Create component-based colors in various device color spaces. */
     static colorWithDeviceWhite$alpha$(white: number, alpha: number): _NSColor;
     static colorWithDeviceRed$green$blue$alpha$(red: number, green: number, blue: number, alpha: number): _NSColor;

package/dist/AppKit/NSColorSampler.d.ts

@@ -1,5 +1,5 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSColor } from "./NSColor.js";
 export declare class _NSColorSampler extends _NSObject {
     static alloc(): _NSColorSampler;
     static new(): _NSColorSampler;
@@ -7,5 +7,5 @@ export declare class _NSColorSampler extends _NSObject {
     /**
      * The primary method for NSColorSampler. Begins or attaches to an existing color sampling session which presents UI to the user for selecting a color from their screen. The handler will be called on the main thread when the user completes the session (either by selection, or cancelation). In the event of user-cancellation, `colorSelectionHandler` will be called with `nil`. The calling NSColorSampler instance is retained until the sampling session is completed.
      */
-    showSamplerWithSelectionHandler$(selectionHandler: NobjcObject | null): void;
+    showSamplerWithSelectionHandler$(selectionHandler: ((selectedColor: _NSColor) => void) | null): void;
 }

package/dist/AppKit/NSControlStateValue.d.ts

@@ -0,0 +1,6 @@
+export declare const NSControlStateValue: {
+    readonly Mixed: -1;
+    readonly Off: 0;
+    readonly On: 1;
+};
+export type NSControlStateValue = typeof NSControlStateValue[keyof typeof NSControlStateValue];

package/dist/AppKit/NSControlStateValue.js

@@ -0,0 +1,6 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const NSControlStateValue = {
+    Mixed: -1,
+    Off: 0,
+    On: 1,
+};

package/dist/AppKit/NSCursor.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSCoder } from "../Foundation/NSCoder.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSColor } from "./NSColor.js";
@@ -6,6 +5,7 @@ import type { _NSEvent } from "./NSEvent.js";
 import type { _NSImage } from "./NSImage.js";
 import type { CGPoint } from "../structs/CGPoint.js";
 import type { NSCursorFrameResizeDirections } from "./NSCursorFrameResizeDirections.js";
+import type { NSCursorFrameResizePosition } from "./NSCursorFrameResizePosition.js";
 import type { NSHorizontalDirections } from "./NSHorizontalDirections.js";
 import type { NSVerticalDirections } from "./NSVerticalDirections.js";
 export declare class _NSCursor extends _NSObject {
@@ -28,7 +28,7 @@ export declare class _NSCursor extends _NSObject {
     /**
      * Returns the cursor for resizing a rectangular frame from the specified edge or corner. - Parameters: - position: The position along the perimeter of a rectangular frame (its edges and corners) from which it’s resized. - directions: The directions in which a rectangular frame can be resized.
      */
-    static frameResizeCursorFromPosition$inDirections$(position: NobjcObject, directions: NSCursorFrameResizeDirections): _NSCursor;
+    static frameResizeCursorFromPosition$inDirections$(position: NSCursorFrameResizePosition, directions: NSCursorFrameResizeDirections): _NSCursor;
     /**
      * Returns the application’s current cursor. - Note: This isn’t necessarily the cursor that is currently being displayed, as the system may be showing the cursor for another running application.
      */

package/dist/AppKit/NSCursorFrameResizePosition.d.ts

@@ -0,0 +1,11 @@
+export declare const NSCursorFrameResizePosition: {
+    readonly Top: 1;
+    readonly Left: 2;
+    readonly Bottom: 4;
+    readonly Right: 8;
+    readonly TopLeft: 3;
+    readonly TopRight: 9;
+    readonly BottomLeft: 6;
+    readonly BottomRight: 12;
+};
+export type NSCursorFrameResizePosition = typeof NSCursorFrameResizePosition[keyof typeof NSCursorFrameResizePosition];

package/dist/AppKit/NSCursorFrameResizePosition.js

@@ -0,0 +1,11 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const NSCursorFrameResizePosition = {
+    Top: 1,
+    Left: 2,
+    Bottom: 4,
+    Right: 8,
+    TopLeft: 3,
+    TopRight: 9,
+    BottomLeft: 6,
+    BottomRight: 12,
+};

package/dist/AppKit/NSCustomImageRep.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSImageRep } from "./NSImageRep.js";
+import type { CGRect } from "../structs/CGRect.js";
 import type { CGSize } from "../structs/CGSize.js";
 export declare class _NSCustomImageRep extends _NSImageRep {
     static alloc(): _NSCustomImageRep;
@@ -8,9 +9,9 @@ export declare class _NSCustomImageRep extends _NSImageRep {
     /**
      * 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.
      */
-    initWithSize$flipped$drawingHandler$(size: CGSize, drawingHandlerShouldBeCalledWithFlippedContext: boolean, drawingHandler: NobjcObject): _NSCustomImageRep;
+    initWithSize$flipped$drawingHandler$(size: CGSize, drawingHandlerShouldBeCalledWithFlippedContext: boolean, drawingHandler: (dstRect: CGRect) => boolean): _NSCustomImageRep;
     initWithDrawSelector$delegate$(selector: string, delegate: NobjcObject): _NSCustomImageRep;
-    drawingHandler(): NobjcObject;
+    drawingHandler(): (arg0: CGRect) => boolean;
     drawSelector(): string | null;
     delegate(): NobjcObject | null;
 }

package/dist/AppKit/NSDocument.d.ts

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