import type { NobjcObject } from "objc-js";
import type { _NSAccessibility } from "./NSAccessibility.js";
import type { _NSAnimatablePropertyContainer } from "./NSAnimatablePropertyContainer.js";
import type { _NSAppearanceCustomization } from "./NSAppearanceCustomization.js";
import type { _NSButton } from "./NSButton.js";
import type { _NSButtonCell } from "./NSButtonCell.js";
import type { _NSColor } from "./NSColor.js";
import type { _NSColorSpace } from "./NSColorSpace.js";
import type { _NSDockTile } from "./NSDockTile.js";
import type { _NSDraggingSession } from "./NSDraggingSession.js";
import type { _NSDraggingSource } from "./NSDraggingSource.js";
import type { _NSEvent } from "./NSEvent.js";
import type { _NSGraphicsContext } from "./NSGraphicsContext.js";
import type { _NSImage } from "./NSImage.js";
import type { _NSMenu } from "./NSMenu.js";
import type { _NSMenuItemValidation } from "./NSMenuItemValidation.js";
import type { _NSPasteboard } from "./NSPasteboard.js";
import type { _NSResponder } from "./NSResponder.js";
import type { _NSScreen } from "./NSScreen.js";
import type { _NSText } from "./NSText.js";
import type { _NSTitlebarAccessoryViewController } from "./NSTitlebarAccessoryViewController.js";
import type { _NSToolbar } from "./NSToolbar.js";
import type { _NSUserInterfaceItemIdentification } from "./NSUserInterfaceItemIdentification.js";
import type { _NSUserInterfaceValidations } from "./NSUserInterfaceValidations.js";
import type { _NSView } from "./NSView.js";
import type { _NSViewController } from "./NSViewController.js";
import type { _NSWindowController } from "./NSWindowController.js";
import type { _NSWindowDelegate } from "./NSWindowDelegate.js";
import type { _NSWindowTab } from "./NSWindowTab.js";
import type { _NSWindowTabGroup } from "./NSWindowTabGroup.js";
import type { _NSArray } from "../Foundation/NSArray.js";
import type { _NSCloseCommand } from "../Foundation/NSCloseCommand.js";
import type { _NSData } from "../Foundation/NSData.js";
import type { _NSDate } from "../Foundation/NSDate.js";
import type { _NSDictionary } from "../Foundation/NSDictionary.js";
import type { _NSError } from "../Foundation/NSError.js";
import type { _NSObject } from "../Foundation/NSObject.js";
import type { _NSScriptCommand } from "../Foundation/NSScriptCommand.js";
import type { _NSString } from "../Foundation/NSString.js";
import type { _NSURL } from "../Foundation/NSURL.js";
import type { _CADisplayLink } from "../QuartzCore/CADisplayLink.js";
import type { CGPoint } from "../structs/CGPoint.js";
import type { CGRect } from "../structs/CGRect.js";
import type { CGSize } from "../structs/CGSize.js";
import type { NSBackingStoreType } from "./NSBackingStoreType.js";
import type { NSDisplayGamut } from "./NSDisplayGamut.js";
import type { NSEventModifierFlags } from "./NSEventModifierFlags.js";
import type { NSLayoutAttribute } from "./NSLayoutAttribute.js";
import type { NSLayoutConstraintOrientation } from "./NSLayoutConstraintOrientation.js";
import type { NSSelectionDirection } from "./NSSelectionDirection.js";
import type { NSTitlebarSeparatorStyle } from "./NSTitlebarSeparatorStyle.js";
import type { NSUserInterfaceLayoutDirection } from "./NSUserInterfaceLayoutDirection.js";
import type { NSWindowAnimationBehavior } from "./NSWindowAnimationBehavior.js";
import type { NSWindowBackingLocation } from "./NSWindowBackingLocation.js";
import type { NSWindowButton } from "./NSWindowButton.js";
import type { NSWindowCollectionBehavior } from "./NSWindowCollectionBehavior.js";
import type { NSWindowDepth } from "./NSWindowDepth.js";
import type { NSWindowNumberListOptions } from "./NSWindowNumberListOptions.js";
import type { NSWindowOcclusionState } from "./NSWindowOcclusionState.js";
import type { NSWindowOrderingMode } from "./NSWindowOrderingMode.js";
import type { NSWindowSharingType } from "./NSWindowSharingType.js";
import type { NSWindowStyleMask } from "./NSWindowStyleMask.js";
import type { NSWindowTabbingMode } from "./NSWindowTabbingMode.js";
import type { NSWindowTitleVisibility } from "./NSWindowTitleVisibility.js";
import type { NSWindowToolbarStyle } from "./NSWindowToolbarStyle.js";
import type { NSWindowUserTabbingPreference } from "./NSWindowUserTabbingPreference.js";
import type { NSRectEdge } from "../Foundation/NSRectEdge.js";
export declare class _NSWindow extends _NSResponder {
    static alloc(): _NSWindow;
    static new(): _NSWindow;
    init(): _NSWindow;
    static frameRectForContentRect$styleMask$(cRect: CGRect, style: NSWindowStyleMask): CGRect;
    static contentRectForFrameRect$styleMask$(fRect: CGRect, style: NSWindowStyleMask): CGRect;
    static minFrameWidthWithTitle$styleMask$(title: _NSString, style: NSWindowStyleMask): number;
    static removeFrameUsingName$(name: _NSString): void;
    static standardWindowButton$forStyleMask$(b: NSWindowButton, styleMask: NSWindowStyleMask): _NSButton | null;
    /**
     * `+windowNumbersWithOptions:` returns an autoreleased array of \c NSNumbers containing windowNumbers for all visible windows satisfying options. If no options are specified, only visible windows belonging to the calling application and on the active space are included. If options include \c NSWindowNumberListAllApplications, visible windows belonging to all applications are included. If options include \c NSWindowNumberListAllSpaces, visible windows on all spaces are included. Windows on the active space are returned in z-order. Examples: To get an array of windowNumbers visible on the current space and belonging to the calling application: `windowNumbers = [NSWindow windowNumbersWithOptions:0];` To get an array of windowNumbers visible on any space and belonging to any application: `windowNumbers = [NSWindow windowNumbersWithOptions:NSWindowNumberListAllApplications|NSWindowNumberListAllSpaces];` To get an array of windowNumbers visible on any space and belonging to the calling application: `windowNumbers = [NSWindow windowNumbersWithOptions:NSWindowNumberListAllSpaces];`
     */
    static windowNumbersWithOptions$(options: NSWindowNumberListOptions): _NSArray | null;
    /**
     * `+windowNumberAtPoint:belowWindowWithWindowNumber:` returns the number of the frontmost window that would be hit by a mouseDown at the screen location "point". "windowNum" can be specified to exclude a given window along with all windows above it, and may belong to any application. If no windows are to be excluded, specify 0 for "windowNum". The windowNumber returned may correspond to a window in another application.
     */
    static windowNumberAtPoint$belowWindowWithWindowNumber$(point: CGPoint, windowNumber: number): number;
    /**
     * Convenience method for creating an autoreleased titled window with the given contentViewController. A basic NSWindow with the following attributes is made: titled, closable, resizable, miniaturizable. The window's title is automatically bound to the contentViewController's title. The size of the window can easily be controlled by utilizing autolayout and applying size constraints to the view (or its subviews). The window has isReleasedWhenClosed set to NO, and it must be explicitly retained to keep the window instance alive. To have it automatically be freed when it is closed, do the following: [window retain] and [window setReleasedWhenClosed:YES].
     */
    static windowWithContentViewController$(contentViewController: _NSViewController): _NSWindow;
    /** @deprecated This method does not do anything and should not be called. */
    static menuChanged$(menu: _NSMenu): void;
    static defaultDepthLimit(): NSWindowDepth;
    /**
     * Allows automatic window tabbing when the value is \c YES. By default, this will be set to \c YES, but applications can explicitly opt out of all automatic tabbing by setting it to NO, and can still adopted explicit window tabbing, if desired.
     */
    static allowsAutomaticWindowTabbing(): boolean;
    static setAllowsAutomaticWindowTabbing$(value: boolean): void;
    /**
     * Returns the user's tabbing preference as set in System Preferences. This value should be queried anytime a new window is made to see if the user wants to automatically show it in tabs.
     */
    static userTabbingPreference(): NSWindowUserTabbingPreference;
    frameRectForContentRect$(contentRect: CGRect): CGRect;
    contentRectForFrameRect$(frameRect: CGRect): CGRect;
    initWithContentRect$styleMask$backing$defer$(contentRect: CGRect, style: NSWindowStyleMask, backingStoreType: NSBackingStoreType, flag: boolean): _NSWindow;
    initWithContentRect$styleMask$backing$defer$screen$(contentRect: CGRect, style: NSWindowStyleMask, backingStoreType: NSBackingStoreType, flag: boolean, screen: _NSScreen | null): _NSWindow;
    addTitlebarAccessoryViewController$(childViewController: _NSTitlebarAccessoryViewController): void;
    insertTitlebarAccessoryViewController$atIndex$(childViewController: _NSTitlebarAccessoryViewController, index: number): void;
    /**
     * NOTE: you can use this method, or removeFromParentViewController, which ever is easier.
     */
    removeTitlebarAccessoryViewControllerAtIndex$(index: number): void;
    setTitleWithRepresentedFilename$(filename: _NSString): void;
    fieldEditor$forObject$(createFlag: boolean, object_: NobjcObject | null): _NSText | null;
    endEditingFor$(object_: NobjcObject | null): void;
    constrainFrameRect$toScreen$(frameRect: CGRect, screen: _NSScreen | null): CGRect;
    setFrame$display$(frameRect: CGRect, flag: boolean): void;
    setContentSize$(size: CGSize): void;
    setFrameOrigin$(point: CGPoint): void;
    setFrameTopLeftPoint$(point: CGPoint): void;
    cascadeTopLeftFromPoint$(topLeftPoint: CGPoint): CGPoint;
    /**
     * Subclasses can override \c animationResizeTime: to control the total time for the frame change. \c newFrame is the rect passed into \c setFrame:display:animate:
     */
    animationResizeTime$(newFrame: CGRect): number;
    /**
     * \c setFrame:display:animate: is equivalent to \c setFrame:display: if the \c animateFlag is NO. If the \c animationFlag is YES, this method will perform a smooth resize of the window, where the total time for the resize is specified by \c -animationResizeTime:
     */
    setFrame$display$animate$(frameRect: CGRect, displayFlag: boolean, animateFlag: boolean): void;
    displayIfNeeded(): void;
    display(): void;
    update(): void;
    makeFirstResponder$(responder: _NSResponder | null): boolean;
    close(): void;
    miniaturize$(sender: NobjcObject | null): void;
    deminiaturize$(sender: NobjcObject | null): void;
    zoom$(sender: NobjcObject | null): void;
    tryToPerform$with$(action: string, object_: NobjcObject | null): boolean;
    validRequestorForSendType$returnType$(sendType: _NSString | null, returnType: _NSString | null): NobjcObject | null;
    /**
     * Indicates the thickness of a given border of the window. NSMinYEdge is the bottom edge of the window, while NSMaxYEdge is the top edge of the window. This method may throw an exception for values that don't apply to the current window styleMask; specifically, passing NSMaxYEdge for a non-textured window will always raise. The contentBorder does not include the titlebar or toolbar.
     */
    setContentBorderThickness$forEdge$(thickness: number, edge: NSRectEdge): void;
    contentBorderThicknessForEdge$(edge: NSRectEdge): number;
    setAutorecalculatesContentBorderThickness$forEdge$(flag: boolean, edge: NSRectEdge): void;
    autorecalculatesContentBorderThicknessForEdge$(edge: NSRectEdge): boolean;
    center(): void;
    makeKeyAndOrderFront$(sender: NobjcObject | null): void;
    orderFront$(sender: NobjcObject | null): void;
    orderBack$(sender: NobjcObject | null): void;
    orderOut$(sender: NobjcObject | null): void;
    orderWindow$relativeTo$(place: NSWindowOrderingMode, otherWin: number): void;
    orderFrontRegardless(): void;
    /**
     * Makes the window key and main if eligible, updating NSApplication's `-keyWindow` and `-mainWindow` properties.
     */
    makeKeyWindow(): void;
    /**
     * Makes the window main if eligible. Updates NSApplication's `-mainWindow` property.
     */
    makeMainWindow(): void;
    /**
     * Informs the window that it has become the key window. This method exists as an override point. Do not invoke directly. Instead, invoke `-makeKeyWindow`.
     */
    becomeKeyWindow(): void;
    /**
     * Informs the window that it has stopped being the key window. This method exists as an override point. Do not invoke directly. Windows automatically receive this message when deactivating or when another window has become key.
     */
    resignKeyWindow(): void;
    /**
     * Informs the window that it has become the main window. This method exists as an override point. Do not invoke directly. Instead, invoke `-makeMainWindow`.
     */
    becomeMainWindow(): void;
    /**
     * Informs the window that it has stopped being the main window. This method exists as an override point. Do not invoke directly. Windows automatically receive this message when deactivating or when another window has become main.
     */
    resignMainWindow(): void;
    /** Methods to convert window coordinates to screen coordinates */
    convertRectToScreen$(rect: CGRect): CGRect;
    convertRectFromScreen$(rect: CGRect): CGRect;
    convertPointToScreen$(point: CGPoint): CGPoint;
    convertPointFromScreen$(point: CGPoint): CGPoint;
    /** Methods to convert to/from a pixel integral backing store space */
    convertRectToBacking$(rect: CGRect): CGRect;
    convertRectFromBacking$(rect: CGRect): CGRect;
    convertPointToBacking$(point: CGPoint): CGPoint;
    convertPointFromBacking$(point: CGPoint): CGPoint;
    /**
     * Use `NSIntegralRectWithOptions()` to produce a backing store pixel aligned rectangle from the given input rectangle in window coordinates.
     */
    backingAlignedRect$options$(rect: CGRect, options: NobjcObject): CGRect;
    performClose$(sender: NobjcObject | null): void;
    performMiniaturize$(sender: NobjcObject | null): void;
    performZoom$(sender: NobjcObject | null): void;
    dataWithEPSInsideRect$(rect: CGRect): _NSData;
    dataWithPDFInsideRect$(rect: CGRect): _NSData;
    print$(sender: NobjcObject | null): void;
    setDynamicDepthLimit$(flag: boolean): void;
    invalidateShadow(): void;
    /**
     * `-toggleFullScreen:` enters or exits for full screen. A window must have \c NSWindowCollectionBehaviorFullScreenAuxiliary or \c NSWindowCollectionBehaviorFullScreenPrimary included in the \c collectionBehavior property; if it does not, this method may simply do nothing.
     */
    toggleFullScreen$(sender: NobjcObject | null): void;
    setFrameFromString$(string_: _NSString): void;
    saveFrameUsingName$(name: _NSString): void;
    /** Set force=YES to use setFrameUsingName on a non-resizable window */
    setFrameUsingName$force$(name: _NSString, force: boolean): boolean;
    setFrameUsingName$(name: _NSString): boolean;
    setFrameAutosaveName$(name: _NSString): boolean;
    /**
     * This API presents modal-sheets on this window. It replaces NSApp's -beginSheet:modalForWindow:modalDelegate:didEndSelector:contextInfo:. If the window already has a presented sheet, it will queue up sheets presented after that. Once the presented sheet is dismissed, the next queued sheet will be presented, and so forth. Critical sheets will skip this queuing process and be immediately presented on top of existing sheets. The presented sheet will be temporarily disabled and be able to be interacted with after the critical sheet is dismissed, and will then continue as normal. Critical sheets should only be used for time-critical or important events, when the presentation of the sheet needs to be guaranteed (Critical Alerts will automatically use this API).
     */
    beginSheet$completionHandler$(sheetWindow: _NSWindow, handler: ((returnCode: number) => void) | null): void;
    beginCriticalSheet$completionHandler$(sheetWindow: _NSWindow, handler: ((returnCode: number) => void) | null): void;
    endSheet$(sheetWindow: _NSWindow): void;
    endSheet$returnCode$(sheetWindow: _NSWindow, returnCode: number): void;
    standardWindowButton$(b: NSWindowButton): _NSButton | null;
    addChildWindow$ordered$(childWin: _NSWindow, place: NSWindowOrderingMode): void;
    removeChildWindow$(childWin: _NSWindow): void;
    /**
     * `-canRepresentDisplayGamut:` returns \c YES if the colorSpace of the receiving window, and the \c colorSpace of the screen containing that window, are capable of representing the given display gamut
     */
    canRepresentDisplayGamut$(displayGamut: NSDisplayGamut): boolean;
    /**
     * Call to start a drag (moving the window) in the Window Server process. In general, this can be done after a mouseDown event has come in and been examined by an application or view. The view may determine it wants to allow that portion of the window to start a window drag, and can hand off the work to the Window Server process by calling this method. This allows the window to participate in space switching, and other system features. Pass the original mouseDown event to the method. The method will return right away, and a mouseUp may not get sent.
     */
    performWindowDragWithEvent$(event: _NSEvent): void;
    selectNextKeyView$(sender: NobjcObject | null): void;
    selectPreviousKeyView$(sender: NobjcObject | null): void;
    selectKeyViewFollowingView$(view: _NSView): void;
    selectKeyViewPrecedingView$(view: _NSView): void;
    disableKeyEquivalentForDefaultButtonCell(): void;
    enableKeyEquivalentForDefaultButtonCell(): void;
    recalculateKeyViewLoop(): void;
    /** @deprecated This property has no effect */
    toggleToolbarShown$(sender: NobjcObject | null): void;
    /** @deprecated This property has no effect */
    runToolbarCustomizationPalette$(sender: NobjcObject | null): void;
    /**
     * Actions that can be called to perform various tabbed window behaviors. UI that is hooked up to these items can be automatically validated by calling `NSWindow`'s \c validateUserInterfaceItem.
     */
    selectNextTab$(sender: NobjcObject | null): void;
    selectPreviousTab$(sender: NobjcObject | null): void;
    moveTabToNewWindow$(sender: NobjcObject | null): void;
    mergeAllWindows$(sender: NobjcObject | null): void;
    toggleTabBar$(sender: NobjcObject | null): void;
    /**
     * Toggle the Tab Picker / Tab Overview UI which is invoked via "Show All Tabs". Performs the toggle in an animated fashion. Use `tabGroup.isOverviewVisible` to find out if it is visible or not at a given time.
     */
    toggleTabOverview$(sender: NobjcObject | null): void;
    /**
     * This is now a cover for `-[self.tabGroup addWindow:]`, which allows more precise placement.
     */
    addTabbedWindow$ordered$(window: _NSWindow, ordered: NSWindowOrderingMode): void;
    /**
     * @abstract Attempt to move window sharing (i.e. within a SharePlay session) from the receiver to another window. In response to this request, the user may choose to transfer sharing to the new window, or simply stop sharing the content. @param window A window that is replacing the reciever in representing the user's current activity. @param completionHandler A completion block that is called after the request finishes. @c error In the event of a failed transfer request, a non-nil error contains details about the failure.
     */
    transferWindowSharingToWindow$completionHandler$(window: _NSWindow, completionHandler: ((error: _NSError) => void) | null): void;
    /**
     * @abstract Request sharing of window. If there is an available ScreenCaptureKit sharing session, an alert will be presented asking the user to confirm the share @param window The window to share @param completionHandler A completion block that is called after the request finishes. @c error The error will be non-nil if the request does not result in a window being shared. The error will be NSUserCancelledError if there is no ScreenCaptureKit session, or if the user rejects the offer to share. If sharing fails for some other reason, the error will provide the details.
     */
    requestSharingOfWindow$completionHandler$(window: _NSWindow, completionHandler: ((error: _NSError) => void) | null): void;
    /**
     * @abstract Request sharing of window to be provided later. If there is an available ScreenCaptureKit sharing session, an alert will be presented asking the user to confirm the share. The delegate will be asked to provide the window to share via windowForSharingRequestFromWindow: @param image An image showing a preview of the window to share @param title The title to show in a confirmation dialog @param completionHandler A completion block that is called after the request finishes. @c error The error will be non-nil if the request does not result in a window being shared. The error will be NSUserCancelledError if there is no ScreenCaptureKit session, or if the user rejects the offer to share. If sharing fails for some other reason, the error will provide the details.
     */
    requestSharingOfWindowUsingPreview$title$completionHandler$(image: _NSImage, title: _NSString, completionHandler: ((error: _NSError) => void) | null): void;
    /**
     * Tracks events matching the supplied mask with the supplied tracking handler until the tracking handler explicitly terminates tracking. Each event is removed from the event queue then passed to the tracking handler. If a matching event does not exist in the event queue, then the main thread blocks in the specified runloop mode until an event of the requested type is received or the timeout expires. If the timeout expires, the tracking handler is called with a nil event. A negative timeout is interpreted as 0. Use \c NSEventDurationForever to never timeout. Tracking continues until `*stop` is set to \c YES. Calls to `-nextEventMatchingMask:…` are allowed inside the trackingHandler block. This method returns once tracking is terminated.
     */
    trackEventsMatchingMask$timeout$mode$handler$(mask: NobjcObject, timeout: number, mode: _NSString, trackingHandler: ((event: _NSEvent, stop: NobjcObject) => void) | null): void;
    nextEventMatchingMask$(mask: NobjcObject): _NSEvent | null;
    nextEventMatchingMask$untilDate$inMode$dequeue$(mask: NobjcObject, expiration: _NSDate | null, mode: _NSString, deqFlag: boolean): _NSEvent | null;
    discardEventsMatchingMask$beforeEvent$(mask: NobjcObject, lastEvent: _NSEvent | null): void;
    postEvent$atStart$(event: _NSEvent, flag: boolean): void;
    sendEvent$(event: _NSEvent): void;
    disableCursorRects(): void;
    enableCursorRects(): void;
    discardCursorRects(): void;
    invalidateCursorRectsForView$(view: _NSView): void;
    resetCursorRects(): void;
    /**
     * @deprecated Use -[NSWindow beginDraggingSessionWithItems:event:source:] instead.
     */
    beginDraggingSessionWithItems$event$source$(items: _NSArray, event: _NSEvent, source: _NSDraggingSource): _NSDraggingSession;
    /**
     * @deprecated Use -[NSWindow beginDraggingSessionWithItems:event:source:] instead.
     */
    dragImage$at$offset$event$pasteboard$source$slideBack$(image: _NSImage, baseLocation: CGPoint, initialOffset: CGSize, event: _NSEvent, pboard: _NSPasteboard, sourceObj: NobjcObject, slideFlag: boolean): void;
    registerForDraggedTypes$(newTypes: _NSArray): void;
    unregisterDraggedTypes(): void;
    /**
     * Returns a new display link whose callback will be invoked in-sync with the display the window is on. If the window is not on any display the callback will not be invoked.
     */
    displayLinkWithTarget$selector$(target: NobjcObject, selector: string): _CADisplayLink;
    /**
     * @deprecated This method shouldn’t be used as it doesn’t work in all drawing situations; instead, a subview should be used that implements the desired drawing behavior
     */
    cacheImageInRect$(rect: CGRect): void;
    /**
     * @deprecated This method shouldn’t be used as it doesn’t work in all drawing situations; instead, a subview should be used that implements the desired drawing behavior
     */
    restoreCachedImage(): void;
    /**
     * @deprecated This method shouldn’t be used as it doesn’t work in all drawing situations; instead, a subview should be used that implements the desired drawing behavior
     */
    discardCachedImage(): void;
    /**
     * gState is unused and should not be called.
     * @deprecated This method is unused and should not be called.
     */
    gState(): number;
    /**
     * The base/screen conversion methods are deprecated in 10.7 and later. Please use one of convertRectToScreen:, convertRectFromScreen:, convertPointToScreen:, or convertPointFromScreen: instead.
     * @deprecated Use -convertRectToScreen: or -convertPointToScreen: instead
     */
    convertBaseToScreen$(point: CGPoint): CGPoint;
    /** @deprecated Use -convertRectFromScreen or -convertPointFromScreen: instead */
    convertScreenToBase$(point: CGPoint): CGPoint;
    /**
     * This method is deprecated and should not be used by applications targeting Mac OS X 10.7 or later. The implementation of this method will always return 1.0. Please use -convertRectToBacking: and -backingScaleFactor instead.
     * @deprecated Use -convertRectToBacking: and -backingScaleFactor instead
     */
    userSpaceScaleFactor(): number;
    /** @deprecated This method does not do anything and should not be called. */
    useOptimizedDrawing$(flag: boolean): void;
    /**
     * canStoreColor has not been needed or used in a while and is deprecated.
     * @deprecated This method does not do anything and should not be called.
     */
    canStoreColor(): boolean;
    /**
     * @deprecated Use +[NSAnimationContext runAnimationGroup:completionHandler:] to perform atomic updates across runloop invocations.
     */
    disableFlushWindow(): void;
    /**
     * @deprecated Use +[NSAnimationContext runAnimationGroup:completionHandler:] to perform atomic updates across runloop invocations.
     */
    enableFlushWindow(): void;
    /**
     * @deprecated Allow AppKit's automatic deferred display mechanism to take care of flushing any graphics contexts as needed.
     */
    flushWindow(): void;
    /**
     * @deprecated Allow AppKit's automatic deferred display mechanism to take care of flushing any graphics contexts as needed.
     */
    flushWindowIfNeeded(): void;
    /** @deprecated This method should not be used. */
    initWithWindowRef$(windowRef: Uint8Array): _NSWindow | null;
    /** @deprecated This method does not do anything and should not be called. */
    disableScreenUpdatesUntilFlush(): void;
    updateConstraintsIfNeeded(): void;
    layoutIfNeeded(): void;
    /**
     * If changes in the interior content (and thus, constraints) of a window force the window to get smaller or larger, what part of the window stays motionless? By default, the top left corner of the window is anchored in place.
     */
    anchorAttributeForOrientation$(orientation: NSLayoutConstraintOrientation): NSLayoutAttribute;
    setAnchorAttribute$forOrientation$(attr: NSLayoutAttribute, orientation: NSLayoutConstraintOrientation): void;
    /**
     * This draws a visual representation of the given constraints in the receiver window. It's a nice way to understand exactly what a collection of constraints specifies.
     */
    visualizeConstraints$(constraints: _NSArray | null): void;
    /**
     * Key value coding compliant set-accessors for the like-named attributes declared in Cocoa's definition of the Standard Suite. Attributes that don't have corresponding methods here are read-only.
     */
    setIsMiniaturized$(flag: boolean): void;
    setIsVisible$(flag: boolean): void;
    setIsZoomed$(flag: boolean): void;
    /**
     * Handlers for script commands declared in Cocoa's definition of the Standard suite.
     */
    handleCloseScriptCommand$(command: _NSCloseCommand): NobjcObject | null;
    handlePrintScriptCommand$(command: _NSScriptCommand): NobjcObject | null;
    handleSaveScriptCommand$(command: _NSScriptCommand): NobjcObject | null;
    /**
     * Disable or enable snapshot restoration. While snapshot restoration is disabled, the window will not be snapshotted for restorable state.
     */
    disableSnapshotRestoration(): void;
    enableSnapshotRestoration(): void;
    title(): _NSString;
    setTitle$(value: _NSString): void;
    /**
     * Secondary text that may be displayed adjacent to or below the primary title depending on the configuration of the window. A value of empty string will remove the subtitle from the window layout.
     */
    subtitle(): _NSString;
    setSubtitle$(value: _NSString): void;
    /** Default value is NSWindowTitleVisible */
    titleVisibility(): NSWindowTitleVisibility;
    setTitleVisibility$(value: NSWindowTitleVisibility): void;
    /**
     * When \c YES, the titlebar doesn't draw its background, allowing all buttons to show through, and "click through" to happen. In general, this is only useful when \c NSFullSizeContentViewWindowMask is set.
     */
    titlebarAppearsTransparent(): boolean;
    setTitlebarAppearsTransparent$(value: boolean): void;
    /**
     * Specifies how the titlebar area of the window should appear when the window displays an NSToolbar
     */
    toolbarStyle(): NSWindowToolbarStyle;
    setToolbarStyle$(value: NSWindowToolbarStyle): void;
    /**
     * Secondary text that may be displayed adjacent to or below the primary title depending on the configuration of the window. A value of empty string will remove the subtitle from the window layout. / @property (copy) NSString *subtitle API_AVAILABLE(macos(11.0)); /// See the enum values for how this property works. @property NSWindowTitleVisibility titleVisibility API_AVAILABLE(macos(10.10)); // Default value is NSWindowTitleVisible /// When \c YES, the titlebar doesn't draw its background, allowing all buttons to show through, and "click through" to happen. In general, this is only useful when \c NSFullSizeContentViewWindowMask is set. @property BOOL titlebarAppearsTransparent API_AVAILABLE(macos(10.10)); /// Specifies how the titlebar area of the window should appear when the window displays an NSToolbar @property NSWindowToolbarStyle toolbarStyle API_AVAILABLE(macos(11.0)); /// The \c contentLayoutRect will return the area inside the window that is for non-obscured content. Typically, this is the same thing as the `contentView`'s frame. However, for windows with the \c NSFullSizeContentViewWindowMask set, there needs to be a way to determine the portion that is not under the toolbar. The \c contentLayoutRect returns the portion of the layout that is not obscured under the toolbar. \c contentLayoutRect is in window coordinates. It is KVO compliant.
     */
    contentLayoutRect(): CGRect;
    /**
     * \c contentLayoutGuide is a corollary to \c contentLayoutRect. It can be used by autolayout constraints to automatically bind to the \c contentLayoutRect.
     */
    contentLayoutGuide(): NobjcObject;
    /**
     * The following methods allow you to add accessory views to the titlebar/toolbar area of a window. See NSTitlebarAccessoryViewController for more details.
     */
    titlebarAccessoryViewControllers(): _NSArray;
    setTitlebarAccessoryViewControllers$(value: _NSArray): void;
    /**
     * If url is not nil and its path is not empty, the window will show a document icon in the titlebar. If the url represents a filename or other resource with a known icon, that icon will be used as the document icon. Otherwise the default document icon will be used. The icon can be customized using `-[[NSWindow standardWindowButton:NSWindowDocumentIconButton] setImage:customImage]`. If url is not nil and its path is not empty, the window will have a pop-up menu which can be shown via command-click on the area containing the document icon and title. By default, this menu will display the path components of the url. The presence and contents of this menu can be controlled by the delegate method `-[window:shouldPopUpDocumentPathMenu:]` If the url is nil or has an empty path, the window will not show a document icon and will not have a pop-up menu available via command-click.
     */
    representedURL(): _NSURL;
    setRepresentedURL$(value: _NSURL): void;
    representedFilename(): _NSString;
    setRepresentedFilename$(value: _NSString): void;
    excludedFromWindowsMenu(): boolean;
    setExcludedFromWindowsMenu$(value: boolean): void;
    contentView(): _NSView | null;
    setContentView$(value: _NSView | null): void;
    delegate(): _NSWindowDelegate | null;
    setDelegate$(value: _NSWindowDelegate | null): void;
    windowNumber(): number;
    /**
     * @note The styleMask can only be set on macOS 10.6 and later. Valid \c styleMask settings have the same restrictions as the \c styleMask passed to `-initWithContentRect:styleMask:backing:defer:`. Some \c styleMask changes will cause the view hierarchy to be rebuilt, since there is a different subclass for the top level view of a borderless window than for the top level view of a titled window.
     */
    styleMask(): NSWindowStyleMask;
    setStyleMask$(value: NSWindowStyleMask): void;
    /**
     * @abstract The frame to use when cascading or sizing a new window based on the receiver's position or size. This may be different from `frame` when the receiver is positioned by the system.
     */
    cascadingReferenceFrame(): CGRect;
    frame(): CGRect;
    inLiveResize(): boolean;
    resizeIncrements(): CGSize;
    setResizeIncrements$(value: CGSize): void;
    aspectRatio(): CGSize;
    setAspectRatio$(value: CGSize): void;
    contentResizeIncrements(): CGSize;
    setContentResizeIncrements$(value: CGSize): void;
    contentAspectRatio(): CGSize;
    setContentAspectRatio$(value: CGSize): void;
    viewsNeedDisplay(): boolean;
    setViewsNeedDisplay$(value: boolean): void;
    preservesContentDuringLiveResize(): boolean;
    setPreservesContentDuringLiveResize$(value: boolean): void;
    /** firstResponder is Key Value Observing (KVO) compliant. */
    firstResponder(): _NSResponder | null;
    resizeFlags(): NSEventModifierFlags;
    releasedWhenClosed(): boolean;
    setReleasedWhenClosed$(value: boolean): void;
    zoomed(): boolean;
    miniaturized(): boolean;
    backgroundColor(): _NSColor;
    setBackgroundColor$(value: _NSColor): void;
    /**
     * Calling -setMovable with a flag of NO will disable server-side dragging of the window via titlebar or background. -setMovableByWindowBackground:YES is ignored on a window that returns NO from -isMovable. When a window returns NO for -isMovable, it can be assigned to a different space with its relative screen position preserved. Note that a resizable window may still be resized, and the window frame may be changed programmatically. Applications may choose to enable application-controlled window dragging after disabling server-side dragging (perhaps to achieve snapping or pinning) by handling the mouseDown/mouseDragged/mouseUp sequence in -sendEvent: in an NSWindow subclass. Note that a non movable window will also not be moved (or resized) by the system in response to a display reconfiguration.
     */
    movable(): boolean;
    setMovable$(value: boolean): void;
    movableByWindowBackground(): boolean;
    setMovableByWindowBackground$(value: boolean): void;
    hidesOnDeactivate(): boolean;
    setHidesOnDeactivate$(value: boolean): void;
    /**
     * Indicates whether a window can be hidden during `-[NSApplication hide:]`. Default is \c YES.
     */
    canHide(): boolean;
    setCanHide$(value: boolean): void;
    miniwindowImage(): _NSImage | null;
    setMiniwindowImage$(value: _NSImage | null): void;
    miniwindowTitle(): _NSString;
    setMiniwindowTitle$(value: _NSString): void;
    dockTile(): _NSDockTile;
    documentEdited(): boolean;
    setDocumentEdited$(value: boolean): void;
    visible(): boolean;
    keyWindow(): boolean;
    mainWindow(): boolean;
    canBecomeKeyWindow(): boolean;
    canBecomeMainWindow(): boolean;
    worksWhenModal(): boolean;
    /**
     * A Boolean value that indicates whether or not to prevent application termination when the receiving window is presented modally. The value of this property is `YES` if the window should prevent application termination when modal; otherwise, `NO`. The default value is `YES`. However, note that some window subclasses and some windows created indirectly (like those created by UI frameworks like AppKit and SwiftUI), may have different default values. For example, the Open panel and toolbar customization sheets should not prevent application termination, so those windows have `preventsApplicationTerminationWhenModal` set to `NO`. Some `NSAlert`s, like those that are simply informational, have windows that do not prevent application termination by default. Setting this property overrides the default behavior.
     */
    preventsApplicationTerminationWhenModal(): boolean;
    setPreventsApplicationTerminationWhenModal$(value: boolean): void;
    /**
     * Returns the scale factor representing the number of backing store pixels corresponding to each linear unit in window space on this \c NSWindow. This method is provided for rare cases when the explicit scale factor is needed. Please use `-convert*ToBacking:` methods whenever possible.
     */
    backingScaleFactor(): number;
    /**
     * Default is \c NO. Set to \c YES to allow a window to display tooltips even when the application is in the background. Note that, enabling tooltips in an inactive application will cause the app to do work any time the mouse passes over the window. This can degrade system performance. Returns \c YES if this window displays tooltips even when the application is in the background. To configure this setting you should call `-setAllowsToolTipsWhenApplicationIsInactive:` instead of overriding `-allowsToolTipsWhenApplicationIsInactive`.
     */
    allowsToolTipsWhenApplicationIsInactive(): boolean;
    setAllowsToolTipsWhenApplicationIsInactive$(value: boolean): void;
    backingType(): NSBackingStoreType;
    setBackingType$(value: NSBackingStoreType): void;
    level(): number;
    setLevel$(value: number): void;
    depthLimit(): NSWindowDepth;
    setDepthLimit$(value: NSWindowDepth): void;
    hasDynamicDepthLimit(): boolean;
    /**
     * The screen property returns the best screen for the window. If the window only intersects one screen, it returns that screen. If it intersects more than one screen, then it resolves the tie through based on what space it is mostly on. It may return nil if there are no available screens, or it is completely off screen.
     */
    screen(): _NSScreen | null;
    deepestScreen(): _NSScreen | null;
    hasShadow(): boolean;
    setHasShadow$(value: boolean): void;
    alphaValue(): number;
    setAlphaValue$(value: number): void;
    opaque(): boolean;
    setOpaque$(value: boolean): void;
    /**
     * `-setSharingType:` specifies whether the window content can be read from another process. The default sharing type is \c NSWindowSharingReadOnly, which means other processes can read the window content (eg. for window capture) but cannot modify it. If you set your window sharing type to \c NSWindowSharingNone, so that the content cannot be captured, your window will also not be able to participate in a number of system services, so this setting should be used with caution.
     */
    sharingType(): NSWindowSharingType;
    setSharingType$(value: NSWindowSharingType): void;
    /**
     * Controls whether threading of view drawing should be enabled for this window. Defaults to \c YES. When this is set to \c YES, AppKit's view system is allowed to perform `-drawRect:` activity for the window's views on threads other than the main thread, for views that have `canDrawConcurrently == YES`. When this is set to \c NO, the window's views will be drawn serially as on 10.5 and earlier, even though some of the views may have `canDrawConcurrently == YES`.
     */
    allowsConcurrentViewDrawing(): boolean;
    setAllowsConcurrentViewDrawing$(value: boolean): void;
    displaysWhenScreenProfileChanges(): boolean;
    setDisplaysWhenScreenProfileChanges$(value: boolean): void;
    /**
     * This API controls whether the receiver is permitted onscreen before the user has logged in. This property is off by default. Alert panels and windows presented by input managers are examples of windows which should have this property set.
     */
    canBecomeVisibleWithoutLogin(): boolean;
    setCanBecomeVisibleWithoutLogin$(value: boolean): void;
    collectionBehavior(): NSWindowCollectionBehavior;
    setCollectionBehavior$(value: NSWindowCollectionBehavior): void;
    /**
     * Provides for per-window control over automatic orderFront/orderOut animation behaviors added in 10.7. Can be set to \c NSWindowAnimationBehaviorNone to disable Appkit's automatic animations for a given window, or to one of the other non-Default \c NSWindowAnimationBehavior values to override AppKit's automatic inference of appropriate animation behavior based on the window's apparent type.
     */
    animationBehavior(): NSWindowAnimationBehavior;
    setAnimationBehavior$(value: NSWindowAnimationBehavior): void;
    /**
     * Returns \c YES if this window is associated with the active space. For visible windows, this API indicates whether the window is currently visible on the active space. For offscreen windows, it indicates whether ordering the window onscreen would make it bring it onto the active space
     */
    onActiveSpace(): boolean;
    stringWithSavedFrame(): _NSString;
    frameAutosaveName(): _NSString;
    /**
     * NOTE: minSize/contentMinSize and maxSize/contentMaxSize are ignored when using autolayout.
     */
    minSize(): CGSize;
    setMinSize$(value: CGSize): void;
    maxSize(): CGSize;
    setMaxSize$(value: CGSize): void;
    contentMinSize(): CGSize;
    setContentMinSize$(value: CGSize): void;
    contentMaxSize(): CGSize;
    setContentMaxSize$(value: CGSize): void;
    /**
     * These are the min and max values for a full screen tiled window. In general, one should not need to explicitly set the min/maxFullScreenContentSize. If an application does not change its window content upon entering full screen, then the normal auto layout min and max size will be sufficient, and one should not set these values. If an application does significantly rework the UI in full screen, then it may be necessary to set a min/maxFullScreenContentSize. This size is what is used to determine if a window can fit when it is in full screen in a tile. This property may be used even if the window does not support full screen, but are implicitly opted into supporting a full screen tile based on resizing behavior and window properties (see the collectionBehavior property). By default, the system uses auto layout to determine the min and max sizes. If auto layout is not used, contentMinSize and contentMaxSize are queried.
     */
    minFullScreenContentSize(): CGSize;
    setMinFullScreenContentSize$(value: CGSize): void;
    maxFullScreenContentSize(): CGSize;
    setMaxFullScreenContentSize$(value: CGSize): void;
    deviceDescription(): _NSDictionary;
    windowController(): _NSWindowController | null;
    setWindowController$(value: _NSWindowController | null): void;
    /**
     * An ordered array of the sheets on the window. This consists of the presented sheets in top-to-bottom order, followed by queued sheets in the order they were queued. This does not include nested/sub-sheets.
     */
    sheets(): _NSArray;
    /**
     * Returns the top-most sheet if there is one or more sheets, or nil if there is no sheet.
     */
    attachedSheet(): _NSWindow | null;
    sheet(): boolean;
    /**
     * Returns the window that the sheet is directly attached to. This is based on the logical attachment of the sheet, not visual attachment. This relationship exists starting when the sheet is begun (using \c NSApplication's `-beginSheet:modalForWindow:modalDelegate:didEndSelector:contextInfo: or NSWindow's -beginSheet:completionHandler:`), and ending once it is ordered out. Returns nil if the window is not a sheet or has no sheet parent.
     */
    sheetParent(): _NSWindow;
    childWindows(): _NSArray | null;
    parentWindow(): _NSWindow | null;
    setParentWindow$(value: _NSWindow | null): void;
    /**
     * If set, the receiver will inherit the appearance of that object, as well as use KVO to observe its effectiveAppearance for changes. Typically this is used for child windows that are shown from a parent window or specific view. Defaults to NSApp.
     */
    appearanceSource(): _NSObject;
    setAppearanceSource$(value: _NSObject): void;
    colorSpace(): _NSColorSpace;
    setColorSpace$(value: _NSColorSpace): void;
    occlusionState(): NSWindowOcclusionState;
    /**
     * Specifies the style of separator displayed between the window's titlebar and content. The default value is NSTitlebarSeparatorStyleAutomatic. Changing this value will override any preference made by `NSSplitViewItem`.
     */
    titlebarSeparatorStyle(): NSTitlebarSeparatorStyle;
    setTitlebarSeparatorStyle$(value: NSTitlebarSeparatorStyle): void;
    /**
     * The main content view controller for the window. This provides the contentView of the window. Assigning this value will remove the existing contentView and will make the contentViewController.view the main contentView for the window. The default value is nil. The contentViewController only controls the contentView, and not the title of the window. The window title can easily be bound to the contentViewController with the following: [window bind:NSTitleBinding toObject:contentViewController withKeyPath:@"title" options:nil]. Setting the contentViewController will cause the window to resize based on the current size of the contentViewController. Autolayout should be used to restrict the size of the window. The value of the contentViewController is encoded in the NIB. Directly assigning a contentView will clear out the contentViewController.
     */
    contentViewController(): _NSViewController;
    setContentViewController$(value: _NSViewController): void;
    initialFirstResponder(): _NSView | null;
    setInitialFirstResponder$(value: _NSView | null): void;
    keyViewSelectionDirection(): NSSelectionDirection;
    defaultButtonCell(): _NSButtonCell | null;
    setDefaultButtonCell$(value: _NSButtonCell | null): void;
    autorecalculatesKeyViewLoop(): boolean;
    setAutorecalculatesKeyViewLoop$(value: boolean): void;
    /** @deprecated This property has no effect */
    toolbar(): _NSToolbar | null;
    setToolbar$(value: _NSToolbar | null): void;
    /** @deprecated This property has no effect */
    showsToolbarButton(): boolean;
    setShowsToolbarButton$(value: boolean): void;
    /**
     * Get and set the tabbing mode for this window. This should be set before a window is shown. The default value is \c NSWindowTabbingModeAutomatic. When the value is \c NSWindowTabbingModeAutomatic, the system will look at the \c userTabbingPreference and automatically tab windows together based on the tabbingIdentifier, when it is appropriate to do so.
     */
    tabbingMode(): NSWindowTabbingMode;
    setTabbingMode$(value: NSWindowTabbingMode): void;
    /**
     * Windows with the same \c tabbingIdentifier will have the ability to be tabbed together when a window is being shown. This allows aggregation of similar windows. By default, the \c tabbingIdentifier will be generated based on inherent window properties, such as the window class name, the delegate class name, the window controller class name, and some additional state. Windows can be explicitly made to group together by using the same \c tabbingIdentifier.
     */
    tabbingIdentifier(): _NSString;
    setTabbingIdentifier$(value: _NSString): void;
    /**
     * This is now a cover for `self.tabGroup.windows`, but will return nil if the window is not showing a tab bar.
     */
    tabbedWindows(): _NSArray;
    /**
     * Access the properties for this window when it is a tabbed window environment. See the \c NSWindowTab header and comments for more information.
     */
    tab(): _NSWindowTab;
    /**
     * Represents a tab group of windows. This \c tabGroup is lazily created on demand.
     */
    tabGroup(): _NSWindowTabGroup;
    /**
     * @abstract Indicates whether the receiver is the subject of an active SharePlay sharing session.
     */
    hasActiveWindowSharingSession(): boolean;
    /**
     * Retrieve the layout direction of the window titlebar: this includes the standard window buttons (close/minimize/maximize buttons) and the title for this window. In general, this will return "right to left" (RTL) if the primary system language is RTL. The layout direction may be RTL even in applications that do not have a RTL language localization. This value should be utilized if an application uses titlebarAppearsTransparent and places controls underneath the titlebar.
     */
    windowTitlebarLayoutDirection(): NSUserInterfaceLayoutDirection;
    currentEvent(): _NSEvent | null;
    acceptsMouseMovedEvents(): boolean;
    setAcceptsMouseMovedEvents$(value: boolean): void;
    ignoresMouseEvents(): boolean;
    setIgnoresMouseEvents$(value: boolean): void;
    mouseLocationOutsideOfEventStream(): CGPoint;
    areCursorRectsEnabled(): boolean;
    /**
     * @deprecated Use +[NSAnimationContext runAnimationGroup:completionHandler:] to perform atomic updates across runloop invocations.
     */
    flushWindowDisabled(): boolean;
    /**
     * @deprecated Use +[NSAnimationContext runAnimationGroup:completionHandler:] to temporarily prevent AppKit's automatic deferred display mechanism from drawing.
     */
    autodisplay(): boolean;
    setAutodisplay$(value: boolean): void;
    /**
     * Returns NSGraphicsContext used to render the receiver's content on the screen for the calling thread.
     * @deprecated Add instances of NSView to display content in a window.
     */
    graphicsContext(): _NSGraphicsContext;
    /** @deprecated This property does not do anything and should not be used */
    oneShot(): boolean;
    setOneShot$(value: boolean): void;
    /** @deprecated This property does not do anything and should not be used */
    preferredBackingLocation(): NSWindowBackingLocation;
    setPreferredBackingLocation$(value: NSWindowBackingLocation): void;
    /** @deprecated This property does not do anything and should not be used */
    backingLocation(): NSWindowBackingLocation;
    /** @deprecated This property does not do anything and should not be used. */
    showsResizeIndicator(): boolean;
    setShowsResizeIndicator$(value: boolean): void;
    /** @deprecated This method should not be used. */
    windowRef(): NobjcObject;
    /** @deprecated Drawers are deprecated; consider using NSSplitViewController */
    drawers(): _NSArray;
    /**
     * Key value coding (KVC) compliant get-accessors for the same-named attributes declared in Cocoa's definition of the Standard Suite. The -isMiniaturized, -isVisible, and -isZoomed methods, declared in NSWindow.h, also serve as KVC accessors.
     */
    hasCloseBox(): boolean;
    hasTitleBar(): boolean;
    floatingPanel(): boolean;
    miniaturizable(): boolean;
    modalPanel(): boolean;
    resizable(): boolean;
    zoomable(): boolean;
    orderedIndex(): number;
    setOrderedIndex$(value: number): void;
    /**
     * Determines whether the window should be restored on relaunch. By default, windows with NSTitledWindowMask set in the styleMask are restorable, and windows without it set are not.
     */
    restorable(): boolean;
    setRestorable$(value: boolean): void;
    /**
     * Set and get the class that is responsible for restoring the window. The default implementation of -[NSWindowController setDocument:] will set the restoration class of the window to the shared NSDocumentController's class.
     */
    restorationClass(): NobjcObject;
    setRestorationClass$(value: NobjcObject): void;
}
export interface _NSWindow extends _NSAnimatablePropertyContainer, _NSMenuItemValidation, _NSUserInterfaceValidations, _NSUserInterfaceItemIdentification, _NSAppearanceCustomization, _NSAccessibility {
}
