objcjs-types 0.7.0 → 0.7.1

package/dist/Metal/MTLCommandBuffer.d.ts

@@ -25,130 +25,130 @@ export interface _MTLCommandBuffer {
     /**
      * @method enqueue @abstract Append this command buffer to the end of its MTLCommandQueue.
      */
-    enqueue?(): void;
+    enqueue(): void;
     /**
      * @method commit @abstract Commit a command buffer so it can be executed as soon as possible.
      */
-    commit?(): void;
+    commit(): void;
     /**
      * @method addScheduledHandler:block: @abstract Adds a block to be called when this command buffer has been scheduled for execution.
      */
-    addScheduledHandler$?(block: (arg0: _MTLCommandBuffer) => void): void;
+    addScheduledHandler$(block: (arg0: _MTLCommandBuffer) => void): void;
     /**
      * @method presentDrawable: @abstract Add a drawable present that will be invoked when this command buffer has been scheduled for execution. @discussion The submission thread will be lock stepped with present call been serviced by window server
      */
-    presentDrawable$?(drawable: _MTLDrawable): void;
+    presentDrawable$(drawable: _MTLDrawable): void;
     /**
      * @method presentDrawable:atTime: @abstract Add a drawable present for a specific host time that will be invoked when this command buffer has been scheduled for execution. @discussion The submission thread will be lock stepped with present call been serviced by window server
      */
-    presentDrawable$atTime$?(drawable: _MTLDrawable, presentationTime: number): void;
+    presentDrawable$atTime$(drawable: _MTLDrawable, presentationTime: number): void;
     /**
      * @method presentDrawable:afterMinimumDuration: @abstract Add a drawable present for a specific host time that allows previous frame to be on screen for at least duration time. @param drawable The drawable to be presented @param duration The minimum time that previous frame should be displayed. The time is double preceision floating point in the unit of seconds. @discussion The difference of this API versus presentDrawable:atTime is that this API defers calculation of the presentation time until the previous frame's actual presentation time is known, thus to be able to maintain a more consistent and stable frame time. This also provides an easy way to set frame rate. The submission thread will be lock stepped with present call been serviced by window server
      */
-    presentDrawable$afterMinimumDuration$?(drawable: _MTLDrawable, duration: number): void;
+    presentDrawable$afterMinimumDuration$(drawable: _MTLDrawable, duration: number): void;
     /**
      * @method waitUntilScheduled @abstract Synchronously wait for this command buffer to be scheduled.
      */
-    waitUntilScheduled?(): void;
+    waitUntilScheduled(): void;
     /**
      * @method addCompletedHandler:block: @abstract Add a block to be called when this command buffer has completed execution.
      */
-    addCompletedHandler$?(block: (arg0: _MTLCommandBuffer) => void): void;
+    addCompletedHandler$(block: (arg0: _MTLCommandBuffer) => void): void;
     /**
      * @method waitUntilCompleted @abstract Synchronously wait for this command buffer to complete.
      */
-    waitUntilCompleted?(): void;
+    waitUntilCompleted(): void;
     /**
      * @method blitCommandEncoder @abstract returns a blit command encoder to encode into this command buffer.
      */
-    blitCommandEncoder?(): _MTLBlitCommandEncoder | null;
+    blitCommandEncoder(): _MTLBlitCommandEncoder | null;
     /**
      * @method renderCommandEncoderWithDescriptor: @abstract returns a render command endcoder to encode into this command buffer.
      */
-    renderCommandEncoderWithDescriptor$?(renderPassDescriptor: _MTLRenderPassDescriptor): _MTLRenderCommandEncoder | null;
+    renderCommandEncoderWithDescriptor$(renderPassDescriptor: _MTLRenderPassDescriptor): _MTLRenderCommandEncoder | null;
     /**
      * @method computeCommandEncoderWithDescriptor: @abstract returns a compute command endcoder to encode into this command buffer.
      */
-    computeCommandEncoderWithDescriptor$?(computePassDescriptor: _MTLComputePassDescriptor): _MTLComputeCommandEncoder | null;
+    computeCommandEncoderWithDescriptor$(computePassDescriptor: _MTLComputePassDescriptor): _MTLComputeCommandEncoder | null;
     /**
      * @method blitCommandEncoderWithDescriptor: @abstract returns a blit command endcoder to encode into this command buffer.
      */
-    blitCommandEncoderWithDescriptor$?(blitPassDescriptor: _MTLBlitPassDescriptor): _MTLBlitCommandEncoder | null;
+    blitCommandEncoderWithDescriptor$(blitPassDescriptor: _MTLBlitPassDescriptor): _MTLBlitCommandEncoder | null;
     /**
      * @method computeCommandEncoder @abstract returns a compute command encoder to encode into this command buffer.
      */
-    computeCommandEncoder?(): _MTLComputeCommandEncoder | null;
+    computeCommandEncoder(): _MTLComputeCommandEncoder | null;
     /**
      * @method computeCommandEncoderWithDispatchType @abstract returns a compute command encoder to encode into this command buffer. Optionally allow this command encoder to execute dispatches concurrently. @discussion On devices that do not support concurrent command encoders, this call is equivalent to computeCommandEncoder
      */
-    computeCommandEncoderWithDispatchType$?(dispatchType: MTLDispatchType): _MTLComputeCommandEncoder | null;
+    computeCommandEncoderWithDispatchType$(dispatchType: MTLDispatchType): _MTLComputeCommandEncoder | null;
     /**
      * @method encodeWaitForEvent:value: @abstract Encodes a command that pauses execution of this command buffer until the specified event reaches a given value. @discussion This method may only be called if there is no current command encoder on the receiver.
      */
-    encodeWaitForEvent$value$?(event: _MTLEvent, value: number): void;
+    encodeWaitForEvent$value$(event: _MTLEvent, value: number): void;
     /**
      * @method encodeSignalEvent:value: @abstract Encodes a command that signals an event with a given value. @discussion This method may only be called if there is no current command encoder on the receiver.
      */
-    encodeSignalEvent$value$?(event: _MTLEvent, value: number): void;
+    encodeSignalEvent$value$(event: _MTLEvent, value: number): void;
     /**
      * @method parallelRenderCommandEncoderWithDescriptor: @abstract returns a parallel render pass encoder to encode into this command buffer.
      */
-    parallelRenderCommandEncoderWithDescriptor$?(renderPassDescriptor: _MTLRenderPassDescriptor): _MTLParallelRenderCommandEncoder | null;
-    resourceStateCommandEncoder?(): _MTLResourceStateCommandEncoder | null;
-    resourceStateCommandEncoderWithDescriptor$?(resourceStatePassDescriptor: _MTLResourceStatePassDescriptor): _MTLResourceStateCommandEncoder | null;
-    accelerationStructureCommandEncoder?(): _MTLAccelerationStructureCommandEncoder | null;
-    accelerationStructureCommandEncoderWithDescriptor$?(descriptor: _MTLAccelerationStructurePassDescriptor): _MTLAccelerationStructureCommandEncoder;
+    parallelRenderCommandEncoderWithDescriptor$(renderPassDescriptor: _MTLRenderPassDescriptor): _MTLParallelRenderCommandEncoder | null;
+    resourceStateCommandEncoder(): _MTLResourceStateCommandEncoder | null;
+    resourceStateCommandEncoderWithDescriptor$(resourceStatePassDescriptor: _MTLResourceStatePassDescriptor): _MTLResourceStateCommandEncoder | null;
+    accelerationStructureCommandEncoder(): _MTLAccelerationStructureCommandEncoder | null;
+    accelerationStructureCommandEncoderWithDescriptor$(descriptor: _MTLAccelerationStructurePassDescriptor): _MTLAccelerationStructureCommandEncoder;
     /**
      * @method pushDebugGroup: @abstract Push a new named string onto a stack of string labels.
      */
-    pushDebugGroup$?(string_: _NSString): void;
+    pushDebugGroup$(string_: _NSString): void;
     /** @method popDebugGroup @abstract Pop the latest named string off of the stack. */
-    popDebugGroup?(): void;
+    popDebugGroup(): void;
     /**
      * @method useResidencySet @abstract Marks the residency set as part of the current command buffer execution. This ensures that the residency set is resident during execution of the command buffer.
      */
-    useResidencySet$?(residencySet: _MTLResidencySet): void;
+    useResidencySet$(residencySet: _MTLResidencySet): void;
     /**
      * @method useResidencySets @abstract Marks the residency sets as part of the current command buffer execution. This ensures that the residency sets are resident during execution of the command buffer.
      */
-    useResidencySets$count$?(residencySets: NobjcObject, count: number): void;
+    useResidencySets$count$(residencySets: NobjcObject, count: number): void;
     /** @property device @abstract The device this resource was created against. */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
     /**
      * @property commandQueue @abstract The command queue this command buffer was created from.
      */
-    commandQueue?(): _MTLCommandQueue;
+    commandQueue(): _MTLCommandQueue;
     /**
      * @property retainedReferences @abstract If YES, this command buffer holds strong references to objects needed to execute this command buffer.
      */
-    retainedReferences?(): boolean;
+    retainedReferences(): boolean;
     /**
      * @abstract The set of options configuring the error reporting of the created command buffer.
      */
-    errorOptions?(): MTLCommandBufferErrorOption;
+    errorOptions(): MTLCommandBufferErrorOption;
     /** @property label @abstract A string to help identify this object. */
-    label?(): _NSString | null;
-    setLabel$?(value: _NSString | null): void;
-    kernelStartTime?(): number;
-    kernelEndTime?(): number;
+    label(): _NSString | null;
+    setLabel$(value: _NSString | null): void;
+    kernelStartTime(): number;
+    kernelEndTime(): number;
     /**
      * @property logs @abstract Logs generated by the command buffer during execution of the GPU commands. Valid after GPU execution is completed
      */
-    logs?(): _MTLLogContainer;
+    logs(): _MTLLogContainer;
     /**
      * @property GPUStartTime @abstract The host time in seconds that GPU starts executing this command buffer. Returns zero if it has not started. This usually can be called in command buffer completion handler.
      */
-    GPUStartTime?(): number;
+    GPUStartTime(): number;
     /**
      * @property GPUEndTime @abstract The host time in seconds that GPU finishes executing this command buffer. Returns zero if CPU has not received completion notification. This usually can be called in command buffer completion handler.
      */
-    GPUEndTime?(): number;
+    GPUEndTime(): number;
     /**
      * @property status @abstract status reports the current stage in the lifetime of MTLCommandBuffer, as it proceeds to enqueued, committed, scheduled, and completed.
      */
-    status?(): MTLCommandBufferStatus;
+    status(): MTLCommandBufferStatus;
     /**
      * @property error @abstract If an error occurred during execution, the NSError may contain more details about the problem.
      */
-    error?(): _NSError | null;
+    error(): _NSError | null;
 }

package/dist/Metal/MTLCommandBufferEncoderInfo.d.ts

@@ -5,11 +5,11 @@ export interface _MTLCommandBufferEncoderInfo {
     /**
      * @abstract The debug label given to the associated Metal command encoder at command buffer submission.
      */
-    label?(): _NSString;
+    label(): _NSString;
     /**
      * @abstract The debug signposts inserted into the associated Metal command encoder.
      */
-    debugSignposts?(): _NSArray;
+    debugSignposts(): _NSArray;
     /** @abstract The error state of the associated Metal command encoder. */
-    errorState?(): MTLCommandEncoderErrorState;
+    errorState(): MTLCommandEncoderErrorState;
 }

package/dist/Metal/MTLCommandEncoder.d.ts

@@ -5,24 +5,24 @@ export interface _MTLCommandEncoder {
     /**
      * @method endEncoding @abstract Declare that all command generation from this encoder is complete, and detach from the MTLCommandBuffer.
      */
-    endEncoding?(): void;
+    endEncoding(): void;
     /**
      * Encodes a consumer barrier on work you commit to the same command queue. Encode a barrier that guarantees that any subsequent work you encode in the current command encoder that corresponds to the `beforeStages` stages doesn't proceed until Metal completes all work prior to the current command encoder corresponding to the `afterQueueStages` stages, completes. Metal can reorder the exact point where it applies the barrier, so use this method for synchronizing between different passes. If you need to synchronize work within a pass that you encode with an instance of a subclass of ``MTLCommandEncoder``, use memory barriers instead. For subclasses of ``MTL4CommandEncoder``, use encoder barriers. You can specify `afterQueueStages` and `beforeStages` that contain ``MTLStages`` unrelated to the current command encoder. - Parameters: - afterQueueStages: ``MTLStages`` mask that represents the stages of work to wait for. This argument applies to work corresponding to these stages you encode in prior command encoders, and not for the current encoder. - beforeStages: ``MTLStages`` mask that represents the stages of work that wait. This argument applies to work you encode in the current command encoder.
      */
-    barrierAfterQueueStages$beforeStages$?(afterQueueStages: MTLStages, beforeStages: MTLStages): void;
+    barrierAfterQueueStages$beforeStages$(afterQueueStages: MTLStages, beforeStages: MTLStages): void;
     /**
      * @method insertDebugSignpost: @abstract Inserts a debug string into the command buffer. This does not change any API behavior, but can be useful when debugging.
      */
-    insertDebugSignpost$?(string_: _NSString): void;
+    insertDebugSignpost$(string_: _NSString): void;
     /**
      * @method pushDebugGroup: @abstract Push a new named string onto a stack of string labels.
      */
-    pushDebugGroup$?(string_: _NSString): void;
+    pushDebugGroup$(string_: _NSString): void;
     /** @method popDebugGroup @abstract Pop the latest named string off of the stack. */
-    popDebugGroup?(): void;
+    popDebugGroup(): void;
     /** @property device @abstract The device this resource was created against. */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
     /** @property label @abstract A string to help identify this object. */
-    label?(): _NSString | null;
-    setLabel$?(value: _NSString | null): void;
+    label(): _NSString | null;
+    setLabel$(value: _NSString | null): void;
 }

package/dist/Metal/MTLCommandQueue.d.ts

@@ -8,39 +8,39 @@ export interface _MTLCommandQueue {
     /**
      * @method commandBuffer @abstract Returns a new autoreleased command buffer used to encode work into this queue that maintains strong references to resources used within the command buffer.
      */
-    commandBuffer?(): _MTLCommandBuffer | null;
+    commandBuffer(): _MTLCommandBuffer | null;
     /**
      * @method commandBufferWithDescriptor @param descriptor The requested properties of the command buffer. @abstract Returns a new autoreleased command buffer used to encode work into this queue.
      */
-    commandBufferWithDescriptor$?(descriptor: _MTLCommandBufferDescriptor): _MTLCommandBuffer | null;
+    commandBufferWithDescriptor$(descriptor: _MTLCommandBufferDescriptor): _MTLCommandBuffer | null;
     /**
      * @method commandBufferWithUnretainedReferences @abstract Returns a new autoreleased command buffer used to encode work into this queue that does not maintain strong references to resources used within the command buffer.
      */
-    commandBufferWithUnretainedReferences?(): _MTLCommandBuffer | null;
+    commandBufferWithUnretainedReferences(): _MTLCommandBuffer | null;
     /**
      * @method insertDebugCaptureBoundary @abstract Inform Xcode about when debug capture should start and stop.
      * @deprecated Use MTLCaptureScope instead
      */
-    insertDebugCaptureBoundary?(): void;
+    insertDebugCaptureBoundary(): void;
     /**
      * @method addResidencySet @abstract Marks the residency set as part of the command queue execution. This ensures that the residency set is resident during execution of all the command buffers within the queue.
      */
-    addResidencySet$?(residencySet: _MTLResidencySet): void;
+    addResidencySet$(residencySet: _MTLResidencySet): void;
     /**
      * @method addResidencySets @abstract Marks the residency sets as part of the command queue execution. This ensures that the residency sets are resident during execution of all the command buffers within the queue.
      */
-    addResidencySets$count$?(residencySets: NobjcObject, count: number): void;
+    addResidencySets$count$(residencySets: NobjcObject, count: number): void;
     /**
      * @method removeResidencySet @abstract Removes the residency set from the command queue execution. This ensures that only the remaining residency sets are resident during execution of all the command buffers within the queue.
      */
-    removeResidencySet$?(residencySet: _MTLResidencySet): void;
+    removeResidencySet$(residencySet: _MTLResidencySet): void;
     /**
      * @method removeResidencySets @abstract Removes the residency sets from the command queue execution. This ensures that only the remaining residency sets are resident during execution of all the command buffers within the queue.
      */
-    removeResidencySets$count$?(residencySets: NobjcObject, count: number): void;
+    removeResidencySets$count$(residencySets: NobjcObject, count: number): void;
     /** @brief A string to help identify this object */
-    label?(): _NSString | null;
-    setLabel$?(value: _NSString | null): void;
+    label(): _NSString | null;
+    setLabel$(value: _NSString | null): void;
     /** @brief The device this queue will submit to */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
 }

package/dist/Metal/MTLComputeCommandEncoder.d.ts

@@ -20,133 +20,133 @@ import type { MTLDispatchType } from "./MTLDispatchType.js";
 import type { MTLResourceUsage } from "./MTLResourceUsage.js";
 export interface _MTLComputeCommandEncoder extends _MTLCommandEncoder {
     /** Set the compute pipeline state that will be used. */
-    setComputePipelineState$?(state: _MTLComputePipelineState): void;
+    setComputePipelineState$(state: _MTLComputePipelineState): void;
     /**
      * Set the data (by copy) for a given buffer binding point. This will remove any existing MTLBuffer from the binding point.
      */
-    setBytes$length$atIndex$?(bytes: Uint8Array, length: number, index: number): void;
+    setBytes$length$atIndex$(bytes: Uint8Array, length: number, index: number): void;
     /** Set a global buffer for all compute kernels 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 the offset within the current global buffer for all compute kernels at the given bind point index.
      */
-    setBufferOffset$atIndex$?(offset: number, index: number): void;
+    setBufferOffset$atIndex$(offset: number, index: number): void;
     /**
      * Set an array of global buffers for all compute kernels with the given bind point range.
      */
-    setBuffers$offsets$withRange$?(buffers: NobjcObject | null, offsets: NobjcObject, range: NSRange): void;
+    setBuffers$offsets$withRange$(buffers: NobjcObject | null, offsets: NobjcObject, range: NSRange): void;
     /**
      * sets kernel buffer at specified index with provided offset and stride. only call this when the kernel-buffer is part of the stageInputDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic`
      */
-    setBuffer$offset$attributeStride$atIndex$?(buffer: _MTLBuffer, offset: number, stride: number, index: number): void;
+    setBuffer$offset$attributeStride$atIndex$(buffer: _MTLBuffer, offset: number, stride: number, index: number): void;
     /**
      * sets an array of kernel buffers with provided offsets and strides with the given bind point range. Only call this when at least one buffer is part of the vertexDescriptor, other buffers must set `MTLAttributeStrideStatic`
      */
-    setBuffers$offsets$attributeStrides$withRange$?(buffers: NobjcObject | null, offsets: NobjcObject, strides: NobjcObject, range: NSRange): void;
+    setBuffers$offsets$attributeStrides$withRange$(buffers: NobjcObject | null, offsets: NobjcObject, strides: NobjcObject, range: NSRange): void;
     /**
      * only call this when the buffer-index is part of the stageInputDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic`
      */
-    setBufferOffset$attributeStride$atIndex$?(offset: number, stride: number, index: number): void;
+    setBufferOffset$attributeStride$atIndex$(offset: number, stride: number, index: number): void;
     /**
      * only call this when the buffer-index is part of the stageInputDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic`
      */
-    setBytes$length$attributeStride$atIndex$?(bytes: Uint8Array, length: number, stride: number, index: number): void;
+    setBytes$length$attributeStride$atIndex$(bytes: Uint8Array, length: number, stride: number, index: number): void;
     /** Set a visible function table at the given buffer index */
-    setVisibleFunctionTable$atBufferIndex$?(visibleFunctionTable: _MTLVisibleFunctionTable | null, bufferIndex: number): void;
+    setVisibleFunctionTable$atBufferIndex$(visibleFunctionTable: _MTLVisibleFunctionTable | null, bufferIndex: number): void;
     /** Set visible function tables at the given buffer index range */
-    setVisibleFunctionTables$withBufferRange$?(visibleFunctionTables: NobjcObject | null, range: NSRange): void;
+    setVisibleFunctionTables$withBufferRange$(visibleFunctionTables: NobjcObject | null, range: NSRange): void;
     /** Set a visible function table at the given buffer index */
-    setIntersectionFunctionTable$atBufferIndex$?(intersectionFunctionTable: _MTLIntersectionFunctionTable | null, bufferIndex: number): void;
+    setIntersectionFunctionTable$atBufferIndex$(intersectionFunctionTable: _MTLIntersectionFunctionTable | null, bufferIndex: number): void;
     /** Set visible function tables at the given buffer index range */
-    setIntersectionFunctionTables$withBufferRange$?(intersectionFunctionTables: NobjcObject | null, range: NSRange): void;
+    setIntersectionFunctionTables$withBufferRange$(intersectionFunctionTables: NobjcObject | null, range: NSRange): void;
     /**
      * Set a global raytracing acceleration structure for all compute kernels at the given buffer bind point index.
      */
-    setAccelerationStructure$atBufferIndex$?(accelerationStructure: _MTLAccelerationStructure | null, bufferIndex: number): void;
+    setAccelerationStructure$atBufferIndex$(accelerationStructure: _MTLAccelerationStructure | null, bufferIndex: number): void;
     /** Set a global texture for all compute kernels 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 global textures for all compute kernels with the given bind point range.
      */
-    setTextures$withRange$?(textures: NobjcObject | null, range: NSRange): void;
+    setTextures$withRange$(textures: NobjcObject | null, range: NSRange): void;
     /** Set a global sampler for all compute kernels 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 global samplers for all compute kernels with the given bind point range.
      */
-    setSamplerStates$withRange$?(samplers: NobjcObject | null, range: NSRange): void;
+    setSamplerStates$withRange$(samplers: NobjcObject | null, range: NSRange): void;
     /** Set a global sampler for all compute kernels at the given bind point index. */
-    setSamplerState$lodMinClamp$lodMaxClamp$atIndex$?(sampler: _MTLSamplerState | null, lodMinClamp: number, lodMaxClamp: number, index: number): void;
+    setSamplerState$lodMinClamp$lodMaxClamp$atIndex$(sampler: _MTLSamplerState | null, lodMinClamp: number, lodMaxClamp: number, index: number): void;
     /**
      * Set an array of global samplers for all compute kernels with the given bind point range.
      */
-    setSamplerStates$lodMinClamps$lodMaxClamps$withRange$?(samplers: NobjcObject | null, lodMinClamps: NobjcObject, lodMaxClamps: NobjcObject, range: NSRange): void;
+    setSamplerStates$lodMinClamps$lodMaxClamps$withRange$(samplers: NobjcObject | null, lodMinClamps: NobjcObject, lodMaxClamps: NobjcObject, range: NSRange): void;
     /**
      * Set the threadgroup memory byte length at the binding point specified by the index. This applies to all compute kernels.
      */
-    setThreadgroupMemoryLength$atIndex$?(length: number, index: number): void;
+    setThreadgroupMemoryLength$atIndex$(length: number, index: number): void;
     /** Set imageblock sizes. */
-    setImageblockWidth$height$?(width: number, height: number): void;
+    setImageblockWidth$height$(width: number, height: number): void;
     /** Set the region of the stage_in attributes to apply the compute kernel. */
-    setStageInRegion$?(region: MTLRegion): void;
+    setStageInRegion$(region: MTLRegion): void;
     /**
      * sets the stage in region indirectly for the following indirect dispatch calls. A buffer object that the device will read the stageIn region arguments from, see MTLStageInRegionIndirectArguments. Byte offset within indirectBuffer to read arguments from. indirectBufferOffset must be a multiple of 4.
      */
-    setStageInRegionWithIndirectBuffer$indirectBufferOffset$?(indirectBuffer: _MTLBuffer, indirectBufferOffset: number): void;
+    setStageInRegionWithIndirectBuffer$indirectBufferOffset$(indirectBuffer: _MTLBuffer, indirectBufferOffset: number): void;
     /** Enqueue a compute function dispatch as a multiple of the threadgroup size. */
-    dispatchThreadgroups$threadsPerThreadgroup$?(threadgroupsPerGrid: MTLSize, threadsPerThreadgroup: MTLSize): void;
+    dispatchThreadgroups$threadsPerThreadgroup$(threadgroupsPerGrid: MTLSize, threadsPerThreadgroup: MTLSize): void;
     /**
      * Enqueue a compute function dispatch using an indirect buffer for threadgroupsPerGrid see MTLDispatchThreadgroupsIndirectArguments. A buffer object that the device will read dispatchThreadgroups arguments from, see MTLDispatchThreadgroupsIndirectArguments. Byte offset within to read arguments from. must be a multiple of 4.
      */
-    dispatchThreadgroupsWithIndirectBuffer$indirectBufferOffset$threadsPerThreadgroup$?(indirectBuffer: _MTLBuffer, indirectBufferOffset: number, threadsPerThreadgroup: MTLSize): void;
+    dispatchThreadgroupsWithIndirectBuffer$indirectBufferOffset$threadsPerThreadgroup$(indirectBuffer: _MTLBuffer, indirectBufferOffset: number, threadsPerThreadgroup: MTLSize): void;
     /**
      * Enqueue a compute function dispatch using an arbitrarily-sized grid. threadsPerGrid does not have to be a multiple of the threadGroup size
      */
-    dispatchThreads$threadsPerThreadgroup$?(threadsPerGrid: MTLSize, threadsPerThreadgroup: MTLSize): void;
+    dispatchThreads$threadsPerThreadgroup$(threadsPerGrid: MTLSize, threadsPerThreadgroup: MTLSize): void;
     /**
      * Update the fence to capture all GPU work so far enqueued by this encoder. The fence is updated at kernel 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 kernel 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 dispatch 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 dispatch 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 render pass through an argument buffer For tracked MTLHeaps, this method protects against data hazards. This method must be called before encoding any dispatch 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 render pass through an argument buffer For tracked MTLHeaps, this method protects against data hazards. This method must be called before encoding any dispatch 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;
     /**
      * Execute commands in the buffer within the range specified. The same indirect command buffer may be executed any number of times within the same encoder.
      */
-    executeCommandsInBuffer$withRange$?(indirectCommandBuffer: _MTLIndirectCommandBuffer, executionRange: NSRange): void;
+    executeCommandsInBuffer$withRange$(indirectCommandBuffer: _MTLIndirectCommandBuffer, executionRange: NSRange): void;
     /**
      * Execute commands in the buffer within the range specified by the indirect range buffer. An indirect buffer from which the device reads the execution range parameter, as laid out in the MTLIndirectCommandBufferExecutionRange structure. The byte offset within indirectBuffer where the execution range parameter is located. Must be a multiple of 4 bytes. The same indirect command buffer may be executed any number of times within the same encoder.
      */
-    executeCommandsInBuffer$indirectBuffer$indirectBufferOffset$?(indirectCommandbuffer: _MTLIndirectCommandBuffer, indirectRangeBuffer: _MTLBuffer, indirectBufferOffset: number): void;
+    executeCommandsInBuffer$indirectBuffer$indirectBufferOffset$(indirectCommandbuffer: _MTLIndirectCommandBuffer, indirectRangeBuffer: _MTLBuffer, indirectBufferOffset: number): void;
     /**
      * Encodes a barrier between currently dispatched kernels in a concurrent compute command encoder and any subsequent ones on a specified resource group This API ensures that all dispatches in the encoder have completed execution and their side effects are visible to subsequent dispatches in that encoder. Calling barrier on a serial encoder is allowed, but ignored.
      */
-    memoryBarrierWithScope$?(scope: MTLBarrierScope): void;
+    memoryBarrierWithScope$(scope: MTLBarrierScope): void;
     /**
      * Encodes a barrier between currently dispatched kernels in a concurrent compute command encoder and any subsequent ones on an array of resources. This API ensures that all dispatches in the encoder have completed execution and side effects on the specified resources are visible to subsequent dispatches in that encoder. Calling barrier on a serial encoder is allowed, but ignored.
      */
-    memoryBarrierWithResources$count$?(resources: NobjcObject, count: number): void;
+    memoryBarrierWithResources$count$(resources: NobjcObject, count: number): void;
     /**
      * Sample hardware counters at this point in the compute 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. On devices where MTLCounterSamplingPointAtDispatchBoundary is unsupported, this method is not available and will generate an error if called.
      */
-    sampleCountersInBuffer$atSampleIndex$withBarrier$?(sampleBuffer: _MTLCounterSampleBuffer, sampleIndex: number, barrier: boolean): void;
+    sampleCountersInBuffer$atSampleIndex$withBarrier$(sampleBuffer: _MTLCounterSampleBuffer, sampleIndex: number, barrier: boolean): void;
     /** The dispatch type of the compute command encoder. */
-    dispatchType?(): MTLDispatchType;
+    dispatchType(): MTLDispatchType;
 }

package/dist/Metal/MTLComputePipelineState.d.ts

@@ -18,70 +18,70 @@ export interface _MTLComputePipelineState extends _MTLAllocation {
     /**
      * Gets the function handle for a function this pipeline links at the Metal IR level by name. - Parameters: - name: A string representing the name of the function. - Returns: A function handle corresponding to the function if the name matches a function in this pipeline state, otherwise `nil`.
      */
-    functionHandleWithName$?(name: _NSString): _MTLFunctionHandle | null;
+    functionHandleWithName$(name: _NSString): _MTLFunctionHandle | null;
     /**
      * Gets the function handle for a function this pipeline links at the binary level. - Parameters: - function: A binary function object representing the function binary to find. - Returns: A function handle corresponding to the function if the binary function mathces a function in this pipeline state, otherwise `nil`.
      */
-    functionHandleWithBinaryFunction$?(function_: _MTL4BinaryFunction): _MTLFunctionHandle | null;
+    functionHandleWithBinaryFunction$(function_: _MTL4BinaryFunction): _MTLFunctionHandle | null;
     /**
      * Allocates a new compute pipeline state by adding binary functions to this pipeline state. - Parameters: - additionalBinaryFunctions: A non-`nil` array containing binary functions to add to this pipeline. - error: An optional parameter into which Metal stores information in case of an error. - Returns: A new compute pipeline state upon success, otherwise `nil`.
      */
-    newComputePipelineStateWithBinaryFunctions$error$?(additionalBinaryFunctions: _NSArray, error: NobjcObject | null): _MTLComputePipelineState | null;
+    newComputePipelineStateWithBinaryFunctions$error$(additionalBinaryFunctions: _NSArray, error: NobjcObject | null): _MTLComputePipelineState | null;
     /**
      * @method imageblockMemoryLengthForDimensions: @brief Returns imageblock memory length for given image block dimensions.
      */
-    imageblockMemoryLengthForDimensions$?(imageblockDimensions: MTLSize): number;
+    imageblockMemoryLengthForDimensions$(imageblockDimensions: MTLSize): number;
     /**
      * @method functionHandleWithFunction: @brief Get the function handle for the specified function from the pipeline state.
      */
-    functionHandleWithFunction$?(function_: _MTLFunction): _MTLFunctionHandle | null;
+    functionHandleWithFunction$(function_: _MTLFunction): _MTLFunctionHandle | null;
     /**
      * @method newRenderPipelineStateWithAdditionalBinaryFunctions:stage: @brief Allocate a new compute pipeline state by adding binary functions to this pipeline state.
      */
-    newComputePipelineStateWithAdditionalBinaryFunctions$error$?(functions: _NSArray, error: NobjcObject | null): _MTLComputePipelineState | null;
+    newComputePipelineStateWithAdditionalBinaryFunctions$error$(functions: _NSArray, error: NobjcObject | null): _MTLComputePipelineState | null;
     /**
      * @method newVisibleFunctionTableWithDescriptor: @brief Allocate a visible function table for the pipeline with the provided descriptor.
      */
-    newVisibleFunctionTableWithDescriptor$?(descriptor: _MTLVisibleFunctionTableDescriptor): _MTLVisibleFunctionTable | null;
+    newVisibleFunctionTableWithDescriptor$(descriptor: _MTLVisibleFunctionTableDescriptor): _MTLVisibleFunctionTable | null;
     /**
      * @method newIntersectionFunctionTableWithDescriptor: @brief Allocate an intersection function table for the pipeline with the provided descriptor.
      */
-    newIntersectionFunctionTableWithDescriptor$?(descriptor: _MTLIntersectionFunctionTableDescriptor): _MTLIntersectionFunctionTable | null;
-    label?(): _NSString | null;
+    newIntersectionFunctionTableWithDescriptor$(descriptor: _MTLIntersectionFunctionTableDescriptor): _MTLIntersectionFunctionTable | null;
+    label(): _NSString | null;
     /**
      * Provides access to this compute pipeline's reflection. Reflection is `nil` if you create the pipeline state object directly from the ``MTLDevice`` protocol.
      */
-    reflection?(): _MTLComputePipelineReflection | null;
+    reflection(): _MTLComputePipelineReflection | null;
     /**
      * @property device @abstract The device this resource was created against. This resource can only be used with this device.
      */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
     /**
      * @property maxTotalThreadsPerThreadgroup @abstract The maximum total number of threads that can be in a single compute threadgroup.
      */
-    maxTotalThreadsPerThreadgroup?(): number;
+    maxTotalThreadsPerThreadgroup(): number;
     /**
      * @property threadExecutionWidth @abstract For most efficient execution, the threadgroup size should be a multiple of this when executing the kernel.
      */
-    threadExecutionWidth?(): number;
+    threadExecutionWidth(): number;
     /**
      * @property staticThreadgroupMemoryLength @abstract The length in bytes of threadgroup memory that is statically allocated.
      */
-    staticThreadgroupMemoryLength?(): number;
+    staticThreadgroupMemoryLength(): number;
     /**
      * @property supportIndirectCommandBuffers @abstract Tells whether this pipeline state is usable through an Indirect Command Buffer.
      */
-    supportIndirectCommandBuffers?(): boolean;
+    supportIndirectCommandBuffers(): boolean;
     /**
      * @property gpuResourceID @abstract Handle of the GPU resource suitable for storing in an Argument Buffer
      */
-    gpuResourceID?(): MTLResourceID;
+    gpuResourceID(): MTLResourceID;
     /**
      * @property shaderValidation @abstract Current state of Shader Validation for the pipeline.
      */
-    shaderValidation?(): MTLShaderValidation;
+    shaderValidation(): MTLShaderValidation;
     /**
      * @property requiredThreadsPerThreadgroup @abstract The required size of every compute threadgroup.
      */
-    requiredThreadsPerThreadgroup?(): MTLSize;
+    requiredThreadsPerThreadgroup(): MTLSize;
 }

package/dist/Metal/MTLCounter.d.ts

@@ -1,4 +1,4 @@
 import type { _NSString } from "../Foundation/NSString.js";
 export interface _MTLCounter {
-    name?(): _NSString;
+    name(): _NSString;
 }

package/dist/Metal/MTLCounterSampleBuffer.d.ts

@@ -6,17 +6,17 @@ export interface _MTLCounterSampleBuffer {
     /**
      * @method resolveCounterRange: @abstract Resolve the counters from the sample buffer to an NSData containing the counter values. This may only be used with sample buffers that have MTLStorageModeShared. @param range The range of indices in the sample buffer to resolve. @return The resolved samples. @discussion Samples that encountered an error during resolve will be set to MTLCounterErrorValue.
      */
-    resolveCounterRange$?(range: NSRange): _NSData | null;
+    resolveCounterRange$(range: NSRange): _NSData | null;
     /**
      * @property device The device that created the sample buffer. It is only valid to use the sample buffer with this device.
      */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
     /**
      * @property label The label for the sample buffer. This is set by the label property of the descriptor that is used to create the sample buffer.
      */
-    label?(): _NSString;
+    label(): _NSString;
     /**
      * @property sampleCount The number of samples that may be stored in this sample buffer.
      */
-    sampleCount?(): number;
+    sampleCount(): number;
 }

package/dist/Metal/MTLCounterSet.d.ts

@@ -2,9 +2,9 @@ import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSString } from "../Foundation/NSString.js";
 export interface _MTLCounterSet {
     /** @property name The name of the counter set. */
-    name?(): _NSString;
+    name(): _NSString;
     /**
      * @property counters The set of counters captured by the counter set. @discussion The counters array contains all the counters that will be written when a counter sample is collected. Counters that do not appear in this array will not be written to the resolved buffer when the samples are resolved, even if they appear in the corresponding resolved counter structure. Instead MTLCounterErrorValue will be written in the resolved buffer.
      */
-    counters?(): _NSArray;
+    counters(): _NSArray;
 }

package/dist/Metal/MTLDepthStencilState.d.ts

@@ -3,11 +3,11 @@ import type { _MTLDevice } from "./MTLDevice.js";
 import type { MTLResourceID } from "../structs/MTLResourceID.js";
 export interface _MTLDepthStencilState {
     /** A string to help identify this object. */
-    label?(): _NSString | null;
+    label(): _NSString | null;
     /**
      * The device this resource was created against. This resource can only be used with this device.
      */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
     /** Handle of the GPU resource suitable for storing in an Argument Buffer */
-    gpuResourceID?(): MTLResourceID;
+    gpuResourceID(): MTLResourceID;
 }