import type { NobjcObject } from "objc-js";
import type { _NSArray } from "../Foundation/NSArray.js";
import type { _NSDictionary } from "../Foundation/NSDictionary.js";
import type { _NSObject } from "../Foundation/NSObject.js";
import type { _CIImage } from "./CIImage.js";
import type { _CIImageProcessorOutput } from "./CIImageProcessorOutput.js";
import type { CGRect } from "../structs/CGRect.js";
export declare class _CIImageProcessorKernel extends _NSObject {
    static alloc(): _CIImageProcessorKernel;
    static new(): _CIImageProcessorKernel;
    init(): _CIImageProcessorKernel;
    /**
     * Override this class method to implement your Core Image Processor Kernel subclass. When a `CIImage` containing your `CIImageProcessorKernel` class is rendered, your class' implementation of this method will be called as needed for that render. The method may be called more than once if Core Image needs to tile to limit memory usage. When your implementation of this class method is called, use the provided `inputs` and `arguments` objects to return processed pixel data to Core Image via `output`. > Important: this is a class method so that you cannot use or capture any state by accident. All the parameters that affect the output results must be passed to ``applyWithExtent:inputs:arguments:error:``. - Parameters: - inputs: An array of `id<CIImageProcessorInput>` that the class consumes to produce its output. The `input.region` may be larger than the rect returned by ``roiForInput:arguments:outputRect:``. - arguments: the arguments dictionary that was passed to ``applyWithExtent:inputs:arguments:error:``. - output: The `id<CIImageProcessorOutput>` that the `CIImageProcessorKernel` must provide results to. - error: Pointer to the `NSError` object into which processing errors will be written. - Returns: Returns YES if processing succeeded, and NO if processing failed.
     */
    static processWithInputs$arguments$output$error$(inputs: _NSArray | null, arguments_: _NSDictionary | null, output: _CIImageProcessorOutput, error: NobjcObject | null): boolean;
    /**
     * Override this class method to implement your processor’s ROI callback. This will be called one or more times per render to determine what portion of the input images are needed to render a given 'outputRect' of the output. This will not be called if processor has no input images. The default implementation would return outputRect. > Important: this is a class method so that you cannot use or capture any state by accident. All the parameters that affect the output results must be passed to ``applyWithExtent:inputs:arguments:error:``. - Parameters: - inputIndex: the index that tells you which processor input for which to return the ROI rectangle. - arguments: the arguments dictionary that was passed to ``applyWithExtent:inputs:arguments:error:``. - outputRect: the output `CGRect` that processor will be asked to output. - Returns: The `CGRect` of the `inputIndex`th input that is required for the above `outputRect`
     */
    static roiForInput$arguments$outputRect$(inputIndex: number, arguments_: _NSDictionary | null, outputRect: CGRect): CGRect;
    /**
     * Override this class method to implement your processor’s tiled ROI callback. This will be called one or more times per render to determine what tiles of the input images are needed to render a given `outputRect` of the output. If the processor implements this method, then when rendered; * as CoreImage prepares for a render, this method will be called for each input to return an ROI tile array. * as CoreImage performs the render, the method ``processWithInputs:arguments:output:error:`` will be called once for each tile. > Important: this is a class method so that you cannot use or capture any state by accident. All the parameters that affect the output results must be passed to ``applyWithExtent:inputs:arguments:error:``. - Parameters: - inputIndex: the index that tells you which processor input for which to return the array of ROI rectangles - arguments: the arguments dictionary that was passed to ``applyWithExtent:inputs:arguments:error:``. - outputRect: the output `CGRect` that processor will be asked to output. - Returns: An array of ``CIVector`` that specify tile regions of the `inputIndex`'th input that is required for the above `outputRect` Each region tile in the array is a created by calling ``/CIVector/vectorWithCGRect:/`` The tiles may overlap but should fully cover the area of 'input' that is needed. If a processor has multiple inputs, then each input should return the same number of region tiles.
     */
    static roiTileArrayForInput$arguments$outputRect$(inputIndex: number, arguments_: _NSDictionary | null, outputRect: CGRect): _NSArray;
    /**
     * Override this class method if you want your any of the inputs to be in a specific pixel format. The format must be one of `kCIFormatBGRA8`, `kCIFormatRGBAh`, `kCIFormatRGBAf` or `kCIFormatR8`. On iOS 12 and macOS 10.14, the formats `kCIFormatRh` and `kCIFormatRf` are also supported. If the requested inputFormat is `0`, then the input will be a supported format that best matches the rendering context's ``/CIContext/workingFormat``. If a processor wants data in a colorspace other than the context's working color space, then call ``/CIImage/imageByColorMatchingWorkingSpaceToColorSpace:`` on the processor input. If a processor wants it input as alpha-unpremultiplied RGBA data, then call ``/CIImage/imageByUnpremultiplyingAlpha`` on the processor input.
     */
    static formatForInputAtIndex$(inputIndex: number): number;
    /**
     * Call this method on your Core Image Processor Kernel subclass to create a new image of the specified extent. The inputs and arguments will be retained so that your subclass can be called when the image is drawn. This method will return `nil` and an error if: * calling ``outputFormat`` on your subclass returns an unsupported format. * calling ``formatForInputAtIndex:`` on your subclass returns an unsupported format. * your subclass does not implement ``processWithInputs:arguments:output:error:`` - Parameters: - extent: The bounding `CGRect` of pixels that the `CIImageProcessorKernel` can produce. This method will return ``/CIImage/emptyImage`` if extent is empty. - inputs: An array of ``CIImage`` objects to use as input. - arguments: This dictionary contains any additional parameters that the processor needs to produce its output. The argument objects can be of any type but in order for CoreImage to cache intermediates, they must be of the following immutable types: `NSArray`, `NSDictionary`, `NSNumber`, `NSValue`, `NSData`, `NSString`, `NSNull`, ``CIVector``, ``CIColor``, `CGImage`, `CGColorSpace`, or `MLModel`. - error: Pointer to the `NSError` object into which processing errors will be written. - Returns: An autoreleased ``CIImage``
     */
    static applyWithExtent$inputs$arguments$error$(extent: CGRect, inputs: _NSArray | null, arguments_: _NSDictionary | null, error: NobjcObject | null): _CIImage | null;
    /**
     * Override this class method of your Core Image Processor Kernel subclass if it needs to produce multiple outputs. This supports 0, 1, 2 or more input images and 2 or more output images. When a `CIImage` containing your `CIImageProcessorKernel` class is rendered, your class' implementation of this method will be called as needed for that render. The method may be called more than once if Core Image needs to tile to limit memory usage. When your implementation of this class method is called, use the provided `inputs` and `arguments` objects to return processed pixel data to Core Image via multiple `outputs`. > Important: this is a class method so that you cannot use or capture any state by accident. All the parameters that affect the output results must be passed to ``applyWithExtent:inputs:arguments:error:``. - Parameters: - inputs: An array of `id<CIImageProcessorInput>` that the class consumes to produce its output. The `input.region` may be larger than the rect returned by ``roiForInput:arguments:outputRect:``. - arguments: the arguments dictionary that was passed to ``applyWithExtent:inputs:arguments:error:``. - outputs: An array `id<CIImageProcessorOutput>` that the `CIImageProcessorKernel` must provide results to. - error: Pointer to the `NSError` object into which processing errors will be written. - Returns: Returns YES if processing succeeded, and NO if processing failed.
     */
    static processWithInputs$arguments$outputs$error$(inputs: _NSArray | null, arguments_: _NSDictionary | null, outputs: _NSArray, error: NobjcObject | null): boolean;
    /**
     * Override this class method if your processor has more than one output and you want your processor's output to be in a specific supported `CIPixelFormat`. The format must be one of `kCIFormatBGRA8`, `kCIFormatRGBAh`, `kCIFormatRGBAf` or `kCIFormatR8`. On iOS 12 and macOS 10.14, the formats `kCIFormatRh` and `kCIFormatRf` are also supported. If the outputFormat is `0`, then the output will be a supported format that best matches the rendering context's ``/CIContext/workingFormat``. - Parameters: - outputIndex: the index that tells you which processor output for which to return the desired `CIPixelFormat` - arguments: the arguments dictionary that was passed to ``applyWithExtent:inputs:arguments:error:``. - Returns: Return the desired `CIPixelFormat`
     */
    static outputFormatAtIndex$arguments$(outputIndex: number, arguments_: _NSDictionary | null): number;
    /**
     * Call this method on your multiple-output Core Image Processor Kernel subclass to create an array of new image objects given the specified array of extents. The inputs and arguments will be retained so that your subclass can be called when the image is drawn. This method will return `nil` and an error if: * calling ``outputFormatAtIndex:arguments:`` on your subclass returns an unsupported format. * calling ``formatForInputAtIndex:`` on your subclass returns an unsupported format. * your subclass does not implement ``processWithInputs:arguments:output:error:`` - Parameters: - extents: The array of bounding rectangles that the `CIImageProcessorKernel` can produce. Each rectangle in the array is an object created using ``/CIVector/vectorWithCGRect:`` This method will return `CIImage.emptyImage` if a rectangle in the array is empty. - inputs: An array of ``CIImage`` objects to use as input. - arguments: This dictionary contains any additional parameters that the processor needs to produce its output. The argument objects can be of any type but in order for CoreImage to cache intermediates, they must be of the following immutable types: `NSArray`, `NSDictionary`, `NSNumber`, `NSValue`, `NSData`, `NSString`, `NSNull`, ``CIVector``, ``CIColor``, `CGImage`, `CGColorSpace`, or `MLModel`. - error: Pointer to the `NSError` object into which processing errors will be written. - Returns: An autoreleased ``CIImage``
     */
    static applyWithExtents$inputs$arguments$error$(extents: _NSArray, inputs: _NSArray | null, arguments_: _NSDictionary | null, error: NobjcObject | null): _NSArray | null;
    /**
     * Override this class property if you want your processor's output to be in a specific pixel format. The format must be one of `kCIFormatBGRA8`, `kCIFormatRGBAh`, `kCIFormatRGBAf` or `kCIFormatR8`. On iOS 12 and macOS 10.14, the formats `kCIFormatRh` and `kCIFormatRf` are also supported. If the outputFormat is `0`, then the output will be a supported format that best matches the rendering context's ``/CIContext/workingFormat``. If a processor returns data in a color space other than the context working color space, then call ``/CIImage/imageByColorMatchingColorSpaceToWorkingSpace:`` on the processor output. If a processor returns data as alpha-unpremultiplied RGBA data, then call, ``/CIImage/imageByPremultiplyingAlpha`` on the processor output.
     */
    static outputFormat(): number;
    /**
     * Override this class property if your processor's output stores 1.0 into the alpha channel of all pixels within the output extent. If not overridden, false is returned.
     */
    static outputIsOpaque(): boolean;
    /**
     * Override this class property to return false if you want your processor to be given input objects that have not been synchronized for CPU access. Generally, if your subclass uses the GPU your should override this method to return false. If not overridden, true is returned.
     */
    static synchronizeInputs(): boolean;
}
