import type { NobjcObject } from "objc-js";
import type { _MTL4CommitOptions } from "./MTL4CommitOptions.js";
import type { _MTLBuffer } from "./MTLBuffer.js";
import type { _MTLDevice } from "./MTLDevice.js";
import type { _MTLDrawable } from "./MTLDrawable.js";
import type { _MTLEvent } from "./MTLEvent.js";
import type { _MTLHeap } from "./MTLHeap.js";
import type { _MTLResidencySet } from "./MTLResidencySet.js";
import type { _MTLTexture } from "./MTLTexture.js";
import type { _NSString } from "../Foundation/NSString.js";
export interface _MTL4CommandQueue {
    /**
     * Enqueues an array of command buffers for execution. The order in which you sort the command buffers in the array is meaningful, especially when it contains suspending/resuming render passes. A suspending/resuming render pass is a render pass you create by calling ``MTL4CommandBuffer/renderCommandEncoderWithDescriptor:options:``, and provide `MTL4RenderEncoderOptionSuspending` or `MTL4RenderEncoderOptionResuming` for the `options` parameter. If your command buffers contain suspend/resume render passes, ensure that the first command buffer only suspends, and the last one only resumes. Additionally, make sure that all intermediate command buffers are both suspending and resuming. - Parameters: - commandBuffers: an array of ``MTL4CommandBuffer``. - count: the number of ``MTL4CommandBuffer`` instances in the `commandBuffers` array.
     */
    commit$count$?(commandBuffers: NobjcObject, count: number): void;
    /**
     * Enqueues an array of command buffer instances for execution with a set of options. Provide an ``MTL4CommitOptions`` instance to configure the commit operation. The order in which you sort the command buffers in the array is meaningful, especially when it contains suspending/resuming render passes. A suspending/resuming render pass is a render pass you create by calling ``MTL4CommandBuffer/renderCommandEncoderWithDescriptor:options:``, and provide `MTL4RenderEncoderOptionSuspending` or `MTL4RenderEncoderOptionResuming` for the `options` parameter. If your command buffers contain suspend/resume render passes, ensure that the first command buffer only suspends, and the last one only resumes. Additionally, make sure that all intermediate command buffers are both suspending and resuming. When you commit work from multiple threads, modifying and reusing the same options instance, you are responsible for externally synchronizing access to it. - Parameters: - commandBuffers: an array of ``MTL4CommandBuffer``. - count: the number of ``MTL4CommandBuffer`` instances in the `commandBuffers` array. - options: an instance of ``MTL4CommitOptions`` that configures the commit operation.
     */
    commit$count$options$?(commandBuffers: NobjcObject, count: number, options: _MTL4CommitOptions): void;
    /**
     * Schedules an operation to signal a GPU event with a specific value after all GPU work prior to this point is complete. - Parameters: - event: ``MTLEvent`` to signal. - value: the value to signal the ``MTLEvent`` with.
     */
    signalEvent$value$?(event: _MTLEvent, value: number): void;
    /**
     * Schedules an operation to wait for a GPU event of a specific value before continuing to execute any future GPU work. - Parameters: - event: ``MTLEvent`` to wait on. - value: the specific value to wait for.
     */
    waitForEvent$value$?(event: _MTLEvent, value: number): void;
    /**
     * Schedules a signal operation on the command queue to indicate when rendering to a Metal drawable is complete. Signaling when rendering to a ``MTLDrawable`` instance is complete indicates that it's safe to present it to the display. You are responsible for calling this method after committing all command buffers that contain commands targeting this drawable, and before calling ``MTLDrawable/present``, ``MTLDrawable/presentAtTime:``, or ``MTLDrawable/presentAfterMinimumDuration:``. - Note: This method doesn't trigger the presentation of the drawable, and fails if you call it after any of the present methods, or if you call it multiple times. Metal doesn't guarantee that command buffers you commit to the command queue after calling this method execute before presentation. - Parameters: - drawable: ``MTLDrawable`` instance to signal.
     */
    signalDrawable$?(drawable: _MTLDrawable): void;
    /**
     * Schedules a wait operation on the command queue to ensure the display is no longer using a specific Metal drawable. Use this method to ensure the display is no longer using a ``MTLDrawable`` instance before executing any subsequent commands. This method returns immediately and doesn't perform any synchronization on the current thread. You are responsible for calling this method before committing any command buffers containing commands that target this drawable. Call this method multiple times if you commit your command buffers to multiple command queues. - Parameters: - drawable: ``MTLDrawable`` instance to signal.
     */
    waitForDrawable$?(drawable: _MTLDrawable): void;
    /**
     * Marks a residency set as part of this command queue. Ensures that Metal makes the residency set resident during the execution of all command buffers you commit to this command queue. Each command queue supports up to 32 unique residency set instances. - Parameter residencySet: ``MTLResidencySet`` to add to the command queue.
     */
    addResidencySet$?(residencySet: _MTLResidencySet): void;
    /**
     * Marks an array of residency sets as part of this command queue. Ensures that Metal makes the residency set resident during the execution of all command buffers you commit to this command queue. Each command queue supports up to 32 unique residency set instances. - Parameters: - residencySets: Array of ``MTLResidencySet`` instances to add to the command queue. - count: Number of ``MTLResidencySet`` instances in the array.
     */
    addResidencySets$count$?(residencySets: NobjcObject, count: number): void;
    /**
     * Removes a residency set from the command queue. After calling this method ensures only the remaining residency sets remain resident during the execution of the command buffers you commit this command queue. - Parameter residencySet: ``MTLResidencySet`` instance to remove from the command queue.
     */
    removeResidencySet$?(residencySet: _MTLResidencySet): void;
    /**
     * Removes multiple residency sets from the command queue. After calling this method ensures only the remaining residency sets remain resident during the execution of the command buffers you commit this command queue. - Parameters: - residencySets: Array of ``MTLResidencySet`` instances to remove from the command queue. - count: Number of ``MTLResidencySet`` instances in the array.
     */
    removeResidencySets$count$?(residencySets: NobjcObject, count: number): void;
    /**
     * Updates multiple regions within a placement sparse texture to alias specific tiles of a Metal heap. You can provide a `nil` parameter to the `heap` argument only if when you perform unmap operations. Otherwise, you are responsible for ensuring the heap is non-nil and has a ``MTLHeapDescriptor/maxCompatiblePlacementSparsePageSize`` of at least the texture's ``MTLTextureDescriptor/placementSparsePageSize``. When performing a sparse mapping update, you are responsible for issuing a barrier against stage `MTLStageResourceState`. You can determine the sparse texture tier by calling `MTLTexture/sparseTextureTier`. - Parameters: - texture: A placement sparse ``MTLTexture``. - heap: ``MTLHeap`` you allocate with type ``MTLHeapType/MTLHeapTypePlacement``. - operations: An array of ``MTL4UpdateSparseTextureMappingOperation`` instances to perform. - count: Number of operations to perform.
     */
    updateTextureMappings$heap$operations$count$?(texture: _MTLTexture, heap: _MTLHeap | null, operations: NobjcObject, count: number): void;
    /**
     * Copies multiple regions within a source placement sparse texture to a destination placement sparse texture. You are responsible for ensuring the source and destination textures have the same ``MTLTextureDescriptor/placementSparsePageSize``. Additionally, you are responsible for ensuring that the source and destination textures don't use the same aliased tiles at the same time. - Note: If a sparse texture and a sparse buffer share the same backing tiles, these don't provide you you with meaningful views of the other resource’s data. - Parameters: - sourceTexture: The source placement sparse ``MTLTexture``. - destinationTexture: The destination placement sparse ``MTLTexture``. - operations: An array of ``MTL4CopySparseTextureMappingOperation`` instances to perform. - count: Number of operations to perform.
     */
    copyTextureMappingsFromTexture$toTexture$operations$count$?(sourceTexture: _MTLTexture, destinationTexture: _MTLTexture, operations: NobjcObject, count: number): void;
    /**
     * Updates multiple regions within a placement sparse buffer to alias specific tiles from a Metal heap. You can provide a `nil` parameter to the `heap` argument only when you perform unmap operations. Otherwise, you are responsible for ensuring parameter `heap` references an ``MTLHeap`` that has a ``MTLHeapDescriptor/maxCompatiblePlacementSparsePageSize`` of at least the buffer's `placementSparsePageSize` you assign when creating the sparse buffer via ``MTLDevice/newBufferWithLength:options:placementSparsePageSize:``. - Parameters: - buffer: A placement sparse ``MTLBuffer``. - heap: An ``MTLHeap`` you allocate with type ``MTLHeapType/MTLHeapTypePlacement``. - operations: An array of ``MTL4UpdateSparseBufferMappingOperation`` instances to perform. - count: Number of operations to perform.
     */
    updateBufferMappings$heap$operations$count$?(buffer: _MTLBuffer, heap: _MTLHeap | null, operations: NobjcObject, count: number): void;
    /**
     * Copies multiple offsets within a source placement sparse buffer to a destination placement sparse buffer. You are responsible for ensuring the source destination sparse buffers have the same `placementSparsePageSize` when you create them via ``MTLDevice/newBufferWithLength:options:placementSparsePageSize:``. Additionally, you are responsible for ensuring both the source and destination sparse buffers don't use the same aliased tiles at the same time. - Note: If a sparse texture and a sparse buffer share the same backing tiles, these don't provide you with meaningful views of the other resource’s data. - Parameters: - sourceBuffer: The source placement sparse ``MTLBuffer``. - destinationBuffer: The destination placement sparse ``MTLBuffer``. - operations: An array of ``MTL4CopySparseBufferMappingOperation`` instances to perform. - count: Number of operations to perform.
     */
    copyBufferMappingsFromBuffer$toBuffer$operations$count$?(sourceBuffer: _MTLBuffer, destinationBuffer: _MTLBuffer, operations: NobjcObject, count: number): void;
    /** Returns the GPU device that the command queue belongs to. */
    device?(): _MTLDevice;
    /** Obtains this queue's optional label for debugging purposes. */
    label?(): _NSString | null;
}
