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";
import type { _NSCopying } from "../Foundation/NSCopying.js";
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";
import type { _NSPasteboardReading } from "./NSPasteboardReading.js";
import type { _NSPasteboardWriting } from "./NSPasteboardWriting.js";
import type { _CIColor } from "../CoreImage/CIColor.js";
import type { CGRect } from "../structs/CGRect.js";
import type { NSColorSpaceName } from "./NSColorSpaceName.js";
import type { NSColorSystemEffect } from "./NSColorSystemEffect.js";
import type { NSColorType } from "./NSColorType.js";
import type { NSControlTint } from "./NSControlTint.js";
export declare class _NSColor extends _NSObject {
    static alloc(): _NSColor;
    static new(): _NSColor;
    /**
     * Create component-based colors with arbitrary colorspace. The colorspace should be component-based, and the number of components in the provided array should match the number dictated by the specified colorspace, plus one for alpha (supply 1.0 for opaque colors); otherwise an exception will be raised.
     */
    static colorWithColorSpace$components$count$(space: _NSColorSpace, components: NobjcObject, numberOfComponents: number): _NSColor;
    /**
     * Create component-based colors in the sRGB, GenericGamma22Gray, or P3 colorspaces.
     */
    static colorWithSRGBRed$green$blue$alpha$(red: number, green: number, blue: number, alpha: number): _NSColor;
    static colorWithGenericGamma22White$alpha$(white: number, alpha: number): _NSColor;
    static colorWithDisplayP3Red$green$blue$alpha$(red: number, green: number, blue: number, alpha: number): _NSColor;
    /**
     * Create component-based colors that are compatible with sRGB colorspace; these methods are effectively same as colorWithSRGBRed:... or colorWithGenericGamma22White:..., but provided for easier reuse of code that uses UIColor on iOS. If red, green, blue, or saturation, brightness, or white values are outside of the 0..1 range, these will create colors in the extended sRGB (or for colorWithWhite:alpha:, extendedGenericGamma22GrayColorSpace) color spaces. This behavior is compatible with iOS UIColor.
     */
    static colorWithWhite$alpha$(white: number, alpha: number): _NSColor;
    static colorWithRed$green$blue$alpha$(red: number, green: number, blue: number, alpha: number): _NSColor;
    static colorWithHue$saturation$brightness$alpha$(hue: number, saturation: number, brightness: number, alpha: number): _NSColor;
    /**
     * Create a RGB-based color using HSB component values. An exception will be raised if the color model of the provided color space is not RGB.
     */
    static colorWithColorSpace$hue$saturation$brightness$alpha$(space: _NSColorSpace, hue: number, saturation: number, brightness: number, alpha: number): _NSColor;
    /**
     * Look up and return catalog colors from standard color catalogs, or from NSColorList whose name matches the specified catalog name.
     */
    static colorWithCatalogName$colorName$(listName: _NSString, colorName: _NSString): _NSColor | null;
    /**
     * Create catalog colors from values stored with the given name in the Asset Catalog of the specified bundle. To look in the main bundle, use the method without the bundle argument, or specify a nil bundle argument.
     */
    static colorNamed$bundle$(name: _NSString, bundle: _NSBundle | null): _NSColor | null;
    static colorNamed$(name: _NSString): _NSColor | null;
    /**
     * 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: (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;
    static colorWithDeviceHue$saturation$brightness$alpha$(hue: number, saturation: number, brightness: number, alpha: number): _NSColor;
    static colorWithDeviceCyan$magenta$yellow$black$alpha$(cyan: number, magenta: number, yellow: number, black: number, alpha: number): _NSColor;
    /**
     * Create component-based colors in NSCalibratedWhiteColorSpace or NSCalibratedRGBColorSpace color spaces. In general it's best to avoid these methods, since sRGB or P3 colors are preferred over the calibrated (aka "generic") color spaces.
     */
    static colorWithCalibratedWhite$alpha$(white: number, alpha: number): _NSColor;
    static colorWithCalibratedRed$green$blue$alpha$(red: number, green: number, blue: number, alpha: number): _NSColor;
    static colorWithCalibratedHue$saturation$brightness$alpha$(hue: number, saturation: number, brightness: number, alpha: number): _NSColor;
    /** Create pattern colors that paint with the specified image. */
    static colorWithPatternImage$(image: _NSImage): _NSColor;
    /**
     * Generates an HDR color in the extended sRGB colorspace by applying an exposure to the SDR color defined by the red, green, and blue components. The `red`, `green`, and `blue` components have a nominal range of [0..1], `exposure` is a value >= 0. To produce an HDR color, we process the given color in a linear color space, multiplying component values by `2^exposure`. The produced color will have a `contentHeadroom` equal to the linearized exposure value. Each whole value of exposure produces a color that is twice as bright.
     */
    static colorWithRed$green$blue$alpha$exposure$(red: number, green: number, blue: number, alpha: number, exposure: number): _NSColor;
    /**
     * Generates an HDR color in the extended sRGB colorspace by applying an exposure to the SDR color defined by the red, green, and blue components. The `red`, `green`, and `blue` components have a nominal range of [0..1], `linearExposure` is a value >= 1. To produce an HDR color, we process the given color in a linear color space, multiplying component values by `linearExposure `. The produced color will have a `contentHeadroom` equal to `linearExposure`. Each doubling of `linearExposure` produces a color that is twice as bright.
     */
    static colorWithRed$green$blue$alpha$linearExposure$(red: number, green: number, blue: number, alpha: number, linearExposure: number): _NSColor;
    /**
     * @deprecated NSControlTint does not describe the full range of available control accent colors. Use +[NSColor controlAccentColor] instead.
     */
    static colorForControlTint$(controlTint: NSControlTint): _NSColor;
    /** Pasteboard methods */
    static colorFromPasteboard$(pasteBoard: _NSPasteboard): _NSColor | null;
    /** May return nil */
    static colorWithCGColor$(cgColor: Uint8Array): _NSColor | null;
    static colorWithCIColor$(color: _CIColor): _NSColor;
    /**
     * Some convenience methods to create standard colors, typically should not be used for display in user interface elements. Do not make any assumptions about the actual color spaces used: For applications built against the 10.13 SDK these return colors in the sRGB or genericGamma22GrayColorSpace color spaces, while in older apps they use calibrated color spaces.
     */
    static blackColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *blackColor; 0.0 white */
    static darkGrayColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *darkGrayColor; 0.333 white */
    static lightGrayColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *lightGrayColor; 0.667 white */
    static whiteColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *whiteColor; 1.0 white */
    static grayColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *grayColor; 0.5 white */
    static redColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *redColor; 1.0, 0.0, 0.0 RGB */
    static greenColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *greenColor; 0.0, 1.0, 0.0 RGB */
    static blueColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *blueColor; 0.0, 0.0, 1.0 RGB */
    static cyanColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *cyanColor; 0.0, 1.0, 1.0 RGB */
    static yellowColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *yellowColor; 1.0, 1.0, 0.0 RGB */
    static magentaColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *magentaColor; 1.0, 0.0, 1.0 RGB */
    static orangeColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *orangeColor; 1.0, 0.5, 0.0 RGB */
    static purpleColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *purpleColor; 0.5, 0.0, 0.5 RGB */
    static brownColor(): _NSColor;
    /** @property (class, strong, readonly) NSColor *brownColor; 0.6, 0.4, 0.2 RGB */
    static clearColor(): _NSColor;
    /** Foreground color for static text and related elements */
    static labelColor(): _NSColor;
    /** Foreground color for secondary static text and related elements */
    static secondaryLabelColor(): _NSColor;
    /** Foreground color for disabled static text and related elements */
    static tertiaryLabelColor(): _NSColor;
    /**
     * Foreground color for large secondary or disabled static text, separators, large glyphs/icons, etc
     */
    static quaternaryLabelColor(): _NSColor;
    /**
     * / Used for large scale images or subtle decorative elements; not for general foreground content.
     */
    static quinaryLabelColor(): _NSColor;
    /** Foreground color for standard system links */
    static linkColor(): _NSColor;
    /** Foreground color for placeholder text in controls or text views */
    static placeholderTextColor(): _NSColor;
    /** Foreground color on window chrome */
    static windowFrameTextColor(): _NSColor;
    /**
     * Foreground color inside selected menu items. Equivalent to +labelColor in a NSBackgroundStyleEmphasized context.
     */
    static selectedMenuItemTextColor(): _NSColor;
    /**
     * Foreground color inside emphasized and selected content: table views rows, collection views, etc. Equivalent to +labelColor in a NSBackgroundStyleEmphasized context.
     */
    static alternateSelectedControlTextColor(): _NSColor;
    /** Foreground color for header cells in Table/OutlineView */
    static headerTextColor(): _NSColor;
    /**
     * Foreground used for separators between sections of content. Not appropriate for use as split view or window chrome dividers.
     */
    static separatorColor(): _NSColor;
    /** Grids in controls */
    static gridColor(): _NSColor;
    /**
     * Background for windows. This should not be used for drawing, and NSVisualEffectMaterialWindowBackground should be used instead.
     */
    static windowBackgroundColor(): _NSColor;
    /**
     * Background areas revealed behind documents. This should not be used for drawing, and NSVisualEffectMaterialUnderPageBackground should be used instead.
     */
    static underPageBackgroundColor(): _NSColor;
    /**
     * Background for content areas: scroll views, table views, collection views. This should not be used for drawing, and NSVisualEffectMaterialContentBackground should be used instead.
     */
    static controlBackgroundColor(): _NSColor;
    /**
     * The background color of selected and emphasized (focused) content: table views rows, collection views, etc. Alias for +alternateSelectedControlColor
     */
    static selectedContentBackgroundColor(): _NSColor;
    /**
     * The background color of selected and unemphasized content: table views rows, collection views, etc. Alias for +secondarySelectedControlColor
     */
    static unemphasizedSelectedContentBackgroundColor(): _NSColor;
    /**
     * The background colors for alternating content items: such as table view rows, collection view items. Alias for +controlAlternatingRowBackgroundColors
     */
    static alternatingContentBackgroundColors(): _NSArray;
    /**
     * Background color of find indicators: the bubbles that show inline search result hits
     */
    static findHighlightColor(): _NSColor;
    /** Document text */
    static textColor(): _NSColor;
    /** Document text background */
    static textBackgroundColor(): _NSColor;
    static textInsertionPointColor(): _NSColor;
    /** Selected document text */
    static selectedTextColor(): _NSColor;
    /** Selected document text background */
    static selectedTextBackgroundColor(): _NSColor;
    /**
     * The background for unemphasized text selection (e.g. when the associated control/view/window is not key)
     */
    static unemphasizedSelectedTextBackgroundColor(): _NSColor;
    /**
     * The foreground for unemphasized text selection (e.g. when the associated control/view/window is not key)
     */
    static unemphasizedSelectedTextColor(): _NSColor;
    /** Approximate background for the color of control faces (such as buttons). */
    static controlColor(): _NSColor;
    /** Text on controls */
    static controlTextColor(): _NSColor;
    /** Control face for selected controls */
    static selectedControlColor(): _NSColor;
    /** Text on selected controls */
    static selectedControlTextColor(): _NSColor;
    /** Text on disabled controls */
    static disabledControlTextColor(): _NSColor;
    /** Keyboard focus ring around controls */
    static keyboardFocusIndicatorColor(): _NSColor;
    /** Patterned background color for use in NSScrubber */
    static scrubberTexturedBackgroundColor(): _NSColor;
    /**
     * Some colors that are used by system elements and applications. Like the above dynamic system colors, these return named colors whose values may vary between different appearances and releases. Do not make assumptions about the color spaces or actual colors used.
     */
    static systemRedColor(): _NSColor;
    static systemGreenColor(): _NSColor;
    static systemBlueColor(): _NSColor;
    static systemOrangeColor(): _NSColor;
    static systemYellowColor(): _NSColor;
    static systemBrownColor(): _NSColor;
    static systemPinkColor(): _NSColor;
    static systemPurpleColor(): _NSColor;
    static systemGrayColor(): _NSColor;
    static systemTealColor(): _NSColor;
    static systemIndigoColor(): _NSColor;
    static systemMintColor(): _NSColor;
    static systemCyanColor(): _NSColor;
    /**
     * systemFillColor is appropriate for filling thin shapes, such as the track of a slider.
     */
    static systemFillColor(): _NSColor;
    /**
     * secondarySystemFillColor is appropriate for filling small-size shapes, such as the backing of a progress indicator.
     */
    static secondarySystemFillColor(): _NSColor;
    /**
     * tertiarySystemFillColor is appropriate for filling medium-size shapes, such as the backing of a switch.
     */
    static tertiarySystemFillColor(): _NSColor;
    /**
     * quaternarySystemFillColor is appropriate for filling large areas, such as a group box or tab pane.
     */
    static quaternarySystemFillColor(): _NSColor;
    /**
     * quinarySystemFillColor is appropriate for filling large areas that require subtle emphasis, such as content of a form..
     */
    static quinarySystemFillColor(): _NSColor;
    /**
     * A dynamic color that reflects the user's current preferred accent color. This color automatically updates when the accent color preference changes. Do not make assumptions about the color space of this color, which may change across releases.
     * @deprecated NSControlTint does not describe the full range of available control accent colors. Use +[NSColor controlAccentColor] instead.
     */
    static controlAccentColor(): _NSColor;
    /**
     * returns current system control tint
     * @deprecated NSControlTint does not describe the full range of available control accent colors. Use +[NSColor controlAccentColor] instead.
     */
    static currentControlTint(): NSControlTint;
    /**
     * Highlight color for UI elements (this is abstract and defines the color all highlights tend toward)
     */
    static highlightColor(): _NSColor;
    /**
     * Shadow color for UI elements (this is abstract and defines the color all shadows tend toward)
     */
    static shadowColor(): _NSColor;
    /**
     * Global flag for determining whether an application supports alpha. This flag is consulted when an application imports alpha (through color dragging, for instance). The value of this flag also determines whether the color panel has an opacity slider. This value is NO by default as of macOS 14.0. This method provides a global approach to removing alpha which might not always be appropriate, and is deprecated as of macOS 14.0. Applications which need to disable alpha sometimes should use more fine-grained API to control alpha behavior for individual controls.
     * @deprecated Use `showsAlpha` in `NSColorPanel` and `supportsAlpha` in `NSColorWell` to control alpha behavior for individual controls.
     */
    static ignoresAlpha(): boolean;
    static setIgnoresAlpha$(value: boolean): void;
    /**
     * Historically used as the inner border highlight color for beveled buttons. No longer used.
     * @deprecated Use a color that matches the semantics being used, such as `separatorColor`
     */
    static controlHighlightColor(): _NSColor;
    /**
     * Historically used as the outer border highlight color for beveled buttons. No longer used.
     * @deprecated Use a color that matches the semantics being used, such as `separatorColor`
     */
    static controlLightHighlightColor(): _NSColor;
    /**
     * Historically used as the inner border shadow color for beveled buttons. No longer used.
     * @deprecated Use a color that matches the semantics being used, such as `separatorColor`
     */
    static controlShadowColor(): _NSColor;
    /**
     * Historically used as the outer border shadow color for beveled buttons. No longer used.
     * @deprecated Use a color that matches the semantics being used, such as `separatorColor`
     */
    static controlDarkShadowColor(): _NSColor;
    /**
     * Historically used as the color of scroll bars. No longer used.
     * @deprecated Use NSScroller instead
     */
    static scrollBarColor(): _NSColor;
    /**
     * Historically used as the color of scroll bar knobs. No longer used.
     * @deprecated Use NSScroller instead
     */
    static knobColor(): _NSColor;
    /**
     * Historically used as the color of scroll bar knobs being dragged. No longer used.
     * @deprecated Use NSScroller instead
     */
    static selectedKnobColor(): _NSColor;
    /**
     * Historically used as the color of the window chrome, which is no longer able to be represented by a color. No longer used.
     * @deprecated Use NSVisualEffectMaterialTitlebar
     */
    static windowFrameColor(): _NSColor;
    /**
     * Historically used as the color of selected menu items, which is no longer a color but a tinted blur effect. No longer used.
     * @deprecated Use NSVisualEffectMaterialSelection
     */
    static selectedMenuItemColor(): _NSColor;
    /**
     * Historically used as the color of table headers, which is no longer a color but a tinted blur effect.
     * @deprecated Use NSVisualEffectMaterialHeaderView
     */
    static headerColor(): _NSColor;
    /**
     * The background color of selected content or text that is unemphasized. Older alias for +unemphasizedSelectedContentBackgroundColor and +unemphasizedSelectedTextBackgroundColor
     * @deprecated unemphasizedSelectedContentBackgroundColor
     */
    static secondarySelectedControlColor(): _NSColor;
    /**
     * The background color of selected and emphasized (focused) content: table views rows, collection views, etc. Older alias for +selectedContentBackgroundColor
     * @deprecated selectedContentBackgroundColor
     */
    static alternateSelectedControlColor(): _NSColor;
    /**
     * The background colors for alternating content items: such as table view rows, collection view items. Older alias for +alternatingContentBackgroundColors
     * @deprecated Use -type and NSColorType instead
     */
    static controlAlternatingRowBackgroundColors(): _NSArray;
    init(): _NSColor;
    initWithCoder$(coder: _NSCoder): _NSColor | null;
    /**
     * Convert the color to a color of different type; return nil if conversion is not possible.
     */
    colorUsingType$(type: NSColorType): _NSColor | null;
    /**
     * colorUsingColorSpace: will convert existing color to a new color space, if the receiver can be represented as a component-based color. This method will return the receiver if its colorspace is already the same as the one specified. Will return nil if conversion is not possible. This method is highly recommended before using any specialized component accessors such as redComponent, cyanComponent, etc, since these will raise an exception if the color is not in an appropriate color space.
     */
    colorUsingColorSpace$(space: _NSColorSpace): _NSColor | null;
    /**
     * Reinterpret the color by applying a new `contentHeadroom` without changing the color components. Changing the `contentHeadroom` redefines the color relative to a different peak white, changing its behavior under tone mapping and the result of calling `standardDynamicRangeColor`. The new color will have a `contentHeadroom` >= 1.0. If called on a color with a color space that does not support extended range, or does not have an equivalent extended range counterpart, this will return `self`.
     */
    colorByApplyingContentHeadroom$(contentHeadroom: number): _NSColor;
    /** val = 0 => receiver, val = 1 => highlightColor */
    highlightWithLevel$(val: number): _NSColor | null;
    /** val = 0 => receiver, val = 1 => shadowColor */
    shadowWithLevel$(val: number): _NSColor | null;
    /**
     * Returns a color representing the base color with a system defined effect applied to it. This color is safe to create before draw time, as the resolution of the final color only happens when being `-set`, retrieving its `CGColor`, resolving with `-colorWithType:`, etc. The return color type is `.named`.
     */
    colorWithSystemEffect$(systemEffect: NSColorSystemEffect): _NSColor;
    /**
     * Set the color: Sets the fill and stroke colors in the current drawing context. If the color doesn't know about alpha, it's set to 1.0. Should be implemented by subclassers.
     */
    set(): void;
    /**
     * Set the fill or stroke colors individually. These should be implemented by subclassers.
     */
    setFill(): void;
    setStroke(): void;
    /**
     * Blend using the NSCalibratedRGB color space. Both colors are converted into the calibrated RGB color space, and they are blended by taking fraction of color and 1 - fraction of the receiver. The result is in the calibrated RGB color space. If the colors cannot be converted into the calibrated RGB color space the blending fails and nil is returned.
     */
    blendedColorWithFraction$ofColor$(fraction: number, color: _NSColor): _NSColor | null;
    /**
     * Returns a color in the same color space as the receiver with the specified alpha component. The abstract implementation of this method returns the receiver if alpha is 1.0, otherwise it returns nil; subclassers who have explicit opacity components override this method to actually return a color with the specified alpha.
     */
    colorWithAlphaComponent$(alpha: number): _NSColor;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelRGB.
     */
    getRed$green$blue$alpha$(red: NobjcObject | null, green: NobjcObject | null, blue: NobjcObject | null, alpha: NobjcObject | null): void;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelRGB.
     */
    getHue$saturation$brightness$alpha$(hue: NobjcObject | null, saturation: NobjcObject | null, brightness: NobjcObject | null, alpha: NobjcObject | null): void;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelGray.
     */
    getWhite$alpha$(white: NobjcObject | null, alpha: NobjcObject | null): void;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelCMYK.
     */
    getCyan$magenta$yellow$black$alpha$(cyan: NobjcObject | null, magenta: NobjcObject | null, yellow: NobjcObject | null, black: NobjcObject | null, alpha: NobjcObject | null): void;
    getComponents$(components: NobjcObject): void;
    writeToPasteboard$(pasteBoard: _NSPasteboard): void;
    /**
     * Draws the color and adorns it to indicate the type of color. Used by colorwells, swatches, and other UI objects that need to display colors. Implementation in NSColor simply draws the color (with an indication of transparency if the color isn't fully opaque); subclassers can draw more stuff as they see fit.
     */
    drawSwatchInRect$(rect: CGRect): void;
    /**
     * Convert the color to a color of another color space name. This may return nil if the specified conversion cannot be done. The abstract implementation of this method returns the receiver if the specified name matches that of the receiver; otherwise it returns nil. Subclassers who can convert themselves to other color space names override this method to do something better. The device description argument allows the color to specialize itself for the given device. Device descriptions can be obtained from windows, screens, and printers with the "deviceDescription" method. If device is nil then the current device (as obtained from the currently lockFocus'ed view's window or, if printing, the current printer) is used. The method without the device: argument passes nil for the device. If colorSpaceName is nil, then the most appropriate color space is used.
     * @deprecated Use -colorUsingType: or -colorUsingColorSpace: instead
     */
    colorUsingColorSpaceName$device$(name: NSColorSpaceName | null, deviceDescription: _NSDictionary | null): _NSColor | null;
    /** @deprecated Use -colorUsingType: or -colorUsingColorSpace: instead */
    colorUsingColorSpaceName$(name: NSColorSpaceName): _NSColor | null;
    /**
     * Return the type of the color, which in turn determines which accessors are valid for this color. It's an exception-raising error to use properties that are not valid for a color; so, before using a given accessor on a color, call colorUsingType: to convert the color to the appropriate type. Or, if wanting to use colorSpace-specific accessors such as redComponent, convert to the desired colorSpace with colorUsingColorSpace:. Note that as of macOS 10.13, the new APIs type and colorUsingType: replace colorSpaceName and colorUsingColorSpaceName: as the funnel APIs for determining the type of color. In code destined to run on 10.13 and newer systems, subclassers are encouraged to implement these two rather than the older colorSpaceName based methods.
     */
    type(): NSColorType;
    /**
     * In some cases it is useful to recover the color that was base the SDR color that was exposed to generate an HDR color. If a color's `linearExposure` is > 1, then this will return the base SDR color. If the color is not an HDR color, this will return `self`.
     */
    standardDynamicRangeColor(): _NSColor;
    /**
     * Get the catalog and color name of standard colors from catalogs. Valid only on colors whose type is NSColorTypeCatalog. These colors are special colors which can have different device or appearance specific underlying colors.
     */
    catalogNameComponent(): _NSString;
    colorNameComponent(): _NSString;
    /** Return localized versions of the above. */
    localizedCatalogNameComponent(): _NSString;
    localizedColorNameComponent(): _NSString;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelRGB.
     */
    redComponent(): number;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelRGB.
     */
    greenComponent(): number;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelRGB.
     */
    blueComponent(): number;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelRGB.
     */
    hueComponent(): number;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelRGB.
     */
    saturationComponent(): number;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelRGB.
     */
    brightnessComponent(): number;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelGray.
     */
    whiteComponent(): number;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelCMYK.
     */
    cyanComponent(): number;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelCMYK.
     */
    magentaComponent(): number;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelCMYK.
     */
    yellowComponent(): number;
    /**
     * Valid only on component based colors whose colorSpace model is NSColorSpaceModelCMYK.
     */
    blackComponent(): number;
    /**
     * In colors with type == NSColorTypeComponentBased, return the colorspace and individual floating point components, including alpha. Like other colorspace-specific methods these will raise exceptions on other color types.
     */
    colorSpace(): _NSColorSpace;
    numberOfComponents(): number;
    /**
     * Return the image used for the pattern color. Will raise exception for colors other than type == NSColorTypePattern.
     */
    patternImage(): _NSImage;
    /**
     * Get the alpha component. Valid on all colors; for colors which do not have alpha components, this will return 1.0 (opaque).
     */
    alphaComponent(): number;
    /**
     * For HDR colors, the linear brightness multiplier that was applied when generating the color. Colors created with an exposure by NSColor create CGColors that are tagged with a contentHeadroom value. While CGColors created without a contentHeadroom tag will return 0 from CGColorGetHeadroom, NSColors generated in a similar fashion return a linearExposure of 1.0.
     */
    linearExposure(): number;
    /**
     * Returns an autoreleased CGColor. This will never be NULL, although the return value may be an approximation in some cases, so there isn't guaranteed round-trip fidelity.
     */
    CGColor(): NobjcObject;
    /**
     * Get the color space name of the color. Note that here "color space name" doesn't refer to the name of an NSColorSpace, but rather an older way to distinguish the color type of different types of colors, as described at the top of this file. Should be implemented by subclassers for code destined to run on 10.12 or earlier. Newer code can choose to implement type instead.
     * @deprecated Use -type and NSColorType instead
     */
    colorSpaceName(): NSColorSpaceName;
}
export interface _NSColor extends _NSCopying, _NSPasteboardReading, _NSPasteboardWriting, _NSAccessibilityColor {
}
