import type { NobjcObject } from "objc-js";
import type { _NSData } from "../Foundation/NSData.js";
import type { _NSDictionary } from "../Foundation/NSDictionary.js";
import type { _NSObject } from "../Foundation/NSObject.js";
import type { _NSURL } from "../Foundation/NSURL.js";
import type { _CIFilter } from "./CIFilter.js";
import type { _CIImage } from "./CIImage.js";
import type { _CIRenderDestination } from "./CIRenderDestination.js";
import type { _CIRenderTask } from "./CIRenderTask.js";
import type { _MTLCommandBuffer } from "../Metal/MTLCommandBuffer.js";
import type { _MTLCommandQueue } from "../Metal/MTLCommandQueue.js";
import type { _MTLDevice } from "../Metal/MTLDevice.js";
import type { _MTLTexture } from "../Metal/MTLTexture.js";
import type { CGPoint } from "../structs/CGPoint.js";
import type { CGRect } from "../structs/CGRect.js";
import type { CGSize } from "../structs/CGSize.js";
export declare class _CIContext extends _NSObject {
    static alloc(): _CIContext;
    static new(): _CIContext;
    /**
     * Create a new CoreImage context object, all output will be drawn into the surface attached to the OpenGL context 'cglctx'. If 'pixelFormat' is non-null it should be the pixel format object used to create 'cglctx'; it's required to be valid for the lifetime of the CIContext. The colorspace should be set to the colorspace of your target otherwise CI will take the colorspace from the CGLContext if available.
     */
    static contextWithCGLContext$pixelFormat$colorSpace$options$(cglctx: NobjcObject, pixelFormat: NobjcObject | null, colorSpace: Uint8Array | null, options: _NSDictionary | null): _CIContext;
    /**
     * DEPRECATED, please use the method above or if you need this for backward capability, make sure that you specify the colorspace in the options dictionary
     */
    static contextWithCGLContext$pixelFormat$options$(cglctx: NobjcObject, pixelFormat: NobjcObject | null, options: _NSDictionary | null): _CIContext;
    /**
     * Create a context specifying a destination CGContext. Core Image will use an internal destination context when methods such as [context render:to...] or [context createCGImage:...] are called. The [context drawImage:...] render methods will render to the CGContext.
     */
    static contextWithCGContext$options$(cgctx: Uint8Array, options: _NSDictionary | null): _CIContext;
    /**
     * Create a context without specifying a destination CG/GL/Metal context. Core Image will use an internal destination context when methods such as [context render:to...] or [context createCGImage:...] are called. The [context drawImage:...] render methods will not operate on this type of context.
     */
    static contextWithOptions$(options: _NSDictionary | null): _CIContext;
    static context(): _CIContext;
    /**
     * If a system has more than one MTLDevice, then you can create a CIContext that uses a specific device. If a client wishes to use the default MTLDevice then call [CIContext contextWithOptions:] instead.
     */
    static contextWithMTLDevice$(device: _MTLDevice): _CIContext;
    static contextWithMTLDevice$options$(device: _MTLDevice, options: _NSDictionary | null): _CIContext;
    /** Create a CIContext that commits commands to a specific queue. */
    static contextWithMTLCommandQueue$(commandQueue: _MTLCommandQueue): _CIContext;
    static contextWithMTLCommandQueue$options$(commandQueue: _MTLCommandQueue, options: _NSDictionary | null): _CIContext;
    /**
     * Not all GPUs will be driving a display. If they are offline we can still use them to do work with Core Image. This method returns the number of offline GPUs which can be used for this purpose
     */
    static offlineGPUCount(): number;
    /**
     * These two methods lets you create a CIContext based on an offline gpu index. The first method takes only the GPU index as a parameter, the second, takes an optional colorspace, options dictionary and a CGLContext which can be shared with other GL resources. The return value will be null if index is out of range (e.g. if the device has no offline GPUs).
     */
    static contextForOfflineGPUAtIndex$(index: number): _CIContext | null;
    static contextForOfflineGPUAtIndex$colorSpace$options$sharedContext$(index: number, colorSpace: Uint8Array | null, options: _NSDictionary | null, sharedContext: NobjcObject | null): _CIContext | null;
    initWithOptions$(options: _NSDictionary | null): _CIContext;
    init(): _CIContext;
    /**
     * DEPRECATED, please use drawImage:inRect:fromRect: instead. Render the subregion 'fromRect' of 'image' to point 'atPoint' in the context's destination.
     * @deprecated
     */
    drawImage$atPoint$fromRect$(image: _CIImage, atPoint: CGPoint, fromRect: CGRect): void;
    /**
     * Render the rectangle 'fromRect' of 'image' to the rectangle 'inRect' in the context's destination.
     */
    drawImage$inRect$fromRect$(image: _CIImage, inRect: CGRect, fromRect: CGRect): void;
    /**
     * Create a CoreGraphics layer object suitable for creating content for subsequently rendering into this CI context. The 'info' parameter is passed into CGLayerCreate () as the auxiliaryInfo dictionary. This will return null if size is empty or infinite.
     * @deprecated
     */
    createCGLayerWithSize$info$(size: CGSize, info: NobjcObject | null): NobjcObject;
    /**
     * Render 'image' to the given bitmap. The 'data' parameter must point to at least rowBytes*floor(bounds.size.height) bytes. The 'bounds' parameter has the following behavior: The 'bounds' parameter acts to specify the region of 'image' to render. This region (regardless of its origin) is rendered at upper-left corner of 'data'. Passing a 'colorSpace' value of null means: Disable output color management if app is linked against iOS SDK Disable output color management if app is linked against OSX 10.11 SDK or later Match to context's output color space if app is linked against OSX 10.10 SDK or earlier
     */
    render$toBitmap$rowBytes$bounds$format$colorSpace$(image: _CIImage, data: Uint8Array, rowBytes: number, bounds: CGRect, format: number, colorSpace: Uint8Array | null): void;
    /**
     * Render 'image' to the given IOSurface. Point (0,0) in the image coordinate system will align to the lower left corner of 'surface'. The 'bounds' parameter acts as a clip rect to limit what region of 'surface' is modified. If 'colorSpace' is nil, CI will not color match to the destination.
     */
    render$toIOSurface$bounds$colorSpace$(image: _CIImage, surface: Uint8Array, bounds: CGRect, colorSpace: Uint8Array | null): void;
    /**
     * Render 'image' into the given CVPixelBuffer. In OS X 10.11.3 and iOS 9.3 and later CI will color match to the colorspace of the buffer. otherwise CI will color match to the context's output colorspace.
     */
    render$toCVPixelBuffer$(image: _CIImage, buffer: NobjcObject): void;
    /**
     * Render 'image' to the given CVPixelBufferRef. Point (0,0) in the image coordinate system will align to the lower left corner of 'buffer'. The 'bounds' parameter acts as a clip rect to limit what region of 'buffer' is modified. If 'colorSpace' is nil, CI will not color match to the destination.
     */
    render$toCVPixelBuffer$bounds$colorSpace$(image: _CIImage, buffer: NobjcObject, bounds: CGRect, colorSpace: Uint8Array | null): void;
    /**
     * Render 'bounds' of 'image' to a Metal texture, optionally specifying what command buffer to use. Texture type must be MTLTexture2D. NOTE: Rendering to a texture initialized with a commandBuffer requires encoding all the commands to render an image into the specified buffer. This may impact system responsiveness and may result in higher memory usage if the image requires many passes to render. To avoid this impact, it is recommended to create a context using [CIContext contextWithMTLCommandQueue:].
     */
    render$toMTLTexture$commandBuffer$bounds$colorSpace$(image: _CIImage, texture: _MTLTexture, commandBuffer: _MTLCommandBuffer | null, bounds: CGRect, colorSpace: Uint8Array): void;
    /**
     * Runs the context's garbage collector to reclaim any resources that are no longer required (e.g. removes textures from the texture cache that reference deleted images.) This method is called automatically after every rendering operation.
     */
    reclaimResources(): void;
    /**
     * Frees any cached data (such as temporary images) associated with the context. This also runs the garbage collector.
     */
    clearCaches(): void;
    /**
     * Returns the maximum dimension for input images that can be processed on the context.
     */
    inputImageMaximumSize(): CGSize;
    /** Returns the maximum dimension for image that can be rendered on the context. */
    outputImageMaximumSize(): CGSize;
    /**
     * Creates a Core Graphics image from a region of a Core Image image instance. The color space of the created `CGImage` will be sRGB unless the receiving ``CIContext`` was created with a `kCIContextOutputColorSpace` option. Normally the pixel format of the created CGImage will be 8 bits-per-component. It will be 16 bits-per-component float if the above color space is HDR. - Parameters: - image: A ``CIImage`` image instance for which to create a `CGImage`. - fromRect: The `CGRect` region of the `image` to use. This region relative to the cartesean coordinate system of `image`. This region will be intersected with integralized and intersected with `image.extent`. - Returns: Returns a new `CGImage` instance. You are responsible for releasing the returned image when you no longer need it. The returned value will be `null` if the extent is empty or too big.
     */
    createCGImage$fromRect$(image: _CIImage, fromRect: CGRect): NobjcObject;
    /**
     * Creates a Core Graphics image from a region of a Core Image image instance with an option for controlling the pixel format and color space of the `CGImage`. - Parameters: - image: A ``CIImage`` image instance for which to create a `CGImage`. - fromRect: The `CGRect` region of the `image` to use. This region relative to the cartesean coordinate system of `image`. This region will be intersected with integralized and intersected with `image.extent`. - format: A ``CIFormat`` to specify the pixel format of the created `CGImage`. For example, if `kCIFormatRGBX16` is specified, then the created `CGImage` will be 16 bits-per-component and opaque. - colorSpace: The `CGColorSpace` for the output image. This color space must have either `CGColorSpaceModel.rgb` or `CGColorSpaceModel.monochrome` and be compatible with the specified pixel format. - Returns: Returns a new `CGImage` instance. You are responsible for releasing the returned image when you no longer need it. The returned value will be `null` if the extent is empty or too big.
     */
    createCGImage$fromRect$format$colorSpace$(image: _CIImage, fromRect: CGRect, format: number, colorSpace: Uint8Array | null): NobjcObject;
    /**
     * Creates a Core Graphics image from a region of a Core Image image instance with an option for controlling when the image is rendered. - Parameters: - image: A ``CIImage`` image instance for which to create a `CGImage`. - fromRect: The `CGRect` region of the `image` to use. This region relative to the cartesean coordinate system of `image`. This region will be intersected with integralized and intersected with `image.extent`. - format: A ``CIFormat`` to specify the pixel format of the created `CGImage`. For example, if `kCIFormatRGBX16` is specified, then the created `CGImage` will be 16 bits-per-component and opaque. - colorSpace: The `CGColorSpace` for the output image. This color space must have either `CGColorSpaceModel.rgb` or `CGColorSpaceModel.monochrome` and be compatible with the specified pixel format. - deferred: Controls when Core Image renders `image`. * True: rendering of `image` is deferred until the created `CGImage` rendered. * False: the `image` is rendered immediately. - Returns: Returns a new `CGImage` instance. You are responsible for releasing the returned image when you no longer need it. The returned value will be `null` if the extent is empty or too big.
     */
    createCGImage$fromRect$format$colorSpace$deferred$(image: _CIImage, fromRect: CGRect, format: number, colorSpace: Uint8Array | null, deferred: boolean): NobjcObject;
    /**
     * Creates a Core Graphics image from a region of a Core Image image instance with an option for calculating HDR statistics. - Parameters: - image: A ``CIImage`` image instance for which to create a `CGImage`. - fromRect: The `CGRect` region of the `image` to use. This region relative to the cartesean coordinate system of `image`. This region will be intersected with integralized and intersected with `image.extent`. - format: A ``CIFormat`` to specify the pixel format of the created `CGImage`. For example, if `kCIFormatRGBX16` is specified, then the created `CGImage` will be 16 bits-per-component and opaque. - colorSpace: The `CGColorSpace` for the output image. This color space must have either `CGColorSpaceModel.rgb` or `CGColorSpaceModel.monochrome` and be compatible with the specified pixel format. - deferred: Controls when Core Image renders `image`. * True: rendering of `image` is deferred until the created `CGImage` rendered. * False: the `image` is rendered immediately. - calculateHDRStats: Controls if Core Image calculates HDR statistics. * True: Core Image will immediately render `image`, calculate the HDR statistics and create a `CGImage` that has the calculated values. * False: the created `CGImage` will not have any HDR statistics. - Returns: Returns a new `CGImage` instance. You are responsible for releasing the returned image when you no longer need it. The returned value will be `null` if the extent is empty or too big.
     */
    createCGImage$fromRect$format$colorSpace$deferred$calculateHDRStats$(image: _CIImage, fromRect: CGRect, format: number, colorSpace: Uint8Array | null, deferred: boolean, calculateHDRStats: boolean): NobjcObject;
    /**
     * Given an IOSurface, use the receiving Core Image context to calculate its HDR statistics (content headroom and content average light level) and then update the surface's attachments to store the values. If the `IOSurface` has a Clean Aperture rectangle then only pixels within that rectangle are considered. - Parameters: - surface: A mutable `IOSurfaceRef` for which to calculate and attach statistics.
     */
    calculateHDRStatsForIOSurface$(surface: Uint8Array): void;
    /**
     * Given a CVPixelBuffer, use the receiving Core Image context to calculate its HDR statistics (content headroom and content average light level) and then update the buffers's attachments to store the values. If the `CVPixelBuffer` has a Clean Aperture rectangle then only pixels within that rectangle are considered. - Parameters: - buffer: A mutable `CVPixelBuffer` for which to calculate and attach statistics.
     */
    calculateHDRStatsForCVPixelBuffer$(buffer: NobjcObject): void;
    /**
     * Given a Core Graphics image, use the receiving Core Image context to calculate its HDR statistics (content headroom and content average light level) and then return a new Core Graphics image that has the calculated values. - Parameters: - cgimage: An immutable `CGImage` for which to calculate statistics. - Returns: Returns a new `CGImage` instance that has the calculated statistics attached.
     */
    calculateHDRStatsForCGImage$(cgimage: Uint8Array): NobjcObject;
    /**
     * Given a Core Image image, use the receiving Core Image context to calculate its HDR statistics (content headroom and content average light level) and then return a new Core Image image that has the calculated values. If the image extent is not finite, then nil will be returned. - Parameters: - image: An immutable ``CIImage`` for which to calculate statistics. - Returns: Returns a new ``CIImage`` instance that has the calculated statistics attached.
     */
    calculateHDRStatsForImage$(image: _CIImage): _CIImage | null;
    /**
     * Render a CIImage to TIFF data. Image must have a finite non-empty extent. The CGColorSpace must be kCGColorSpaceModelRGB or kCGColorSpaceModelMonochrome and must match the specified CIFormat. No options keys are supported at this time.
     */
    TIFFRepresentationOfImage$format$colorSpace$options$(image: _CIImage, format: number, colorSpace: Uint8Array, options: _NSDictionary): _NSData | null;
    /**
     * Render a CIImage to JPEG data. Image must have a finite non-empty extent. The CGColorSpace must be kCGColorSpaceModelRGB or kCGColorSpaceModelMonochrome. Supported options keys are kCGImageDestinationLossyCompressionQuality, kCGImageDestinationEmbedThumbnail, and the depth, disparity, and matte options.
     */
    JPEGRepresentationOfImage$colorSpace$options$(image: _CIImage, colorSpace: Uint8Array, options: _NSDictionary): _NSData | null;
    /**
     * Render a CIImage to HEIF data. Image must have a finite non-empty extent. The CGColorSpace must be kCGColorSpaceModelRGB or kCGColorSpaceModelMonochrome and must match the specified CIFormat. Supported options keys are kCGImageDestinationLossyCompressionQuality, kCGImageDestinationEmbedThumbnail,and the depth, disparity, and matte options.
     */
    HEIFRepresentationOfImage$format$colorSpace$options$(image: _CIImage, format: number, colorSpace: Uint8Array, options: _NSDictionary): _NSData | null;
    /**
     * Render a CIImage to HEIF data. Image must have a finite non-empty extent. The CGColorSpace must be kCGColorSpaceModelRGB or kCGColorSpaceModelMonochrome. Supported options keys are kCGImageDestinationLossyCompressionQuality, and the depth, disparity, and matte options.
     */
    HEIF10RepresentationOfImage$colorSpace$options$error$(image: _CIImage, colorSpace: Uint8Array, options: _NSDictionary, errorPtr: NobjcObject | null): _NSData | null;
    /**
     * Render a CIImage to PNG data. Image must have a finite non-empty extent. The CGColorSpace must be kCGColorSpaceModelRGB or kCGColorSpaceModelMonochrome and must match the specified CIFormat. No options keys are supported at this time.
     */
    PNGRepresentationOfImage$format$colorSpace$options$(image: _CIImage, format: number, colorSpace: Uint8Array, options: _NSDictionary): _NSData | null;
    /**
     * Render a CIImage to OpenEXR data. Image must have a finite non-empty extent. No options keys are supported at this time.
     */
    OpenEXRRepresentationOfImage$options$error$(image: _CIImage, options: _NSDictionary, errorPtr: NobjcObject | null): _NSData | null;
    /**
     * Render a CIImage to TIFF file. Image must have a finite non-empty extent. The CGColorSpace must be kCGColorSpaceModelRGB or kCGColorSpaceModelMonochrome and must match the specified CIFormat. No options keys are supported at this time.
     */
    writeTIFFRepresentationOfImage$toURL$format$colorSpace$options$error$(image: _CIImage, url: _NSURL, format: number, colorSpace: Uint8Array, options: _NSDictionary, errorPtr: NobjcObject | null): boolean;
    /**
     * Render a CIImage to PNG file. Image must have a finite non-empty extent. The CGColorSpace must be kCGColorSpaceModelRGB or kCGColorSpaceModelMonochrome and must match the specified CIFormat. No options keys are supported at this time.
     */
    writePNGRepresentationOfImage$toURL$format$colorSpace$options$error$(image: _CIImage, url: _NSURL, format: number, colorSpace: Uint8Array, options: _NSDictionary, errorPtr: NobjcObject | null): boolean;
    /**
     * Render a CIImage to JPEG file. Image must have a finite non-empty extent. The CGColorSpace must be kCGColorSpaceModelRGB or kCGColorSpaceModelMonochrome. Supported options keys are kCGImageDestinationLossyCompressionQuality, kCGImageDestinationEmbedThumbnail, and the depth, disparity, and matte options.
     */
    writeJPEGRepresentationOfImage$toURL$colorSpace$options$error$(image: _CIImage, url: _NSURL, colorSpace: Uint8Array, options: _NSDictionary, errorPtr: NobjcObject | null): boolean;
    /**
     * Render a CIImage to HEIF file. Image must have a finite non-empty extent. The CGColorSpace must be kCGColorSpaceModelRGB or kCGColorSpaceModelMonochrome and must match the specified CIFormat. Supported options keys are kCGImageDestinationLossyCompressionQuality, kCGImageDestinationEmbedThumbnail, and the depth, disparity, and matte options.
     */
    writeHEIFRepresentationOfImage$toURL$format$colorSpace$options$error$(image: _CIImage, url: _NSURL, format: number, colorSpace: Uint8Array, options: _NSDictionary, errorPtr: NobjcObject | null): boolean;
    /**
     * Render a CIImage to 10-bit deep HEIF file. Image must have a finite non-empty extent. The CGColorSpace must be kCGColorSpaceModelRGB or kCGColorSpaceModelMonochrome. Supported options keys are kCGImageDestinationLossyCompressionQuality, and the depth, disparity, and matte options.
     */
    writeHEIF10RepresentationOfImage$toURL$colorSpace$options$error$(image: _CIImage, url: _NSURL, colorSpace: Uint8Array, options: _NSDictionary, errorPtr: NobjcObject | null): boolean;
    /**
     * Render a CIImage to OpenEXR file. Image must have a finite non-empty extent. No options keys are supported at this time.
     */
    writeOpenEXRRepresentationOfImage$toURL$options$error$(image: _CIImage, url: _NSURL, options: _NSDictionary, errorPtr: NobjcObject | null): boolean;
    /**
     * Create and CIFilter instance for 'image' that can be used to apply the CIDepthBlurEffect. The receiver context is user to render the image in order to get the facial landmarks The 'options' parameter is a key value/pair reserved for future use.
     */
    depthBlurEffectFilterForImageURL$options$(url: _NSURL, options: _NSDictionary | null): _CIFilter | null;
    /**
     * This is the same as the method above expect it uses NSData to instantiate the image data instead of the contents of a NSURL.
     */
    depthBlurEffectFilterForImageData$options$(data: _NSData, options: _NSDictionary | null): _CIFilter | null;
    /**
     * Create and CIFilter instance for 'image' that can be used to apply the CIDepthBlurEffect. The receiver context is user to render the image in order to get the facial landmarks The 'orientation' parameter should be CGImagePropertyOrientation enum value as defined in the TIFF spec. The 'options' parameter is a key value/pair reserved for future use.
     */
    depthBlurEffectFilterForImage$disparityImage$portraitEffectsMatte$orientation$options$(image: _CIImage, disparityImage: _CIImage, portraitEffectsMatte: _CIImage | null, orientation: NobjcObject, options: _NSDictionary | null): _CIFilter | null;
    depthBlurEffectFilterForImage$disparityImage$portraitEffectsMatte$hairSemanticSegmentation$orientation$options$(image: _CIImage, disparityImage: _CIImage, portraitEffectsMatte: _CIImage | null, hairSemanticSegmentation: _CIImage | null, orientation: NobjcObject, options: _NSDictionary | null): _CIFilter | null;
    depthBlurEffectFilterForImage$disparityImage$portraitEffectsMatte$hairSemanticSegmentation$glassesMatte$gainMap$orientation$options$(image: _CIImage, disparityImage: _CIImage, portraitEffectsMatte: _CIImage | null, hairSemanticSegmentation: _CIImage | null, glassesMatte: _CIImage | null, gainMap: _CIImage | null, orientation: NobjcObject, options: _NSDictionary | null): _CIFilter | null;
    /**
     * Renders a portion of image to a point of destination It renders as if 'image' is cropped to 'fromRect' and the origin of the result is placed at 'atPoint' If image.extent and fromRect are infinite, then it renders so that point (0,0) of image is placed at 'atPoint' MTLTexture-backed CIRenderDestinations are only supported by MTLTexture-backed CIContexts. GLTexture-backed CIRenderDestinations are only supported by GLContext-backed CIContexts. For contexts that are initialized with a command queue, this call will return as soon as all the work for the render is enqueued on the context's device. Otherwise, it will return as soon as all the work is scheduled. In many situations, after issuing a render, the client can use the destination or its backing object without waiting for the enqueued work to complete. For example, after rendering a surface CIRenderDestination, the surface can be passed on for further processing by the GPU. In other situations, the client may need to wait for the render to be complete. For example, after rendering a surface CIRenderDestination, the surface can be accessed by CPU code by calling IOSurfaceGetBytePointer only after the render is completed. In this case the client can use the returned CIRenderTask like this: CIRenderTask* task = [context render:...]; [task waitUntilCompletedAndReturnError: &error ];
     */
    startTaskToRender$fromRect$toDestination$atPoint$error$(image: _CIImage, fromRect: CGRect, destination: _CIRenderDestination, atPoint: CGPoint, error: NobjcObject | null): _CIRenderTask | null;
    /**
     * Renders an image to a destination so that point (0,0) of image. is placed at point (0,0) of the destination.
     */
    startTaskToRender$toDestination$error$(image: _CIImage, destination: _CIRenderDestination, error: NobjcObject | null): _CIRenderTask | null;
    /**
     * This is an optional call which can be used to "warm up" a CIContext so that a subsequent call to render with the same arguments can be more efficient. By making this call, Core Image will ensure that - any needed kernels will be compiled - any intermedate buffers are allocated and marked volatile
     */
    prepareRender$fromRect$toDestination$atPoint$error$(image: _CIImage, fromRect: CGRect, destination: _CIRenderDestination, atPoint: CGPoint, error: NobjcObject | null): boolean;
    /**
     * Fill the entire destination with black (0,0,0,1) if its alphaMode is None or clear (0,0,0,0) if its alphaMode is Premultiplied or Unpremultiplied.
     */
    startTaskToClear$error$(destination: _CIRenderDestination, error: NobjcObject | null): _CIRenderTask | null;
    /**
     * The working color space of the CIContext. The working color space determines the color space used when executing filter kernels. You specify a working color space using the ``kCIContextWorkingColorSpace`` option when creating a ``CIContext``. * All input images are color matched from the input's color space to the working space. * All renders are color matched from the working space to the destination space. The property will be `null` if the context was created with color management disabled.
     */
    workingColorSpace(): NobjcObject;
    /**
     * The working pixel format that the CIContext uses for intermediate buffers. The working format determines the pixel format that Core Image uses to create intermediate buffers for rendering images. You specify a working pixel format using the ``kCIContextWorkingFormat`` option when creating a ``CIContext``.
     */
    workingFormat(): number;
}
