objcjs-types 0.7.0 → 0.7.2

package/dist/Metal/MTL4RenderCommandEncoder.d.ts

@@ -24,161 +24,161 @@ export interface _MTL4RenderCommandEncoder extends _MTL4CommandEncoder {
     /**
      * Sets the mapping from logical shader color output to physical render pass color attachments. Use this method to define how the physical color attachments you specify via ``MTL4RenderPassDescriptor/colorAttachments`` map to the logical color output the fragment shader writes to. To use this feature, make sure to set ``MTL4RenderPassDescriptor/supportColorAttachmentMapping`` to <doc ://com.apple.documentation/documentation/swift/true>. - Parameter mapping: Mapping from logical shader outputs to physical outputs.
      */
-    setColorAttachmentMap$?(mapping: _MTLLogicalToPhysicalColorAttachmentMap | null): void;
+    setColorAttachmentMap$(mapping: _MTLLogicalToPhysicalColorAttachmentMap | null): void;
     /**
      * Configures this encoder with a render pipeline state that applies to your subsequent draw commands. - Parameter pipelineState: a non-`nil` ``MTLRenderPipelineState`` instance.
      */
-    setRenderPipelineState$?(pipelineState: _MTLRenderPipelineState): void;
+    setRenderPipelineState$(pipelineState: _MTLRenderPipelineState): void;
     /**
      * Sets the viewport which that transforms vertices from normalized device coordinates to window coordinates. Metal clips fragments that lie outside this viewport, and optionally clamps fragments outside of z-near/z-far range depending on the value you assign to ``setDepthClipMode:``. - Parameter viewport: ``MTLViewport`` to set.
      */
-    setViewport$?(viewport: MTLViewport): void;
+    setViewport$(viewport: MTLViewport): void;
     /**
      * Sets an array of viewports to transform vertices from normalized device coordinates to window coordinates. Metal clips fragments that lie outside of the viewport, and optionally clamps fragments outside of z-near/z-far range, depending on the value you assign to ``setDepthClipMode:``. Metal selects the viewport to use from the `[[ viewport_array_index ]]` attribute you specify in the pipeline state's vertex shader function in the Metal Shading Language. - Parameters: - viewports: Array of ``MTLViewport`` instances. - count: Number of ``MTLViewport`` instances in the array.
      */
-    setViewports$count$?(viewports: NobjcObject, count: number): void;
+    setViewports$count$(viewports: NobjcObject, count: number): void;
     /**
      * Sets the vertex amplification count and its view mapping for each amplification ID. Each view mapping element describes how to route the corresponding amplification ID to a specific viewport and render target array index by using offsets from the base array index provided by the `[[ render_target_array_index ]]` and/or `[[ viewport_array_index ]]` output attributes in the vertex shader. This allows Metal to route each amplified vertex to a different `[[ render_target_array_index ]]` and `[[ viewport_array_index ]]`, even though you can't directly amplify these attributes. - Parameters: - count: The number of outputs to create. The maximum value is `2`. - viewMappings: Array of ``MTLVertexAmplificationViewMapping`` instances. Each instance provides per-output offsets to a specific render target and viewport.
      */
-    setVertexAmplificationCount$viewMappings$?(count: number, viewMappings: NobjcObject | null): void;
+    setVertexAmplificationCount$viewMappings$(count: number, viewMappings: NobjcObject | null): void;
     /**
      * Controls whether Metal culls front facing primitives, back facing primitives, or culls no primitives at all. - Parameter cullMode: ``MTLCullMode`` to set.
      */
-    setCullMode$?(cullMode: MTLCullMode): void;
+    setCullMode$(cullMode: MTLCullMode): void;
     /**
      * Controls the behavior for fragments outside of the near or far planes. - Parameter depthClipMode: ``MTLDepthClipMode`` to set.
      */
-    setDepthClipMode$?(depthClipMode: MTLDepthClipMode): void;
+    setDepthClipMode$(depthClipMode: MTLDepthClipMode): void;
     /**
      * Configures the adjustments a render pass applies to depth values from fragment shader functions by a scaling factor and bias. - Parameters: - depthBias: A constant bias the render pipeline applies to all fragments. - slopeScale: A bias coefficient that scales with the depth of the primitive relative to the camera. - clamp: A value that limits the bias value the render pipeline can apply to a fragment. Pass a positive or negative value to limit the largest magnitude of a positive or negative bias, respectively. Set this value to `0` to disable bias clamping.
      */
-    setDepthBias$slopeScale$clamp$?(depthBias: number, slopeScale: number, clamp: number): void;
+    setDepthBias$slopeScale$clamp$(depthBias: number, slopeScale: number, clamp: number): void;
     /**
      * Configures the minimum and maximum bounds for depth bounds testing. The render command encoder disables depth bounds testing by default. The render command encoder also disables depth bounds testing when all of the following properties equal a specific value: - The `minBound` property is equal to `0.0f`. - The `maxBound` property is equal to `1.0f`. Both `minBound` and `maxBound` need to be within `[0.0f, 1.0f]`, and `minBound` needs to be less than or equal to `maxBound`. - Parameters: - minBound: A minimum bound for depth testing, which discards fragments with a stored depth that is less than `minBound`. - maxBound: A maximum bound for depth testing, which discards fragments with a stored depth that is greater than `maxBound`.
      */
-    setDepthTestMinBound$maxBound$?(minBound: number, maxBound: number): void;
+    setDepthTestMinBound$maxBound$(minBound: number, maxBound: number): void;
     /**
      * Sets a scissor rectangle to discard fragments outside a specific area. Metal performs a scissor test and discards all fragments outside of the scissor rect. - Parameter rect: ``MTLScissorRect`` rectangle to specify. This rectangle needs to lie completely within the current render attachment.
      */
-    setScissorRect$?(rect: MTLScissorRect): void;
+    setScissorRect$(rect: MTLScissorRect): void;
     /**
      * Sets an array of scissor rectangles for a fragment scissor test. Metal uses the specific scissor rectangle corresponding to the index you specify via the `[[ viewport_array_index ]]` output attribute of the vertex shader function in the Metal Shading Language, discarding all fragments outside of the scissor rect. - Parameters: - scissorRects: Array of ``MTLScissorRect`` structures. - count: Number of ``MTLScissorRect`` structures in the array.
      */
-    setScissorRects$count$?(scissorRects: NobjcObject, count: number): void;
+    setScissorRects$count$(scissorRects: NobjcObject, count: number): void;
     /**
      * Configures how subsequent draw commands rasterize triangle and triangle strip primitives. - Parameter fillMode:``MTLTriangleFillMode`` the render pass applies to draw commands that rasterize triangles or triangle strips.
      */
-    setTriangleFillMode$?(fillMode: MTLTriangleFillMode): void;
+    setTriangleFillMode$(fillMode: MTLTriangleFillMode): void;
     /**
      * Configures each pixel component value, including alpha, for the render pipeline’s constant blend color. - Parameters: - red: A value for the red component for the blend color constant. - green: A value for the green component for the blend color constant. - blue: A value for the blue component for the blend color constant. - alpha: A value for the alpha component for the blend color constant.
      */
-    setBlendColorRed$green$blue$alpha$?(red: number, green: number, blue: number, alpha: number): void;
+    setBlendColorRed$green$blue$alpha$(red: number, green: number, blue: number, alpha: number): void;
     /**
      * Configures this encoder with a depth stencil state that applies to your subsequent draw commands. - Parameter depthStencilState: the ``MTLDepthStencilState`` instance to set.
      */
-    setDepthStencilState$?(depthStencilState: _MTLDepthStencilState | null): void;
+    setDepthStencilState$(depthStencilState: _MTLDepthStencilState | null): void;
     /**
      * Configures this encoder with a reference value for stencil testing. The render pipeline applies this reference value to both front-facing and back-facing primitives. - Parameter referenceValue: A stencil test comparison value.
      */
-    setStencilReferenceValue$?(referenceValue: number): void;
+    setStencilReferenceValue$(referenceValue: number): void;
     /**
      * Configures the encoder with different stencil test reference values for front-facing and back-facing primitives. The render pipeline applies `frontReferenceValue` to front-facing primitives and `backReferenceValue` to back-facing primitives. - Parameters: - frontReferenceValue: A stencil test comparison value the render pipeline applies to front-facing primitives. - backReferenceValue: A stencil test comparison value the render pipeline applies to back-facing primitives.
      */
-    setStencilFrontReferenceValue$backReferenceValue$?(frontReferenceValue: number, backReferenceValue: number): void;
+    setStencilFrontReferenceValue$backReferenceValue$(frontReferenceValue: number, backReferenceValue: number): void;
     /**
      * Configures a visibility test for Metal to run, and the destination for any results it generates. You use the `mode` parameter to enable or disable the visibility test, and determine if it produces a boolean response for passing fragments, or if it counts the number of fragments. - Parameters: - mode: A ``MTLVisibilityResultMode`` that configures which visibility test results the render pass saves to a buffer, or disables visibility testing. - offset: A location, in bytes, relative to the start of ``MTL4RenderPassDescriptor/visibilityResultBuffer`` The GPU stores the result of a visibility test at `offset`, which needs to be a multiple of `8`.
      */
-    setVisibilityResultMode$offset$?(mode: MTLVisibilityResultMode, offset: number): void;
+    setVisibilityResultMode$offset$(mode: MTLVisibilityResultMode, offset: number): void;
     /**
      * Configures the store action for a color attachment. - Parameters: - storeAction: A store action for the color attachment that can’t be ``MTLStoreAction/MTLStoreActionUnknown``. - colorAttachmentIndex: The index of a color attachment.
      */
-    setColorStoreAction$atIndex$?(storeAction: MTLStoreAction, colorAttachmentIndex: number): void;
+    setColorStoreAction$atIndex$(storeAction: MTLStoreAction, colorAttachmentIndex: number): void;
     /**
      * Configures the store action for the depth attachment. - Parameter storeAction: A store action for the depth attachment that can’t be ``MTLStoreAction/MTLStoreActionUnknown``.
      */
-    setDepthStoreAction$?(storeAction: MTLStoreAction): void;
+    setDepthStoreAction$(storeAction: MTLStoreAction): void;
     /**
      * Configures the store action for the stencil attachment. - Parameter storeAction: A store action for the stencil attachment that can’t be ``MTLStoreAction/MTLStoreActionUnknown``.
      */
-    setStencilStoreAction$?(storeAction: MTLStoreAction): void;
+    setStencilStoreAction$(storeAction: MTLStoreAction): void;
     /**
      * Encodes a draw command that renders an instance of a geometric primitive. This command assigns each vertex a unique `vertex_id` value that increases from `vertexStart` through `(vertexStart + vertexCount - 1)`. Your vertex shader function can use this value to uniquely identify each vertex. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - vertexStart: The lowest value the command passes to your vertex shader function’s parameter with the `[[vertex_id]]` attribute. - vertexCount: An integer that represents the number of vertices of `primitiveType` the command draws.
      */
-    drawPrimitives$vertexStart$vertexCount$?(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number): void;
+    drawPrimitives$vertexStart$vertexCount$(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive. The command assigns each vertex a unique `vertex_id` value within its drawing instance that increases from `vertexStart` through `(vertexStart + vertexCount - 1)`. Additionally, the command assigns each drawing instance a unique `instance_id` value that increases from `0` through `(instanceCount - 1)`. Your vertex shader can use the `vertex_id` value to uniquely identify each vertex in each drawing instance, and the `instance_id` value to identify which instance that vertex belongs to. - Parameters: - primitiveType: A ``MTLPrimitiveType`` represents how the command interprets vertex argument data. - vertexStart: The lowest value the command passes to your vertex shader function’s parameter with the `vertex_id` attribute. - vertexCount: An integer that represents the number of vertices of `primitiveType` the command draws. - instanceCount: An integer that represents the number of times the command draws `primitiveType` primitives with `vertexCount` vertices.
      */
-    drawPrimitives$vertexStart$vertexCount$instanceCount$?(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number, instanceCount: number): void;
+    drawPrimitives$vertexStart$vertexCount$instanceCount$(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number, instanceCount: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive, starting with a custom instance identification number. The command assigns each vertex a unique `vertex_id` value within its drawing instance that increases from `vertexStart` through `(vertexStart + vertexCount - 1)`. Additionally, the command assigns each drawing instance a unique `instance_id` value that increases from `baseInstance` through `(baseInstance + instanceCount - 1)`. Your vertex shader can use the `vertex_id` value to uniquely identify each vertex in each drawing instance, and the `instance_id` value to identify which instance that vertex belongs to. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - vertexStart: The lowest value the command passes to your vertex shader function’s parameter with the `vertex_id` attribute. - vertexCount: An integer that represents the number of vertices of `primitiveType` the command draws. - instanceCount: An integer that represents the number of times the command draws `primitiveType` with `vertexCount` vertices. - baseInstance: The lowest value the command passes to your vertex shader function’s parameter with the `instance_id` attribute.
      */
-    drawPrimitives$vertexStart$vertexCount$instanceCount$baseInstance$?(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number, instanceCount: number, baseInstance: number): void;
+    drawPrimitives$vertexStart$vertexCount$instanceCount$baseInstance$(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number, instanceCount: number, baseInstance: number): void;
     /**
      * Encodes a draw command that renders an instance of a geometric primitive with indexed vertices. Use this method to perform indexed drawing, where an index buffer determines how Metal assembles primitives. Metal imposes some restrictions on the index buffer's address, which needs to be 2- or 4-byte aligned, and its length in bytes, which needs to be a multiple of 2 or 4, depending on whether the format of the index is ``MTLIndexType/MTLIndexTypeUInt16`` or ``MTLIndexType/MTLIndexTypeUInt32``. Use an instance of ``MTLResidencySet`` to mark residency of the index buffer the `indexBuffer` parameter references. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - indexCount: An integer that represents the number of vertices the command reads from `indexBuffer`. - indexType: A ``MTLIndexType`` instance that represents the index format. - indexBuffer: GPUAddress of a ``MTLBuffer`` instance that contains `indexCount` indices of `indexType` format. You are responsible for ensuring this address is aligned to 2 bytes if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and aligned to 4 bytes if the format is ``MTLIndexType/MTLIndexTypeUInt32``. - indexBufferLength: An integer that represents the length of `indexBuffer`, in bytes. You are responsible for ensuring this this size is a multiple of 2 if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and a multiple of 4 if the format is ``MTLIndexType/MTLIndexTypeUInt32``. If this draw call causes Metal to read indices at or beyond the `indexBufferLength`, Metal continues to execute them assigning a value of `0` to the `vertex_id` attribute.
      */
-    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$?(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number): void;
+    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive with indexed vertices. Use this method to perform instanced indexed drawing, where an index buffer determines how Metal assembles primitives. The command assigns each drawing instance a unique `instance_id` value that increases from `0` through `(instanceCount - 1)`. Your shader can use this value to identify which instance the vertex belongs to. Metal imposes some restrictions on the index buffer's address, which needs to be 2- or 4-byte aligned, and its length in bytes, which needs to be a multiple of 2 or 4, depending on whether the format of the index is ``MTLIndexType/MTLIndexTypeUInt16`` or ``MTLIndexType/MTLIndexTypeUInt32``. Use an instance of ``MTLResidencySet`` to mark residency of the index buffer the `indexBuffer` parameter references. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - indexCount: An integer that represents the number of vertices the command reads from `indexBuffer`. - indexType: A ``MTLIndexType`` instance that represents the index format. - indexBuffer: GPUAddress of a ``MTLBuffer`` instance that contains `indexCount` indices of `indexType` format. You are responsible for ensuring this address is aligned to 2 bytes if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and aligned to 4 bytes if the format is ``MTLIndexType/MTLIndexTypeUInt32``. - indexBufferLength: An integer that represents the length of `indexBuffer`, in bytes. You are responsible for ensuring this this size is a multiple of 2 if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and a multiple of 4 if the format is ``MTLIndexType/MTLIndexTypeUInt32``. Metal disregards this value and assigns `0` to the `vertex_id` attribute for all primitives that require loading indices at a byte offset of `indexBufferLength` or greater. - instanceCount: An integer that represents the number of times the command draws `primitiveType` with `indexCount` vertices.
      */
-    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$instanceCount$?(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, instanceCount: number): void;
+    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$instanceCount$(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, instanceCount: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive with indexed vertices, starting with a custom vertex and instance. Use this method to perform instanced indexed drawing, where an index buffer determines how Metal assembles primitives whilst customizing the base vertex and base instance value Metal passes to the vertex shader function. The command assigns each drawing instance a unique `instance_id` value that increases from `baseInstance` through `(baseInstance + instanceCount - 1)`. Your shader can use this value to identify which instance the vertex belongs to. Metal imposes some restrictions on the index buffer's address, which needs to be 2- or 4-byte aligned, and its length in bytes, which needs to be a multiple of 2 or 4, depending on whether the format of the index is ``MTLIndexType/MTLIndexTypeUInt16`` or ``MTLIndexType/MTLIndexTypeUInt32``. Use an instance of ``MTLResidencySet`` to mark residency of the index buffer the `indexBuffer` parameter references. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - indexCount: An integer that represents the number of vertices the command reads from `indexBuffer`. - indexType: A ``MTLIndexType`` instance that represents the index format. - indexBuffer: GPUAddress of a ``MTLBuffer`` instance that contains `indexCount` indices of `indexType` format. You are responsible for ensuring this address is aligned to 2 bytes if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and aligned to 4 bytes if the format is ``MTLIndexType/MTLIndexTypeUInt32``. - indexBufferLength: An integer that represents the length of `indexBuffer`, in bytes. You are responsible for ensuring this this size is a multiple of 2 if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and a multiple of 4 if the format is ``MTLIndexType/MTLIndexTypeUInt32``. If this draw call causes Metal to read indices at or beyond the `indexBufferLength`, Metal continues to execute them assigning a value of `0` to the `vertex_id` attribute. - instanceCount: An integer that represents the number of times the command draws `primitiveType` with `indexCount` vertices. - baseVertex: The lowest value the command passes to your vertex shader functions’s parameter with the `vertex_id` attribute. Metal disregards this value and assigns `0` to the `vertex_id` attribute for all primitives that require loading indices at a byte offset of `indexBufferLength` or greater. - baseInstance: The lowest value the command passes to your vertex shader’s parameter with the `instance_id` attribute.
      */
-    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$instanceCount$baseVertex$baseInstance$?(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, instanceCount: number, baseVertex: number, baseInstance: number): void;
+    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$instanceCount$baseVertex$baseInstance$(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, instanceCount: number, baseVertex: number, baseInstance: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive with indirect arguments. When you use this function, Metal reads the parameters to the draw command from an ``MTLBuffer`` instance, allowing you to implement a GPU-driven workflow where a compute pipeline state determines the draw arguments. You are responsible for ensuring that the address of the indirect buffer you provide to this method has 4-byte alignment. Because this is a non-indexed draw call, Metal interprets the contents of the indirect buffer to match the layout of struct ``MTLDrawPrimitivesIndirectArguments``. Use an instance of ``MTLResidencySet`` to mark residency of the indirect buffer that the `indirectBuffer` parameter references. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - indirectBuffer: GPUAddress of a ``MTLBuffer`` instance with data that matches the layout of the ``MTLDrawPrimitivesIndirectArguments`` structure. You are responsible for ensuring that the alignment of this address is 4 bytes.
      */
-    drawPrimitives$indirectBuffer$?(primitiveType: MTLPrimitiveType, indirectBuffer: number): void;
+    drawPrimitives$indirectBuffer$(primitiveType: MTLPrimitiveType, indirectBuffer: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive with indexed vertices and indirect arguments. When you use this function, Metal reads the parameters to the draw command from an ``MTLBuffer`` instance, allowing you to implement a GPU-driven workflow where a compute pipeline state determines the draw arguments. Because this is an indexed draw call, Metal interprets the contents of the indirect buffer to match the layout of struct ``MTLDrawIndexedPrimitivesIndirectArguments``, which includes `indexStart` and `indexCount` members, denoting a range within the index buffer you provide in the `indexBuffer` parameter. The range of indices within the `indexBuffer` form the primitives Metal draws. Metal imposes some restrictions on the index buffer's address, which needs to be 2- or 4-byte aligned, and its length in bytes, which needs to be a multiple of 2 or 4, depending on whether the format of the index is ``MTLIndexType/MTLIndexTypeUInt16`` or ``MTLIndexType/MTLIndexTypeUInt32``. Similarly, you are responsible for ensuring the indirect buffer's address has 4-byte alignment. Use an instance of ``MTLResidencySet`` to mark residency of the indirect buffer that the `indirectBuffer` parameter references, and of the index buffer the `indexBuffer` parameter references. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - indexType: A ``MTLIndexType`` instance that represents the index format. - indexBuffer: GPUAddress of a ``MTLBuffer`` instance that contains `indexCount` indices of `indexType` format. You are responsible for ensuring this address is aligned to 2 bytes if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and aligned to 4 bytes if the format is ``MTLIndexType/MTLIndexTypeUInt32``. - indexBufferLength: An integer that represents the length of `indexBuffer`, in bytes. You are responsible for ensuring this this size is a multiple of 2 if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and a multiple of 4 if the format is ``MTLIndexType/MTLIndexTypeUInt32``. If this draw call causes Metal to read indices at or beyond the `indexBufferLength`, Metal continues to execute them assigning a value of `0` to the `vertex_id` attribute. - indirectBuffer: GPUAddress of an ``MTLBuffer`` instance with data that matches the layout of the ``MTLDrawIndexedPrimitivesIndirectArguments`` structure. This address requires 4-byte alignment.
      */
-    drawIndexedPrimitives$indexType$indexBuffer$indexBufferLength$indirectBuffer$?(primitiveType: MTLPrimitiveType, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, indirectBuffer: number): void;
+    drawIndexedPrimitives$indexType$indexBuffer$indexBufferLength$indirectBuffer$(primitiveType: MTLPrimitiveType, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, indirectBuffer: number): void;
     /**
      * Encodes a command that runs a range of commands from an indirect command buffer. - Parameters: - indirectCommandBuffer: A ``MTLIndirectCommandBuffer`` instance containing other commands that the current command runs. - executionRange: A span of integers that represent the command entries in the buffer that the current command runs.
      */
-    executeCommandsInBuffer$withRange$?(indirectCommandBuffer: _MTLIndirectCommandBuffer, executionRange: NSRange): void;
+    executeCommandsInBuffer$withRange$(indirectCommandBuffer: _MTLIndirectCommandBuffer, executionRange: NSRange): void;
     /**
      * Encodes a command that runs an indirect range of commands from an indirect command buffer. Use this method to indicate to Metal the span of indices in the command buffer to execute indirectly via an ``MTLBuffer`` instance you provide in the `indirectRangeBuffer` parameter. This allows you to calculate the span of commands Metal executes in the GPU timeline, enabling GPU-driven workflows. Metal requires that the contents of this buffer match the layout of struct ``MTLIndirectCommandBufferExecutionRange``, which specifies a location and a length within the indirect command buffer. You are responsible for ensuring the address of this buffer has 4-byte alignment. Use an instance of ``MTLResidencySet`` to mark residency of the indirect buffer that the `indirectRangeBuffer` parameter references. - Parameters: - indirectCommandBuffer: A ``MTLIndirectCommandBuffer`` instance that contains other commands the current command runs. - indirectRangeBuffer: GPUAddress of a ``MTLBuffer`` instance with data that matches the layout of the ``MTLIndirectCommandBufferExecutionRange`` structure. This address requires 4-byte alignment.
      */
-    executeCommandsInBuffer$indirectBuffer$?(indirectCommandBuffer: _MTLIndirectCommandBuffer, indirectRangeBuffer: number): void;
+    executeCommandsInBuffer$indirectBuffer$(indirectCommandBuffer: _MTLIndirectCommandBuffer, indirectRangeBuffer: number): void;
     /**
      * Configures the size of a threadgroup memory buffer for a threadgroup argument in the object shader function. - Parameters: - length: The size of the threadgroup memory, in bytes. - index: An integer that corresponds to the index of the argument you annotate with attribute `[[threadgroup(index)]]` in the shader function.
      */
-    setObjectThreadgroupMemoryLength$atIndex$?(length: number, index: number): void;
+    setObjectThreadgroupMemoryLength$atIndex$(length: number, index: number): void;
     /**
      * Encodes a draw command that invokes a mesh shader and, optionally, an object shader with a grid of threadgroups. - Parameters: - threadgroupsPerGrid: A ``MTLSize`` instance that represents the number of threadgroups for each grid dimension. - threadsPerObjectThreadgroup: A ``MTLSize`` instance that represents the number of threads in an object shader threadgroup, if applicable. - threadsPerMeshThreadgroup: A ``MTLSize`` instance that represents the number of threads in a mesh shader threadgroup.
      */
-    drawMeshThreadgroups$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$?(threadgroupsPerGrid: MTLSize, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
+    drawMeshThreadgroups$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$(threadgroupsPerGrid: MTLSize, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
     /**
      * Encodes a draw command that invokes a mesh shader and, optionally, an object shader with a grid of threads. - Parameters: - threadsPerGrid: A ``MTLSize`` instance that represents the number of threads for each grid dimension. For mesh shaders, the command rounds the value down to the nearest multiple of `threadsPerMeshThreadgroup` for each dimension. For object shaders, the value doesn’t need to be a multiple of `threadsPerObjectThreadgroup`. - threadsPerObjectThreadgroup: A ``MTLSize`` instance that represents the number of threads in an object shader threadgroup, if applicable. - threadsPerMeshThreadgroup: A ``MTLSize`` instance that represents the number of threads in a mesh shader threadgroup.
      */
-    drawMeshThreads$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$?(threadsPerGrid: MTLSize, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
+    drawMeshThreads$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$(threadsPerGrid: MTLSize, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
     /**
      * Encodes a draw command that invokes a mesh shader and, optionally, an object shader with indirect arguments. This method enables you to determine the number of threadgroups per grid indirectly, in the GPU timeline. Metal expects this buffer's contents to match the layout of structure ``MTLDispatchThreadgroupsIndirectArguments``. You are responsible for ensuring the address of this buffer has 4-byte alignment. Use an instance of ``MTLResidencySet`` to mark residency of the indirect buffer that the `indirectBuffer` parameter references. - Parameters: - indirectBuffer: GPUAddress of an ``MTLBuffer`` instance with data that matches the layout of the ``MTLDispatchThreadgroupsIndirectArguments`` structure. This address requires 4-byte alignment. - threadsPerObjectThreadgroup: A ``MTLSize`` instance that represents the number of threads in an object shader threadgroup, if applicable. - threadsPerMeshThreadgroup: A ``MTLSize`` instance that represents the number of threads in a mesh shader threadgroup.
      */
-    drawMeshThreadgroupsWithIndirectBuffer$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$?(indirectBuffer: number, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
+    drawMeshThreadgroupsWithIndirectBuffer$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$(indirectBuffer: number, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
     /**
      * Encodes a command that invokes a tile shader function from the encoder’s current tile render pipeline state. - Parameter threadsPerTile: A ``MTLSize`` instance that represents the number of threads the render pass uses per tile. Set the size’s ``MTLSize/width`` and ``MTLSize/height`` properties to values that are less than or equal to ``tileWidth`` and ``tileHeight``, respectively. Some GPU families only support square tile dispatches and require the same value for width and height. Set ``MTLSize/depth`` to `1`.
      */
-    dispatchThreadsPerTile$?(threadsPerTile: MTLSize): void;
+    dispatchThreadsPerTile$(threadsPerTile: MTLSize): void;
     /**
      * Configures the size of a threadgroup memory buffer for a threadgroup argument in the fragment and tile shader functions. - Parameters: - length: The size of the threadgroup memory, in bytes. - offset: An integer that represents the location, in bytes, from the start of the threadgroup memory buffer at `index` where the threadgroup memory begins. - index: An integer that corresponds to the index of the argument you annotate with attribute `[[threadgroup(index)]]` in the shader function.
      */
-    setThreadgroupMemoryLength$offset$atIndex$?(length: number, offset: number, index: number): void;
+    setThreadgroupMemoryLength$offset$atIndex$(length: number, offset: number, index: number): void;
     /**
      * Associates an argument table with a set of render stages. Metal takes a snapshot of the resources in the argument table when you encode a draw, dispatch, or execute command. This snapshot becomes available to the `stages` you specify to this method. - Parameters: - argumentTable: ``MTL4ArgumentTable`` to set. - stages: A ``MTLRenderStages`` bitmask that specifies the shader stages with visibility over the table.
      */
-    setArgumentTable$atStages$?(argumentTable: _MTL4ArgumentTable, stages: MTLRenderStages): void;
+    setArgumentTable$atStages$(argumentTable: _MTL4ArgumentTable, stages: MTLRenderStages): void;
     /**
      * Configures the vertex winding order that determines which face of a geometric primitive is the front one. - Parameter frontFacingWinding: A ``MTLWinding`` value that determines which side of a primitive the render pipeline interprets as front facing.
      */
-    setFrontFacingWinding$?(frontFacingWinding: MTLWinding): void;
+    setFrontFacingWinding$(frontFacingWinding: MTLWinding): void;
     /**
      * Writes a GPU timestamp into the given ``MTL4CounterHeap`` at `index` after `stage` completes. This command only guarantees all draws prior to this command are complete when Metal writes the timestamp into the counter heap you provide in the `counterHeap` parameter. The timestamp may also include subsequent operations. If you call this method before any draw calls, Metal writes a timestamp before the stage you specify in the `stage` parameter begins. - Parameters: - granularity: a ``MTL4TimestampGranularity`` hint. - stage: ``MTLRenderStages`` that need to complete before Metal writes the timestamp. This may also include later stages that are related, for example ``MTLRenderStages/MTLRenderStageMesh`` may include ``MTLRenderStages/MTLRenderStageVertex``. - counterHeap: ``MTL4CounterHeap`` into which Metal writes timestamps. - index: The index value into which Metal writes this timestamp.
      */
-    writeTimestampWithGranularity$afterStage$intoHeap$atIndex$?(granularity: MTL4TimestampGranularity, stage: MTLRenderStages, counterHeap: _MTL4CounterHeap, index: number): void;
+    writeTimestampWithGranularity$afterStage$intoHeap$atIndex$(granularity: MTL4TimestampGranularity, stage: MTLRenderStages, counterHeap: _MTL4CounterHeap, index: number): void;
     /** Sets the width of a tile for this render pass. */
-    tileWidth?(): number;
+    tileWidth(): number;
     /** Sets the height of a tile for this render pass. */
-    tileHeight?(): number;
+    tileHeight(): number;
 }

package/dist/Metal/MTL4RenderEncoderOptions.d.ts

@@ -3,4 +3,4 @@ export declare const MTL4RenderEncoderOptions: {
     readonly MTL4RenderEncoderOptionSuspending: 1;
     readonly MTL4RenderEncoderOptionResuming: 2;
 };
-export type MTL4RenderEncoderOptions = (number & {}) | typeof MTL4RenderEncoderOptions[keyof typeof MTL4RenderEncoderOptions];
+export type MTL4RenderEncoderOptions = (number & {}) | (typeof MTL4RenderEncoderOptions)[keyof typeof MTL4RenderEncoderOptions];

package/dist/Metal/MTL4ShaderReflection.d.ts

@@ -3,4 +3,4 @@ export declare const MTL4ShaderReflection: {
     readonly BindingInfo: 1;
     readonly BufferTypeInfo: 2;
 };
-export type MTL4ShaderReflection = (number & {}) | typeof MTL4ShaderReflection[keyof typeof MTL4ShaderReflection];
+export type MTL4ShaderReflection = (number & {}) | (typeof MTL4ShaderReflection)[keyof typeof MTL4ShaderReflection];

package/dist/Metal/MTL4TimestampGranularity.d.ts

@@ -2,4 +2,4 @@ export declare const MTL4TimestampGranularity: {
     readonly Relaxed: 0;
     readonly Precise: 1;
 };
-export type MTL4TimestampGranularity = typeof MTL4TimestampGranularity[keyof typeof MTL4TimestampGranularity];
+export type MTL4TimestampGranularity = (typeof MTL4TimestampGranularity)[keyof typeof MTL4TimestampGranularity];

package/dist/Metal/MTL4VisibilityOptions.d.ts

@@ -3,4 +3,4 @@ export declare const MTL4VisibilityOptions: {
     readonly MTL4VisibilityOptionDevice: 1;
     readonly MTL4VisibilityOptionResourceAlias: 2;
 };
-export type MTL4VisibilityOptions = (number & {}) | typeof MTL4VisibilityOptions[keyof typeof MTL4VisibilityOptions];
+export type MTL4VisibilityOptions = (number & {}) | (typeof MTL4VisibilityOptions)[keyof typeof MTL4VisibilityOptions];

package/dist/Metal/MTLAccelerationStructure.d.ts

@@ -1,9 +1,9 @@
 import type { _MTLResource } from "./MTLResource.js";
 import type { MTLResourceID } from "../structs/MTLResourceID.js";
 export interface _MTLAccelerationStructure extends _MTLResource {
-    size?(): number;
+    size(): number;
     /**
      * @property gpuResourceID @abstract Handle of the GPU resource suitable for storing in an Argument Buffer
      */
-    gpuResourceID?(): MTLResourceID;
+    gpuResourceID(): MTLResourceID;
 }

package/dist/Metal/MTLAccelerationStructureCommandEncoder.d.ts

@@ -14,57 +14,57 @@ export interface _MTLAccelerationStructureCommandEncoder extends _MTLCommandEnco
     /**
      * Encode an acceleration structure build into the command buffer. All bottom-level acceleration structure builds must have completed before a top-level acceleration structure build may begin. The resulting acceleration structure will not retain any references to the input vertex buffer, instance buffer, etc. The acceleration structure build will not be completed until the command buffer has been committed and finished executing. However, it is safe to encode ray tracing work against the acceleration structure as long as the command buffers are scheduled and synchronized such that the command buffer will have completed by the time the ray tracing starts. The acceleration structure and scratch buffer must be at least the size returned by the [MTLDevice accelerationStructureSizesWithDescriptor:] query. Acceleration structure storage to build into Object describing the acceleration structure to build Scratch buffer to use while building the acceleration structure. The contents may be overwritten and are undefined after the build has started/completed. Offset into the scratch buffer
      */
-    buildAccelerationStructure$descriptor$scratchBuffer$scratchBufferOffset$?(accelerationStructure: _MTLAccelerationStructure, descriptor: _MTLAccelerationStructureDescriptor, scratchBuffer: _MTLBuffer, scratchBufferOffset: number): void;
+    buildAccelerationStructure$descriptor$scratchBuffer$scratchBufferOffset$(accelerationStructure: _MTLAccelerationStructure, descriptor: _MTLAccelerationStructureDescriptor, scratchBuffer: _MTLBuffer, scratchBufferOffset: number): void;
     /**
      * Encode an acceleration structure refit into the command buffer. Refitting can be used to update the acceleration structure when geometry changes and is much faster than rebuilding from scratch. However, the quality of the acceleration structure and the subsequent ray tracing performance will degrade depending on how much the geometry changes. Refitting can not be used after certain changes, such as adding or removing geometry. Acceleration structures can be refit in place by specifying the same source and destination acceleration structures or by providing a nil destination acceleration structure. If the source and destination acceleration structures are not the same, they must not overlap in memory. The destination acceleration structure must be at least as large as the source acceleration structure, unless the source acceleration structure has been compacted, in which case the destination acceleration structure must be at least as large as the compacted size of the source acceleration structure. The scratch buffer must be at least the size returned by the accelerationStructureSizesWithDescriptor method of the MTLDevice. Object describing the acceleration structure to build Acceleration structure to copy from Acceleration structure to copy to Scratch buffer to use while refitting the acceleration structure. The contents may be overwritten and are undefined after the refit has started/completed. Offset into the scratch buffer.
      */
-    refitAccelerationStructure$descriptor$destination$scratchBuffer$scratchBufferOffset$?(sourceAccelerationStructure: _MTLAccelerationStructure, descriptor: _MTLAccelerationStructureDescriptor, destinationAccelerationStructure: _MTLAccelerationStructure | null, scratchBuffer: _MTLBuffer | null, scratchBufferOffset: number): void;
+    refitAccelerationStructure$descriptor$destination$scratchBuffer$scratchBufferOffset$(sourceAccelerationStructure: _MTLAccelerationStructure, descriptor: _MTLAccelerationStructureDescriptor, destinationAccelerationStructure: _MTLAccelerationStructure | null, scratchBuffer: _MTLBuffer | null, scratchBufferOffset: number): void;
     /**
      * Encode an acceleration structure refit into the command buffer. Refitting can be used to update the acceleration structure when geometry changes and is much faster than rebuilding from scratch. However, the quality of the acceleration structure and the subsequent ray tracing performance will degrade depending on how much the geometry changes. Refitting can not be used after certain changes, such as adding or removing geometry. Acceleration structures can be refit in place by specifying the same source and destination acceleration structures or by providing a nil destination acceleration structure. If the source and destination acceleration structures are not the same, they must not overlap in memory. The destination acceleration structure must be at least as large as the source acceleration structure, unless the source acceleration structure has been compacted, in which case the destination acceleration structure must be at least as large as the compacted size of the source acceleration structure. The scratch buffer must be at least the size returned by the accelerationStructureSizesWithDescriptor method of the MTLDevice. Object describing the acceleration structure to build Acceleration structure to copy from Acceleration structure to copy to Scratch buffer to use while refitting the acceleration structure. The contents may be overwritten and are undefined after the refit has started/completed. Offset into the scratch buffer. Options specifying the elements of the acceleration structure to refit.
      */
-    refitAccelerationStructure$descriptor$destination$scratchBuffer$scratchBufferOffset$options$?(sourceAccelerationStructure: _MTLAccelerationStructure, descriptor: _MTLAccelerationStructureDescriptor, destinationAccelerationStructure: _MTLAccelerationStructure | null, scratchBuffer: _MTLBuffer | null, scratchBufferOffset: number, options: MTLAccelerationStructureRefitOptions): void;
+    refitAccelerationStructure$descriptor$destination$scratchBuffer$scratchBufferOffset$options$(sourceAccelerationStructure: _MTLAccelerationStructure, descriptor: _MTLAccelerationStructureDescriptor, destinationAccelerationStructure: _MTLAccelerationStructure | null, scratchBuffer: _MTLBuffer | null, scratchBufferOffset: number, options: MTLAccelerationStructureRefitOptions): void;
     /**
      * Copy an acceleration structure. The source and destination acceleration structures must not overlap in memory. If this is a top level acceleration structure, references to bottom level acceleration structures will be preserved. The destination acceleration structure must be at least as large as the source acceleration structure, unless the source acceleration structure has been compacted, in which case the destination acceleration structure must be at least as large as the compacted size of the source acceleration structure. Acceleration structure to copy from Acceleration structure to copy to
      */
-    copyAccelerationStructure$toAccelerationStructure$?(sourceAccelerationStructure: _MTLAccelerationStructure, destinationAccelerationStructure: _MTLAccelerationStructure): void;
+    copyAccelerationStructure$toAccelerationStructure$(sourceAccelerationStructure: _MTLAccelerationStructure, destinationAccelerationStructure: _MTLAccelerationStructure): void;
     /**
      * Compute the compacted size for an acceleration structure and write it into a buffer. This size is potentially smaller than the source acceleration structure. To perform compaction, read this size from the buffer once the command buffer has completed and use it to allocate a smaller acceleration structure. Then create another encoder and call the copyAndCompactAccelerationStructure method. Source acceleration structure Destination size buffer. The compacted size will be written as a 32 bit unsigned integer representing the compacted size in bytes. Offset into the size buffer
      */
-    writeCompactedAccelerationStructureSize$toBuffer$offset$?(accelerationStructure: _MTLAccelerationStructure, buffer: _MTLBuffer, offset: number): void;
+    writeCompactedAccelerationStructureSize$toBuffer$offset$(accelerationStructure: _MTLAccelerationStructure, buffer: _MTLBuffer, offset: number): void;
     /**
      * Compute the compacted size for an acceleration structure and write it into a buffer. This size is potentially smaller than the source acceleration structure. To perform compaction, read this size from the buffer once the command buffer has completed and use it to allocate a smaller acceleration structure. Then create another encoder and call the copyAndCompactAccelerationStructure method. Source acceleration structure Destination size buffer. The compacted size will be written as either a 32 bit or 64 bit value depending on the sizeDataType argument unsigned integer representing the compacted size in bytes. Offset into the size buffer Data type of the size to write into the buffer. Must be either MTLDataTypeUInt (32 bit) or MTLDataTypeULong (64 bit)
      */
-    writeCompactedAccelerationStructureSize$toBuffer$offset$sizeDataType$?(accelerationStructure: _MTLAccelerationStructure, buffer: _MTLBuffer, offset: number, sizeDataType: MTLDataType): void;
+    writeCompactedAccelerationStructureSize$toBuffer$offset$sizeDataType$(accelerationStructure: _MTLAccelerationStructure, buffer: _MTLBuffer, offset: number, sizeDataType: MTLDataType): void;
     /**
      * Copy and compact an acceleration structure. The source and destination acceleration structures must not overlap in memory. If this is a top level acceleration structure, references to bottom level acceleration structures will be preserved. The destination acceleration structure must be at least as large as the compacted size of the source acceleration structure, which is computed by the writeCompactedAccelerationStructureSize method. Acceleration structure to copy and compact Acceleration structure to copy to
      */
-    copyAndCompactAccelerationStructure$toAccelerationStructure$?(sourceAccelerationStructure: _MTLAccelerationStructure, destinationAccelerationStructure: _MTLAccelerationStructure): void;
+    copyAndCompactAccelerationStructure$toAccelerationStructure$(sourceAccelerationStructure: _MTLAccelerationStructure, destinationAccelerationStructure: _MTLAccelerationStructure): void;
     /**
      * Update the fence to capture all GPU work so far enqueued by this encoder. The fence is updated at build submission to maintain global order and prevent deadlock. Drivers may delay fence updates until the end of the encoder. Drivers may also wait on fences at the beginning of an encoder. It is therefore illegal to wait on a fence after it has been updated in the same encoder.
      */
-    updateFence$?(fence: _MTLFence): void;
+    updateFence$(fence: _MTLFence): void;
     /**
      * Prevent further GPU work until the fence is reached. The fence is evaluated at build submission to maintain global order and prevent deadlock. Drivers may delay fence updates until the end of the encoder. Drivers may also wait on fences at the beginning of an encoder. It is therefore illegal to wait on a fence after it has been updated in the same encoder.
      */
-    waitForFence$?(fence: _MTLFence): void;
+    waitForFence$(fence: _MTLFence): void;
     /**
      * Declare that a resource may be accessed by the command encoder through an argument buffer For tracked MTLResources, this method protects against data hazards. This method must be called before encoding any acceleration structure commands which may access the resource through an argument buffer. Prior to iOS 13, macOS 10.15, this method does not protect against data hazards. If you are deploying to older versions of macOS or iOS, use fences to ensure data hazards are resolved.
      */
-    useResource$usage$?(resource: _MTLResource, usage: MTLResourceUsage): void;
+    useResource$usage$(resource: _MTLResource, usage: MTLResourceUsage): void;
     /**
      * Declare that an array of resources may be accessed through an argument buffer by the command encoder For tracked MTL Resources, this method protects against data hazards. This method must be called before encoding any acceleration structure commands which may access the resources through an argument buffer. Prior to iOS 13, macOS 10.15, this method does not protect against data hazards. If you are deploying to older versions of macOS or iOS, use fences to ensure data hazards are resolved.
      */
-    useResources$count$usage$?(resources: NobjcObject, count: number, usage: MTLResourceUsage): void;
+    useResources$count$usage$(resources: NobjcObject, count: number, usage: MTLResourceUsage): void;
     /**
      * Declare that the resources allocated from a heap may be accessed as readonly by the encoder through an argument buffer For tracked MTLHeaps, this method protects against data hazards. This method must be called before encoding any acceleration structure commands which may access the resources allocated from the heap through an argument buffer. This method may cause all of the color attachments allocated from the heap to become decompressed. Therefore, it is recommended that the useResource:usage: or useResources:count:usage: methods be used for color attachments instead, with a minimal (i.e. read-only) usage. Prior to iOS 13, macOS 10.15, this method does not protect against data hazards. If you are deploying to older versions of macOS or iOS, use fences to ensure data hazards are resolved.
      */
-    useHeap$?(heap: _MTLHeap): void;
+    useHeap$(heap: _MTLHeap): void;
     /**
      * Declare that the resources allocated from an array of heaps may be accessed as readonly by the encoder through an argument buffer For tracked MTLHeaps, this method protects against data hazards. This method must be called before encoding any acceleration structure commands which may access the resources allocated from the heaps through an argument buffer. This method may cause all of the color attachments allocated from the heaps to become decompressed. Therefore, it is recommended that the useResource:usage: or useResources:count:usage: methods be used for color attachments instead, with a minimal (i.e. read-only) usage. Prior to iOS 13, macOS 10.15, this method does not protect against data hazards. If you are deploying to older versions of macOS or iOS, use fences to ensure data hazards are resolved.
      */
-    useHeaps$count$?(heaps: NobjcObject, count: number): void;
+    useHeaps$count$(heaps: NobjcObject, count: number): void;
     /**
      * Sample hardware counters at this point in the acceleration structure encoder and store the counter sample into the sample buffer at the specified index. The sample buffer to sample into The index into the counter buffer to write the sample Insert a barrier before taking the sample. Passing YES will ensure that all work encoded before this operation in the encoder is complete but does not isolate the work with respect to other encoders. Passing NO will allow the sample to be taken concurrently with other operations in this encoder. In general, passing YES will lead to more repeatable counter results but may negatively impact performance. Passing NO will generally be higher performance but counter results may not be repeatable.
      */
-    sampleCountersInBuffer$atSampleIndex$withBarrier$?(sampleBuffer: _MTLCounterSampleBuffer, sampleIndex: number, barrier: boolean): void;
+    sampleCountersInBuffer$atSampleIndex$withBarrier$(sampleBuffer: _MTLCounterSampleBuffer, sampleIndex: number, barrier: boolean): void;
 }

package/dist/Metal/MTLAccelerationStructureInstanceDescriptorType.d.ts

@@ -5,4 +5,4 @@ export declare const MTLAccelerationStructureInstanceDescriptorType: {
     readonly Indirect: 3;
     readonly IndirectMotion: 4;
 };
-export type MTLAccelerationStructureInstanceDescriptorType = typeof MTLAccelerationStructureInstanceDescriptorType[keyof typeof MTLAccelerationStructureInstanceDescriptorType];
+export type MTLAccelerationStructureInstanceDescriptorType = (typeof MTLAccelerationStructureInstanceDescriptorType)[keyof typeof MTLAccelerationStructureInstanceDescriptorType];

package/dist/Metal/MTLAccelerationStructureInstanceOptions.d.ts

@@ -5,4 +5,4 @@ export declare const MTLAccelerationStructureInstanceOptions: {
     readonly MTLAccelerationStructureInstanceOptionOpaque: 4;
     readonly MTLAccelerationStructureInstanceOptionNonOpaque: 8;
 };
-export type MTLAccelerationStructureInstanceOptions = (number & {}) | typeof MTLAccelerationStructureInstanceOptions[keyof typeof MTLAccelerationStructureInstanceOptions];
+export type MTLAccelerationStructureInstanceOptions = (number & {}) | (typeof MTLAccelerationStructureInstanceOptions)[keyof typeof MTLAccelerationStructureInstanceOptions];

package/dist/Metal/MTLAccelerationStructureRefitOptions.d.ts

@@ -2,4 +2,4 @@ export declare const MTLAccelerationStructureRefitOptions: {
     readonly MTLAccelerationStructureRefitOptionVertexData: 1;
     readonly MTLAccelerationStructureRefitOptionPerPrimitiveData: 2;
 };
-export type MTLAccelerationStructureRefitOptions = (number & {}) | typeof MTLAccelerationStructureRefitOptions[keyof typeof MTLAccelerationStructureRefitOptions];
+export type MTLAccelerationStructureRefitOptions = (number & {}) | (typeof MTLAccelerationStructureRefitOptions)[keyof typeof MTLAccelerationStructureRefitOptions];

package/dist/Metal/MTLAccelerationStructureUsage.d.ts

@@ -6,4 +6,4 @@ export declare const MTLAccelerationStructureUsage: {
     readonly PreferFastIntersection: 16;
     readonly MinimizeMemory: 32;
 };
-export type MTLAccelerationStructureUsage = (number & {}) | typeof MTLAccelerationStructureUsage[keyof typeof MTLAccelerationStructureUsage];
+export type MTLAccelerationStructureUsage = (number & {}) | (typeof MTLAccelerationStructureUsage)[keyof typeof MTLAccelerationStructureUsage];

package/dist/Metal/MTLAllocation.d.ts

@@ -1,3 +1,3 @@
 export interface _MTLAllocation {
-    allocatedSize?(): number;
+    allocatedSize(): number;
 }

package/dist/Metal/MTLArgumentBuffersTier.d.ts

@@ -2,4 +2,4 @@ export declare const MTLArgumentBuffersTier: {
     readonly MTLArgumentBuffersTier1: 0;
     readonly MTLArgumentBuffersTier2: 1;
 };
-export type MTLArgumentBuffersTier = typeof MTLArgumentBuffersTier[keyof typeof MTLArgumentBuffersTier];
+export type MTLArgumentBuffersTier = (typeof MTLArgumentBuffersTier)[keyof typeof MTLArgumentBuffersTier];

package/dist/Metal/MTLArgumentEncoder.d.ts

@@ -14,61 +14,61 @@ import type { _NSString } from "../Foundation/NSString.js";
 import type { NSRange } from "../structs/NSRange.js";
 export interface _MTLArgumentEncoder {
     /** Sets the destination buffer and offset at which the arguments will be encoded. */
-    setArgumentBuffer$offset$?(argumentBuffer: _MTLBuffer | null, offset: number): void;
+    setArgumentBuffer$offset$(argumentBuffer: _MTLBuffer | null, offset: number): void;
     /**
      * Sets the destination buffer, starting offset and specific array element arguments will be encoded into. arrayElement represents the desired element of IAB array targetted by encoding
      */
-    setArgumentBuffer$startOffset$arrayElement$?(argumentBuffer: _MTLBuffer | null, startOffset: number, arrayElement: number): void;
+    setArgumentBuffer$startOffset$arrayElement$(argumentBuffer: _MTLBuffer | null, startOffset: number, arrayElement: number): void;
     /** Set a buffer at the given bind point index. */
-    setBuffer$offset$atIndex$?(buffer: _MTLBuffer | null, offset: number, index: number): void;
+    setBuffer$offset$atIndex$(buffer: _MTLBuffer | null, offset: number, index: number): void;
     /** Set an array of buffers at the given bind point index range. */
-    setBuffers$offsets$withRange$?(buffers: NobjcObject | null, offsets: NobjcObject, range: NSRange): void;
+    setBuffers$offsets$withRange$(buffers: NobjcObject | null, offsets: NobjcObject, range: NSRange): void;
     /** Set a texture at the given bind point index. */
-    setTexture$atIndex$?(texture: _MTLTexture | null, index: number): void;
+    setTexture$atIndex$(texture: _MTLTexture | null, index: number): void;
     /** Set an array of textures at the given bind point index range. */
-    setTextures$withRange$?(textures: NobjcObject | null, range: NSRange): void;
+    setTextures$withRange$(textures: NobjcObject | null, range: NSRange): void;
     /** Set a sampler at the given bind point index. */
-    setSamplerState$atIndex$?(sampler: _MTLSamplerState | null, index: number): void;
+    setSamplerState$atIndex$(sampler: _MTLSamplerState | null, index: number): void;
     /** Set an array of samplers at the given bind point index range. */
-    setSamplerStates$withRange$?(samplers: NobjcObject | null, range: NSRange): void;
+    setSamplerStates$withRange$(samplers: NobjcObject | null, range: NSRange): void;
     /** Returns a pointer to the constant data at the given bind point index. */
-    constantDataAtIndex$?(index: number): NobjcObject;
+    constantDataAtIndex$(index: number): NobjcObject;
     /** Sets a render pipeline state at a given bind point index */
-    setRenderPipelineState$atIndex$?(pipeline: _MTLRenderPipelineState | null, index: number): void;
+    setRenderPipelineState$atIndex$(pipeline: _MTLRenderPipelineState | null, index: number): void;
     /** Set an array of render pipeline states at a given bind point index range */
-    setRenderPipelineStates$withRange$?(pipelines: NobjcObject | null, range: NSRange): void;
+    setRenderPipelineStates$withRange$(pipelines: NobjcObject | null, range: NSRange): void;
     /** Sets a compute pipeline state at a given bind point index */
-    setComputePipelineState$atIndex$?(pipeline: _MTLComputePipelineState | null, index: number): void;
+    setComputePipelineState$atIndex$(pipeline: _MTLComputePipelineState | null, index: number): void;
     /** Set an array of compute pipeline states at a given bind point index range */
-    setComputePipelineStates$withRange$?(pipelines: NobjcObject | null, range: NSRange): void;
+    setComputePipelineStates$withRange$(pipelines: NobjcObject | null, range: NSRange): void;
     /** Sets an indirect command buffer at a given bind point index */
-    setIndirectCommandBuffer$atIndex$?(indirectCommandBuffer: _MTLIndirectCommandBuffer | null, index: number): void;
+    setIndirectCommandBuffer$atIndex$(indirectCommandBuffer: _MTLIndirectCommandBuffer | null, index: number): void;
     /** Set an array of indirect command buffers at the given bind point index range. */
-    setIndirectCommandBuffers$withRange$?(buffers: NobjcObject | null, range: NSRange): void;
-    setAccelerationStructure$atIndex$?(accelerationStructure: _MTLAccelerationStructure | null, index: number): void;
+    setIndirectCommandBuffers$withRange$(buffers: NobjcObject | null, range: NSRange): void;
+    setAccelerationStructure$atIndex$(accelerationStructure: _MTLAccelerationStructure | null, index: number): void;
     /**
      * Returns a pointer to a new MTLArgumentEncoder that can be used to encode the an argument buffer in the buffer associated with a given index. Returns nil if the resource at the given index is not an argument buffer.
      */
-    newArgumentEncoderForBufferAtIndex$?(index: number): _MTLArgumentEncoder | null;
+    newArgumentEncoderForBufferAtIndex$(index: number): _MTLArgumentEncoder | null;
     /** Set a visible function table at the given buffer index */
-    setVisibleFunctionTable$atIndex$?(visibleFunctionTable: _MTLVisibleFunctionTable | null, index: number): void;
+    setVisibleFunctionTable$atIndex$(visibleFunctionTable: _MTLVisibleFunctionTable | null, index: number): void;
     /** Set visible function tables at the given buffer index range */
-    setVisibleFunctionTables$withRange$?(visibleFunctionTables: NobjcObject | null, range: NSRange): void;
+    setVisibleFunctionTables$withRange$(visibleFunctionTables: NobjcObject | null, range: NSRange): void;
     /** Set an intersection function table at the given buffer index */
-    setIntersectionFunctionTable$atIndex$?(intersectionFunctionTable: _MTLIntersectionFunctionTable | null, index: number): void;
+    setIntersectionFunctionTable$atIndex$(intersectionFunctionTable: _MTLIntersectionFunctionTable | null, index: number): void;
     /** Set intersection function tables at the given buffer index range */
-    setIntersectionFunctionTables$withRange$?(intersectionFunctionTables: NobjcObject | null, range: NSRange): void;
+    setIntersectionFunctionTables$withRange$(intersectionFunctionTables: NobjcObject | null, range: NSRange): void;
     /** Sets a depth stencil state at a given bind point index */
-    setDepthStencilState$atIndex$?(depthStencilState: _MTLDepthStencilState | null, index: number): void;
+    setDepthStencilState$atIndex$(depthStencilState: _MTLDepthStencilState | null, index: number): void;
     /** Sets an array of depth stencil states at a given buffer index range */
-    setDepthStencilStates$withRange$?(depthStencilStates: NobjcObject | null, range: NSRange): void;
+    setDepthStencilStates$withRange$(depthStencilStates: NobjcObject | null, range: NSRange): void;
     /** The device this argument encoder was created against. */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
     /** A string to help identify this object. */
-    label?(): _NSString | null;
-    setLabel$?(value: _NSString | null): void;
+    label(): _NSString | null;
+    setLabel$(value: _NSString | null): void;
     /** The number of bytes required to store the encoded resource bindings. */
-    encodedLength?(): number;
+    encodedLength(): number;
     /** The alignment in bytes required to store the encoded resource bindings. */
-    alignment?(): number;
+    alignment(): number;
 }

package/dist/Metal/MTLArgumentType.d.ts

@@ -10,4 +10,4 @@ export declare const MTLArgumentType: {
     readonly InstanceAccelerationStructure: 26;
     readonly IntersectionFunctionTable: 27;
 };
-export type MTLArgumentType = typeof MTLArgumentType[keyof typeof MTLArgumentType];
+export type MTLArgumentType = (typeof MTLArgumentType)[keyof typeof MTLArgumentType];

package/dist/Metal/MTLAttributeFormat.d.ts

@@ -54,4 +54,4 @@ export declare const MTLAttributeFormat: {
     readonly FloatRG11B10: 54;
     readonly FloatRGB9E5: 55;
 };
-export type MTLAttributeFormat = typeof MTLAttributeFormat[keyof typeof MTLAttributeFormat];
+export type MTLAttributeFormat = (typeof MTLAttributeFormat)[keyof typeof MTLAttributeFormat];

package/dist/Metal/MTLBarrierScope.d.ts

@@ -3,4 +3,4 @@ export declare const MTLBarrierScope: {
     readonly Textures: 2;
     readonly RenderTargets: 4;
 };
-export type MTLBarrierScope = (number & {}) | typeof MTLBarrierScope[keyof typeof MTLBarrierScope];
+export type MTLBarrierScope = (number & {}) | (typeof MTLBarrierScope)[keyof typeof MTLBarrierScope];

package/dist/Metal/MTLBinaryArchive.d.ts

@@ -13,36 +13,36 @@ export interface _MTLBinaryArchive {
     /**
      * Add the function(s) from a compute pipeline state to the archive. The descriptor from which function(s) will be added. If the function fails, this will be set to describe the failure. This can be (but is not required to be) an error from the MTLBinaryArchiveDomain domain. Whether or not the addition succeeded. Functions referenced multiple times are silently accepted.
      */
-    addComputePipelineFunctionsWithDescriptor$error$?(descriptor: _MTLComputePipelineDescriptor, error: NobjcObject | null): boolean;
+    addComputePipelineFunctionsWithDescriptor$error$(descriptor: _MTLComputePipelineDescriptor, error: NobjcObject | null): boolean;
     /**
      * Add the function(s) from a render pipeline state to the archive. The descriptor from which function(s) will be added. If the function fails, this will be set to describe the failure. This can be (but is not required to be) an error from the MTLBinaryArchiveDomain domain. Whether or not the addition succeeded. Functions referenced multiple times are silently accepted.
      */
-    addRenderPipelineFunctionsWithDescriptor$error$?(descriptor: _MTLRenderPipelineDescriptor, error: NobjcObject | null): boolean;
+    addRenderPipelineFunctionsWithDescriptor$error$(descriptor: _MTLRenderPipelineDescriptor, error: NobjcObject | null): boolean;
     /**
      * Add the function(s) from a tile render pipeline state to the archive. The descriptor from which function(s) will be added. If the function fails, this will be set to describe the failure. This can be (but is not required to be) an error from the MTLBinaryArchiveDomain domain. Whether or not the addition succeeded. Functions referenced multiple times are silently accepted.
      */
-    addTileRenderPipelineFunctionsWithDescriptor$error$?(descriptor: _MTLTileRenderPipelineDescriptor, error: NobjcObject | null): boolean;
+    addTileRenderPipelineFunctionsWithDescriptor$error$(descriptor: _MTLTileRenderPipelineDescriptor, error: NobjcObject | null): boolean;
     /**
      * Add the function(s) from a mesh render pipeline state to the archive. The descriptor from which function(s) will be added. If the function fails, this will be set to describe the failure. This can be (but is not required to be) an error from the MTLBinaryArchiveDomain domain. Whether or not the addition succeeded. Functions referenced multiple times are silently accepted.
      */
-    addMeshRenderPipelineFunctionsWithDescriptor$error$?(descriptor: _MTLMeshRenderPipelineDescriptor, error: NobjcObject | null): boolean;
+    addMeshRenderPipelineFunctionsWithDescriptor$error$(descriptor: _MTLMeshRenderPipelineDescriptor, error: NobjcObject | null): boolean;
     /**
      * Add the function(s) from a stitched library to the archive. The stitched library descriptor from which function(s) will be added. If the function fails, this will be set to describe the failure. This can be (but is not required to be) an error from the MTLBinaryArchiveDomain domain. Whether or not the addition succeeded. Functions referenced multiple times are silently accepted.
      */
-    addLibraryWithDescriptor$error$?(descriptor: _MTLStitchedLibraryDescriptor, error: NobjcObject | null): boolean;
+    addLibraryWithDescriptor$error$(descriptor: _MTLStitchedLibraryDescriptor, error: NobjcObject | null): boolean;
     /**
      * Write the contents of a MTLBinaryArchive to a file. Persisting the archive to a file allows opening the archive on a subsequent instance of the app, making available the contents without recompiling. The file URL to which to write the file If the function fails, this will be set to describe the failure. This can be (but is not required to be) an error from the MTLBinaryArchiveDomain domain. Other possible errors can be file access or I/O related. Whether or not the writing the file succeeded.
      */
-    serializeToURL$error$?(url: _NSURL, error: NobjcObject | null): boolean;
+    serializeToURL$error$(url: _NSURL, error: NobjcObject | null): boolean;
     /**
      * Add a `visible` or `intersection` function to the archive. The descriptor from which the function will be added. Library of functions to add the function from. If the function fails, this will be set to describe the failure. This can be (but is not required to be) an error from the MTLBinaryArchiveDomain domain. Other possible errors can be file access or I/O related. Whether or not the addition succeeded. Functions referenced multiple times are silently accepted.
      */
-    addFunctionWithDescriptor$library$error$?(descriptor: _MTLFunctionDescriptor, library: _MTLLibrary, error: NobjcObject | null): boolean;
+    addFunctionWithDescriptor$library$error$(descriptor: _MTLFunctionDescriptor, library: _MTLLibrary, error: NobjcObject | null): boolean;
     /** A string to help identify this object. */
-    label?(): _NSString | null;
-    setLabel$?(value: _NSString | null): void;
+    label(): _NSString | null;
+    setLabel$(value: _NSString | null): void;
     /**
      * The device this resource was created against. This resource can only be used with this device.
      */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
 }