objcjs-types 0.7.0 → 0.7.2

package/dist/MediaPlayer/MPPlayableContentDataSource.d.ts

@@ -18,9 +18,9 @@ export interface _MPPlayableContentDataSource {
     /**
      * Returns the number of child nodes at the specified index path. In a virtual filesystem, this would be the number of files in a specific folder. An empty index path represents the root node.
      */
-    numberOfChildItemsAtIndexPath$?(indexPath: _NSIndexPath): number;
+    numberOfChildItemsAtIndexPath$(indexPath: _NSIndexPath): number;
     /**
      * Returns the content item at the specified index path. If the content item is mutated after returning, its updated contents will be sent to MediaPlayer.
      */
-    contentItemAtIndexPath$?(indexPath: _NSIndexPath): _MPContentItem | null;
+    contentItemAtIndexPath$(indexPath: _NSIndexPath): _MPContentItem | null;
 }

package/dist/MediaPlayer/MPRemoteCommandHandlerStatus.d.ts

@@ -5,4 +5,4 @@ export declare const MPRemoteCommandHandlerStatus: {
     readonly DeviceNotFound: 120;
     readonly CommandFailed: 200;
 };
-export type MPRemoteCommandHandlerStatus = typeof MPRemoteCommandHandlerStatus[keyof typeof MPRemoteCommandHandlerStatus];
+export type MPRemoteCommandHandlerStatus = (typeof MPRemoteCommandHandlerStatus)[keyof typeof MPRemoteCommandHandlerStatus];

package/dist/MediaPlayer/MPRepeatType.d.ts

@@ -3,4 +3,4 @@ export declare const MPRepeatType: {
     readonly One: 1;
     readonly All: 2;
 };
-export type MPRepeatType = typeof MPRepeatType[keyof typeof MPRepeatType];
+export type MPRepeatType = (typeof MPRepeatType)[keyof typeof MPRepeatType];

package/dist/MediaPlayer/MPSeekCommandEventType.d.ts

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

package/dist/MediaPlayer/MPShuffleType.d.ts

@@ -3,4 +3,4 @@ export declare const MPShuffleType: {
     readonly Items: 1;
     readonly Collections: 2;
 };
-export type MPShuffleType = typeof MPShuffleType[keyof typeof MPShuffleType];
+export type MPShuffleType = (typeof MPShuffleType)[keyof typeof MPShuffleType];

package/dist/MediaPlayer/MPSystemMusicPlayerController.d.ts

@@ -1,5 +1,5 @@
 import type { _MPMusicPlayerQueueDescriptor } from "./MPMusicPlayerQueueDescriptor.js";
 export interface _MPSystemMusicPlayerController {
     /** Switches to Music to play the content provided by the queue descriptor. */
-    openToPlayQueueDescriptor$?(queueDescriptor: _MPMusicPlayerQueueDescriptor): void;
+    openToPlayQueueDescriptor$(queueDescriptor: _MPMusicPlayerQueueDescriptor): void;
 }

package/dist/Metal/MTL4AlphaToCoverageState.d.ts

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

package/dist/Metal/MTL4AlphaToOneState.d.ts

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

package/dist/Metal/MTL4Archive.d.ts

@@ -12,24 +12,24 @@ export interface _MTL4Archive {
     /**
      * Creates a compute pipeline state from the archive with a descriptor. - Parameters: - descriptor: A compute pipeline descriptor. - error: On return, if the method fails, a pointer to an error information instance; otherwise `nil`. - Returns: A compute pipeline state if the method succeeds, otherwise `nil`.
      */
-    newComputePipelineStateWithDescriptor$error$?(descriptor: _MTL4ComputePipelineDescriptor, error: NobjcObject | null): _MTLComputePipelineState | null;
+    newComputePipelineStateWithDescriptor$error$(descriptor: _MTL4ComputePipelineDescriptor, error: NobjcObject | null): _MTLComputePipelineState | null;
     /**
      * Creates a compute pipeline state from the archive with a compute descriptor and a dynamic linking descriptor. - Parameters: - descriptor: A compute pipeline descriptor. - dynamicLinkingDescriptor: A descriptor that provides additional properties to link other functions with the pipeline. - error: On return, if the method fails, a pointer to an error information instance; otherwise `nil`. - Returns: A compute pipeline state if the method succeeds, otherwise `nil`.
      */
-    newComputePipelineStateWithDescriptor$dynamicLinkingDescriptor$error$?(descriptor: _MTL4ComputePipelineDescriptor, dynamicLinkingDescriptor: _MTL4PipelineStageDynamicLinkingDescriptor, error: NobjcObject | null): _MTLComputePipelineState | null;
+    newComputePipelineStateWithDescriptor$dynamicLinkingDescriptor$error$(descriptor: _MTL4ComputePipelineDescriptor, dynamicLinkingDescriptor: _MTL4PipelineStageDynamicLinkingDescriptor, error: NobjcObject | null): _MTLComputePipelineState | null;
     /**
      * Creates a render pipeline state from the archive with a descriptor. You create any kind of render pipeline states with this method, including: - Traditional render pipelines - Mesh render pipelines - Tile render pipelines - Parameters: - descriptor: A render pipeline descriptor. - error: On return, if the method fails, a pointer to an error information instance; otherwise `nil`. - Returns: A render pipeline state if the method succeeds, otherwise `nil`.
      */
-    newRenderPipelineStateWithDescriptor$error$?(descriptor: _MTL4PipelineDescriptor, error: NobjcObject | null): _MTLRenderPipelineState | null;
+    newRenderPipelineStateWithDescriptor$error$(descriptor: _MTL4PipelineDescriptor, error: NobjcObject | null): _MTLRenderPipelineState | null;
     /**
      * Creates a render pipeline state from the archive with a render descriptor and a dynamic linking descriptor. You create any kind of render pipeline states with this method, including: - Traditional render pipelines - Mesh render pipelines - Tile render pipelines - Parameters: - descriptor: A render pipeline descriptor. - dynamicLinkingDescriptor: A descriptor that provides additional properties to link other functions with the pipeline. - error: On return, if the method fails, a pointer to an error information instance; otherwise `nil`. - Returns: A render pipeline state if the method succeeds, otherwise `nil`.
      */
-    newRenderPipelineStateWithDescriptor$dynamicLinkingDescriptor$error$?(descriptor: _MTL4PipelineDescriptor, dynamicLinkingDescriptor: _MTL4RenderPipelineDynamicLinkingDescriptor, error: NobjcObject | null): _MTLRenderPipelineState | null;
+    newRenderPipelineStateWithDescriptor$dynamicLinkingDescriptor$error$(descriptor: _MTL4PipelineDescriptor, dynamicLinkingDescriptor: _MTL4RenderPipelineDynamicLinkingDescriptor, error: NobjcObject | null): _MTLRenderPipelineState | null;
     /**
      * Synchronously creates a binary version of a GPU visible function or GPU intersection function. - Parameters: - descriptor: A configuration that tells the method which GPU function to make into a binary function and which options to apply when compiling it. - error: An optional pointer to an error pointer where the method returns the problem details when it can't create a binary GPU function. - Returns: A new GPU binary function instance if the method succeeds; otherwise `nil`.
      */
-    newBinaryFunctionWithDescriptor$error$?(descriptor: _MTL4BinaryFunctionDescriptor, error: NobjcObject | null): _MTL4BinaryFunction | null;
+    newBinaryFunctionWithDescriptor$error$(descriptor: _MTL4BinaryFunctionDescriptor, error: NobjcObject | null): _MTL4BinaryFunction | null;
     /** A label that you can associate with this archive. */
-    label?(): _NSString | null;
-    setLabel$?(value: _NSString | null): void;
+    label(): _NSString | null;
+    setLabel$(value: _NSString | null): void;
 }

package/dist/Metal/MTL4ArgumentTable.d.ts

@@ -5,27 +5,27 @@ export interface _MTL4ArgumentTable {
     /**
      * Binds a GPU address to a buffer binding slot. - Parameters: - gpuAddress: The GPU address of a ``MTLBuffer`` to set. - bindingIndex: a valid binding index in the buffer binding range. It is an error for this value to match or exceed the value of property ``MTL4ArgumentTableDescriptor/maxBufferBindCount`` on the descriptor from which you created this argument table.
      */
-    setAddress$atIndex$?(gpuAddress: number, bindingIndex: number): void;
+    setAddress$atIndex$(gpuAddress: number, bindingIndex: number): void;
     /**
      * Binds a GPU address to a buffer binding slot, providing a dynamic vertex stride. This method requires that the value of property ``MTL4ArgumentTableDescriptor/supportAttributeStrides`` on the descriptor from which you created this argument table is true. - Parameters: - gpuAddress: The GPU address of a ``MTLBuffer`` to set. - stride: The stride between attributes in the buffer. - bindingIndex: a valid binding index in the buffer binding range. It is an error for this value to match or exceed the value of property ``MTL4ArgumentTableDescriptor/maxBufferBindCount`` on the descriptor from which you created this argument table.
      */
-    setAddress$attributeStride$atIndex$?(gpuAddress: number, stride: number, bindingIndex: number): void;
+    setAddress$attributeStride$atIndex$(gpuAddress: number, stride: number, bindingIndex: number): void;
     /**
      * Binds a resource to a buffer binding slot. - Parameters: - resourceID: The ``MTLResourceID`` of the Metal resource to bind. - bindingIndex: a valid binding index in the buffer binding range. It is an error for this value to match or exceed the value of property ``MTL4ArgumentTableDescriptor/maxBufferBindCount`` on the descriptor from which you created this argument table.
      */
-    setResource$atBufferIndex$?(resourceID: MTLResourceID, bindingIndex: number): void;
+    setResource$atBufferIndex$(resourceID: MTLResourceID, bindingIndex: number): void;
     /**
      * Binds a texture to a texture binding slot. - Parameters: - resourceID: The ``MTLResourceID`` of the ``MTLTexture`` instance to bind. - bindingIndex: a valid binding index in the texture binding range. It is an error for this value to match or exceed the value of property ``MTL4ArgumentTableDescriptor/maxTextureBindCount`` on the descriptor from which you created this argument table.
      */
-    setTexture$atIndex$?(resourceID: MTLResourceID, bindingIndex: number): void;
+    setTexture$atIndex$(resourceID: MTLResourceID, bindingIndex: number): void;
     /**
      * Binds a sampler state to a sampler state binding slot. - Parameters: - resourceID: The ``MTLResourceID`` of the ``MTLSamplerState`` instance to bind. - bindingIndex: a valid binding index in the sampler binding range. It is an error for this value to match or exceed the value of property ``MTL4ArgumentTableDescriptor/maxSamplerStateBindCount`` on the descriptor from which you created this argument table.
      */
-    setSamplerState$atIndex$?(resourceID: MTLResourceID, bindingIndex: number): void;
+    setSamplerState$atIndex$(resourceID: MTLResourceID, bindingIndex: number): void;
     /** The device from which you created this argument table. */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
     /**
      * Assigns an optional label with this argument table for debugging purposes. You set this label by setting property ``MTL4ArgumentTableDescriptor/label`` on the descriptor object, prior to creating this table instance.
      */
-    label?(): _NSString | null;
+    label(): _NSString | null;
 }

package/dist/Metal/MTL4BinaryFunction.d.ts

@@ -2,7 +2,7 @@ import type { _NSString } from "../Foundation/NSString.js";
 import type { MTLFunctionType } from "./MTLFunctionType.js";
 export interface _MTL4BinaryFunction {
     /** Obtains the optional name of this binary function. */
-    name?(): _NSString | null;
+    name(): _NSString | null;
     /** Describes the type of this binary function. */
-    functionType?(): MTLFunctionType;
+    functionType(): MTLFunctionType;
 }

package/dist/Metal/MTL4BinaryFunctionOptions.d.ts

@@ -2,4 +2,4 @@ export declare const MTL4BinaryFunctionOptions: {
     readonly MTL4BinaryFunctionOptionNone: 0;
     readonly MTL4BinaryFunctionOptionPipelineIndependent: 2;
 };
-export type MTL4BinaryFunctionOptions = (number & {}) | typeof MTL4BinaryFunctionOptions[keyof typeof MTL4BinaryFunctionOptions];
+export type MTL4BinaryFunctionOptions = (number & {}) | (typeof MTL4BinaryFunctionOptions)[keyof typeof MTL4BinaryFunctionOptions];

package/dist/Metal/MTL4BlendState.d.ts

@@ -3,4 +3,4 @@ export declare const MTL4BlendState: {
     readonly Enabled: 1;
     readonly Unspecialized: 2;
 };
-export type MTL4BlendState = typeof MTL4BlendState[keyof typeof MTL4BlendState];
+export type MTL4BlendState = (typeof MTL4BlendState)[keyof typeof MTL4BlendState];

package/dist/Metal/MTL4CommandAllocator.d.ts

@@ -4,13 +4,13 @@ export interface _MTL4CommandAllocator {
     /**
      * Queries the size of the internal memory heaps of this command allocator that support encoding commands into command buffers. - Returns: a size in bytes.
      */
-    allocatedSize?(): number;
+    allocatedSize(): number;
     /**
      * Marks the command allocator's heaps for reuse. Calling this method allows new ``MTL4CommandBuffer`` to reuse its existing internal memory heaps to encode new GPU commands. You are responsible to ensure that all command buffers with memory originating from this allocator instance are complete before calling resetting it.
      */
-    reset?(): void;
+    reset(): void;
     /** Returns the GPU device that this command allocator belongs to. */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
     /** Provides the optional label you specify at creation time for debug purposes. */
-    label?(): _NSString | null;
+    label(): _NSString | null;
 }

package/dist/Metal/MTL4CommandBuffer.d.ts

@@ -17,56 +17,56 @@ export interface _MTL4CommandBuffer {
     /**
      * Prepares a command buffer for encoding. Attaches the command buffer to the specified ``MTL4CommandAllocator`` and declares that the application is ready to encode commands into the command buffer. Command allocators only service a single command buffer at a time. If you need to issue multiple calls to this method simultaneously, for example, in a multi-threaded command encoding scenario, create multiple instances of ``MTLCommandAllocator`` and use one for each call. You can safely reuse command allocators after ending the command buffer using it by calling ``endCommandBuffer``. After calling this method, any prior calls to ``useResidencySet:`` and ``useResidencySets:count:`` on this command buffer instance no longer apply. Make sure to call these methods again to signal your residency requirements to Metal. - Parameter allocator: ``MTL4CommandAllocator`` to attach to.
      */
-    beginCommandBufferWithAllocator$?(allocator: _MTL4CommandAllocator): void;
+    beginCommandBufferWithAllocator$(allocator: _MTL4CommandAllocator): void;
     /**
      * Prepares a command buffer for encoding with additional options. Attaches the command buffer to the specified ``MTL4CommandAllocator`` and declares that the application is ready to encode commands into the command buffer. Command allocators only service a single command buffer at a time. If you need to issue multiple calls to this method simultaneously, for example, in a multi-threaded command encoding scenario, create multiple instances of ``MTLCommandAllocator`` and use one for each call. You can safely reuse command allocators after ending the command buffer using it by calling ``endCommandBuffer``. After calling this method, any prior calls to ``useResidencySet:`` and ``useResidencySets:count:`` on this command buffer instance no longer apply. Make sure to call these methods again to signal your residency requirements to Metal. The options you provide configure the command buffer only until the command buffer ends, in the next call to ``endCommandBuffer``. - Parameters: - allocator: ``MTL4CommandAllocator`` to attach to. - options: ``MTL4CommandBufferOptions`` to configure the command buffer.
      */
-    beginCommandBufferWithAllocator$options$?(allocator: _MTL4CommandAllocator, options: _MTL4CommandBufferOptions): void;
+    beginCommandBufferWithAllocator$options$(allocator: _MTL4CommandAllocator, options: _MTL4CommandBufferOptions): void;
     /**
      * Closes a command buffer to prepare it for submission to a command queue. Explicitly ending the command buffer allows you to reuse the ``MTL4CommandAllocator`` to start servicing other command buffers. It is an error to call ``commit`` on a command buffer previously recording before calling this method.
      */
-    endCommandBuffer?(): void;
+    endCommandBuffer(): void;
     /**
      * Creates a render command encoder from a render pass descriptor. - Parameters: - descriptor: Descriptor for the render pass. - Returns: The created ``MTL4RenderCommandEncoder`` instance, or `nil` if the function failed.
      */
-    renderCommandEncoderWithDescriptor$?(descriptor: _MTL4RenderPassDescriptor): _MTL4RenderCommandEncoder | null;
+    renderCommandEncoderWithDescriptor$(descriptor: _MTL4RenderPassDescriptor): _MTL4RenderCommandEncoder | null;
     /**
      * Creates a render command encoder from a render pass descriptor with additional options. This method creates a render command encoder to encode a render pass, whilst providing you the option to define some render pass characteristics via an instance of ``MTL4RenderEncoderOptions``. Use these options to configure suspending/resuming render command encoders, which allow you to encode render passes from multiple threads simultaneously. - Parameters: - descriptor: Descriptor for the render pass. - options: ``MTL4RenderEncoderOptions`` instance that provide render pass options. - Returns: The created ``MTL4RenderCommandEncoder`` instance, or `nil` if the function fails.
      */
-    renderCommandEncoderWithDescriptor$options$?(descriptor: _MTL4RenderPassDescriptor, options: MTL4RenderEncoderOptions): _MTL4RenderCommandEncoder | null;
+    renderCommandEncoderWithDescriptor$options$(descriptor: _MTL4RenderPassDescriptor, options: MTL4RenderEncoderOptions): _MTL4RenderCommandEncoder | null;
     /**
      * Creates a compute command encoder. - Returns: The created ``MTL4ComputeCommandEncoder`` instance, or `nil` if the function fails.
      */
-    computeCommandEncoder?(): _MTL4ComputeCommandEncoder | null;
+    computeCommandEncoder(): _MTL4ComputeCommandEncoder | null;
     /**
      * Creates a machine learning command encoder. - Returns: The created ``MTL4MachineLearningCommandEncoder`` instance , or `nil` if the function fails.
      */
-    machineLearningCommandEncoder?(): _MTL4MachineLearningCommandEncoder | null;
+    machineLearningCommandEncoder(): _MTL4MachineLearningCommandEncoder | null;
     /**
      * Marks a residency set as part of the command buffer's execution. Ensures that Metal makes resident the resources that residency set contains during execution of this command buffer. - Parameter residencySet: ``MTLResidencySet`` instance to mark resident.
      */
-    useResidencySet$?(residencySet: _MTLResidencySet): void;
+    useResidencySet$(residencySet: _MTLResidencySet): void;
     /**
      * Marks an array of residency sets as part of the command buffer's execution. Ensures that Metal makes resident the resources that residency sets contain during execution of this command buffer. - Parameters: - residencySets: Array of ``MTLResidencySet`` instances to mark resident. - count: Number of ``MTLResidencySet`` instances in the array.
      */
-    useResidencySets$count$?(residencySets: NobjcObject, count: number): void;
+    useResidencySets$count$(residencySets: NobjcObject, count: number): void;
     /**
      * Pushes a string onto a stack of debug groups for this command buffer. - Parameter string: The string to push.
      */
-    pushDebugGroup$?(string_: _NSString): void;
+    pushDebugGroup$(string_: _NSString): void;
     /** Pops the latest string from the stack of debug groups for this command buffer. */
-    popDebugGroup?(): void;
+    popDebugGroup(): void;
     /**
      * Writes a GPU timestamp into the given counter heap. This method captures a timestamp after work prior to this command in the command buffer is complete. Work after this call may or may not have started. You are responsible for ensuring the `counterHeap` is of type ``MTL4CounterHeapType/MTL4CounterHeapTypeTimestamp``. - Parameters: - counterHeap: ``MTL4CounterHeap`` to write the timestamp into. - index: The index within the ``MTL4CounterHeap`` that Metal writes the timestamp to.
      */
-    writeTimestampIntoHeap$atIndex$?(counterHeap: _MTL4CounterHeap, index: number): void;
+    writeTimestampIntoHeap$atIndex$(counterHeap: _MTL4CounterHeap, index: number): void;
     /**
      * Encodes a command that resolves an opaque counter heap into a buffer. The command this method encodes converts the data within `counterHeap` into a common format and stores it into the `bufferRange` parameter. The command places each entry in the counter heap within `range` sequentially, starting at `alignedOffset`. Each entry needs to be a fixed size that you can query by calling the ``MTLDevice/sizeOfCounterHeapEntry:`` method. This command runs during the `MTLStageBlit` stage of the GPU timeline. Barrier against this stage to ensure the data is present in the resolve buffer parameter before you access it. - Note: Your app needs ensure the GPU places data in the heap before you resolve it by synchronizing this stage with other GPU operations. Similarly, your app needs to synchronize any GPU accesses to `bufferRange` after the command completes with barrier. If your app needs to access `bufferRange` from the CPU, signal an ``MTLSharedEvent`` to notify the CPU when it's ready. Alternatively, you can resolve the heap's data from the CPU by calling the heap's ``MTL4CounterHeap/resolveCounterRange:`` method. - Parameters: - counterHeap: A heap the command resolves. - range: A range of index values within the heap the command resolves. - bufferRange: The buffer the command saves the data it resolves into. - fenceToWait: A fence the GPU waits for before starting, if applicable; otherwise `nil`. - fenceToUpdate: A fence the system updates after the command finishes resolving the data; otherwise `nil`.
      */
-    resolveCounterHeap$withRange$intoBuffer$waitFence$updateFence$?(counterHeap: _MTL4CounterHeap, range: NSRange, bufferRange: MTL4BufferRange, fenceToWait: _MTLFence | null, fenceToUpdate: _MTLFence | null): void;
+    resolveCounterHeap$withRange$intoBuffer$waitFence$updateFence$(counterHeap: _MTL4CounterHeap, range: NSRange, bufferRange: MTL4BufferRange, fenceToWait: _MTLFence | null, fenceToUpdate: _MTLFence | null): void;
     /** Returns the GPU device that this command buffer belongs to. */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
     /** Assigns an optional label with this command buffer. */
-    label?(): _NSString | null;
-    setLabel$?(value: _NSString | null): void;
+    label(): _NSString | null;
+    setLabel$(value: _NSString | null): void;
 }

package/dist/Metal/MTL4CommandEncoder.d.ts

@@ -7,40 +7,40 @@ export interface _MTL4CommandEncoder {
     /**
      * 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 encode the barrier as close to the command that consumes the resource as possible. Don't use this method for synchronizing resource access within the same pass. 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. - visibilityOptions: ``MTL4VisibilityOptions`` of the barrier.
      */
-    barrierAfterQueueStages$beforeStages$visibilityOptions$?(afterQueueStages: MTLStages, beforeStages: MTLStages, visibilityOptions: MTL4VisibilityOptions): void;
+    barrierAfterQueueStages$beforeStages$visibilityOptions$(afterQueueStages: MTLStages, beforeStages: MTLStages, visibilityOptions: MTL4VisibilityOptions): void;
     /**
      * Encodes a producer barrier on work committed to the same command queue. This method encodes a barrier that guarantees that any work you encode using *subsequent command encoders*, corresponding to `beforeQueueStages`, don't begin until all commands you previously encode in the current encoder (and prior encoders), corresponding to `afterStages`, complete. When calling this method, you can pass any ``MTLStages`` to parameters `afterStages` and `beforeQueueStages`, even stages that don't relate to the current or prior command encoders. - Parameters: - afterStages: ``MTLStages`` mask that represents the stages of work to wait for. This argument applies to work corresponding to these stages you encode in the current command encoder prior to this barrier command. - beforeQueueStages: ``MTLStages`` mask that represents the stages of work that need to wait. This argument applies to subsequent encoders and not to work in the current command encoder. - visibilityOptions: ``MTL4VisibilityOptions`` of the barrier, controlling cache flush behavior.
      */
-    barrierAfterStages$beforeQueueStages$visibilityOptions$?(afterStages: MTLStages, beforeQueueStages: MTLStages, visibilityOptions: MTL4VisibilityOptions): void;
+    barrierAfterStages$beforeQueueStages$visibilityOptions$(afterStages: MTLStages, beforeQueueStages: MTLStages, visibilityOptions: MTL4VisibilityOptions): void;
     /**
      * Encodes an intra-pass barrier. Encode a barrier that guarantees that any subsequent work you encode in the *current command encoder*, corresponding to `beforeEncoderStages`, doesn't begin until all prior commands in this command encoder, corresponding to `afterEncoderStages`, completes. When calling this method, it's your responsibility to ensure parameters `afterEncoderStages` and `beforeEncoderStages` contain a combination of ``MTLStages`` for which this encoder can encode commands. For example, for a ``MTL4ComputeCommandEncoder`` instance, you can provide any combination of ``MTLStages/MTLStageDispatch``, ``MTLStages/MTLStageBlit`` and ``MTLStages/MTLStageAccelerationStructure``. - Parameters: - afterEncoderStages: ``MTLStages`` mask that represents the stages of work to wait for. This argument only applies to subsequent work you encode in the current command encoder. - beforeEncoderStages: ``MTLStages`` mask that represents the stages of work that wait. This argument only applies to work you encode in the current command encoder prior to this barrier. - visibilityOptions: ``MTL4VisibilityOptions`` of the barrier, controlling cache flush behavior.
      */
-    barrierAfterEncoderStages$beforeEncoderStages$visibilityOptions$?(afterEncoderStages: MTLStages, beforeEncoderStages: MTLStages, visibilityOptions: MTL4VisibilityOptions): void;
+    barrierAfterEncoderStages$beforeEncoderStages$visibilityOptions$(afterEncoderStages: MTLStages, beforeEncoderStages: MTLStages, visibilityOptions: MTL4VisibilityOptions): void;
     /**
      * Encodes a command to update a GPU fence. This method encodes a command that updates a ``MTLFence`` instance after all previously-encoded commands in the current command encoder, corresponding to `afterEncoderStages`, complete. Use parameter `afterEncoderStages` to pass in a combination of ``MTLStages`` for which this encoder can encode work. For example, for a ``MTL4ComputeCommandEncoder`` you can provide any combination of ``MTLStages/MTLStageDispatch``, ``MTLStages/MTLStageBlit`` and ``MTLStages/MTLStageAccelerationStructure``. - Parameters: - fence: ``MTLFence`` instance to update. - afterEncoderStages: ``MTLStages`` value that represents the stages of work to wait for. This argument only applies to work encoded in the current command encoder.
      */
-    updateFence$afterEncoderStages$?(fence: _MTLFence, afterEncoderStages: MTLStages): void;
+    updateFence$afterEncoderStages$(fence: _MTLFence, afterEncoderStages: MTLStages): void;
     /**
      * Encodes a command to wait on a GPU fence. Encode a command that guarantees that any subsequent work you encode via this current command encoder, corresponding to `beforeEncoderStages`, doesn't begin until all prior updates to the fence is complete. To successfully wait for a fence update, schedule update and wait operations on the same command queue. Use parameter `beforeEncoderStages` to pass in a combination of ``MTLStages`` for which this encoder can encode work. For example, for a ``MTL4ComputeCommandEncoder`` you can provide any combination of ``MTLStages/MTLStageDispatch``, ``MTLStages/MTLStageBlit`` and ``MTLStages/MTLStageAccelerationStructure``. - Parameters: - fence: ``MTLFence`` instance to wait for. - beforeEncoderStages:``MTLStages`` value that represents the stages of work that wait. This argument only applies to work you encode in the current command encoder.
      */
-    waitForFence$beforeEncoderStages$?(fence: _MTLFence, beforeEncoderStages: MTLStages): void;
+    waitForFence$beforeEncoderStages$(fence: _MTLFence, beforeEncoderStages: MTLStages): void;
     /**
      * Inserts a debug string into the frame data to aid debugging. Calling this method doesn't change any behaviors, but can be useful for debugging purposes. - Parameter string: The debug string to insert as a signpost.
      */
-    insertDebugSignpost$?(string_: _NSString): void;
+    insertDebugSignpost$(string_: _NSString): void;
     /**
      * Pushes a string onto this encoder's stack of debug groups. - Parameter string: The debug string to push.
      */
-    pushDebugGroup$?(string_: _NSString): void;
+    pushDebugGroup$(string_: _NSString): void;
     /** Pops the latest debug group string from this encoder's stack of debug groups. */
-    popDebugGroup?(): void;
+    popDebugGroup(): void;
     /** Declares that all command generation from this encoder is complete. */
-    endEncoding?(): void;
+    endEncoding(): void;
     /** Provides an optional label to assign to the command encoder for debug purposes. */
-    label?(): _NSString | null;
-    setLabel$?(value: _NSString | null): void;
+    label(): _NSString | null;
+    setLabel$(value: _NSString | null): void;
     /**
      * Returns the command buffer that is currently encoding commands. This property may return undefined results if you call it after calling ``endEncoding``.
      */
-    commandBuffer?(): _MTL4CommandBuffer | null;
+    commandBuffer(): _MTL4CommandBuffer | null;
 }

package/dist/Metal/MTL4CommandQueue.d.ts

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

package/dist/Metal/MTL4CommandQueueError.d.ts

@@ -7,4 +7,4 @@ export declare const MTL4CommandQueueError: {
     readonly AccessRevoked: 5;
     readonly Internal: 6;
 };
-export type MTL4CommandQueueError = typeof MTL4CommandQueueError[keyof typeof MTL4CommandQueueError];
+export type MTL4CommandQueueError = (typeof MTL4CommandQueueError)[keyof typeof MTL4CommandQueueError];

package/dist/Metal/MTL4CommitFeedback.d.ts

@@ -3,13 +3,13 @@ export interface _MTL4CommitFeedback {
     /**
      * A description of an error when the GPU encounters an issue as it runs the committed command buffers.
      */
-    error?(): _NSError | null;
+    error(): _NSError | null;
     /**
      * The host time, in seconds, when the GPU starts execution of the committed command buffers.
      */
-    GPUStartTime?(): number;
+    GPUStartTime(): number;
     /**
      * The host time, in seconds, when the GPU finishes execution of the committed command buffers.
      */
-    GPUEndTime?(): number;
+    GPUEndTime(): number;
 }

package/dist/Metal/MTL4Compiler.d.ts

@@ -23,89 +23,89 @@ export interface _MTL4Compiler {
     /**
      * Creates a new Metal library synchronously. - Parameters: - descriptor: A description of the library to create. - error: An optional parameter into which Metal stores information in case of an error. - Returns: a Metal library instance upon success, `nil` otherwise.
      */
-    newLibraryWithDescriptor$error$?(descriptor: _MTL4LibraryDescriptor, error: NobjcObject | null): _MTLLibrary | null;
+    newLibraryWithDescriptor$error$(descriptor: _MTL4LibraryDescriptor, error: NobjcObject | null): _MTLLibrary | null;
     /**
      * Creates a new dynamic library from a library containing Metal IR code synchronously. - Parameters: - library: A library from which this compiler creates the new a dynamic library - error: An optional parameter into which Metal stores information in case of an error. - Returns: A new dynamic Metal library upon success, `nil` otherwise.
      */
-    newDynamicLibrary$error$?(library: _MTLLibrary, error: NobjcObject | null): _MTLDynamicLibrary | null;
+    newDynamicLibrary$error$(library: _MTLLibrary, error: NobjcObject | null): _MTLDynamicLibrary | null;
     /**
      * Creates a new dynamic library from the contents of a file at an URL location synchronously. - Parameters: - url: An URL referencing a file whose contents this compiler uses to build a dynamic library. - error: An optional parameter into which Metal stores information in case of an error. - Returns: A new dynamic Metal library upon success, `nil` otherwise.
      */
-    newDynamicLibraryWithURL$error$?(url: _NSURL, error: NobjcObject | null): _MTLDynamicLibrary | null;
+    newDynamicLibraryWithURL$error$(url: _NSURL, error: NobjcObject | null): _MTLDynamicLibrary | null;
     /**
      * Creates a new compute pipeline state object synchronously. - Parameters: - descriptor: A compute pipeline state descriptor describing the pipeline this compiler creates. - compilerTaskOptions: A description of the compilation process itself, providing parameters that influence execution of the compilation process. - error: An optional parameter into which Metal stores information in case of an error. - Returns: A new compute pipeline state object upon success, `nil` otherwise.
      */
-    newComputePipelineStateWithDescriptor$compilerTaskOptions$error$?(descriptor: _MTL4ComputePipelineDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, error: NobjcObject | null): _MTLComputePipelineState | null;
+    newComputePipelineStateWithDescriptor$compilerTaskOptions$error$(descriptor: _MTL4ComputePipelineDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, error: NobjcObject | null): _MTLComputePipelineState | null;
     /**
      * Creates a new compute pipeline state synchronously. - Parameters: - descriptor: A compute pipeline state descriptor describing the pipeline this compiler creates. - dynamicLinkingDescriptor: An optional parameter that provides additional configuration for linking the pipeline state object. - compilerTaskOptions: A description of the compilation process itself, providing parameters that influence execution of the compilation process. - error: An optional parameter into which Metal stores information in case of an error. - Returns: A new compute pipeline state object upon success, `nil` otherwise.
      */
-    newComputePipelineStateWithDescriptor$dynamicLinkingDescriptor$compilerTaskOptions$error$?(descriptor: _MTL4ComputePipelineDescriptor, dynamicLinkingDescriptor: _MTL4PipelineStageDynamicLinkingDescriptor | null, compilerTaskOptions: _MTL4CompilerTaskOptions | null, error: NobjcObject | null): _MTLComputePipelineState | null;
+    newComputePipelineStateWithDescriptor$dynamicLinkingDescriptor$compilerTaskOptions$error$(descriptor: _MTL4ComputePipelineDescriptor, dynamicLinkingDescriptor: _MTL4PipelineStageDynamicLinkingDescriptor | null, compilerTaskOptions: _MTL4CompilerTaskOptions | null, error: NobjcObject | null): _MTLComputePipelineState | null;
     /**
      * Creates a new render pipeline state synchronously. Use this method to build any render pipeline type, including render, tile, and mesh render pipeline states. The type of the descriptor you pass indicates the pipeline type this method builds. Passing in a compute pipeline descriptor to the `descriptor` parameter produces an error. - Parameters: - descriptor: A render, tile, or mesh pipeline state descriptor that describes the pipeline to create. - compilerTaskOptions: A description of the compilation process itself, providing parameters that influence execution of the compilation process. - error: An optional parameter into which Metal stores information in case of an error. - Returns: A new render pipeline state object upon success, `nil` otherwise.
      */
-    newRenderPipelineStateWithDescriptor$compilerTaskOptions$error$?(descriptor: _MTL4PipelineDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, error: NobjcObject | null): _MTLRenderPipelineState | null;
+    newRenderPipelineStateWithDescriptor$compilerTaskOptions$error$(descriptor: _MTL4PipelineDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, error: NobjcObject | null): _MTLRenderPipelineState | null;
     /**
      * Creates a new render pipeline state synchronously. Use this method to build any render pipeline type, including render, tile, and mesh render pipeline states. The type of the descriptor you pass indicates the pipeline type this method builds. Passing in a compute pipeline descriptor to the `descriptor` parameter produces an error. - Parameters: - descriptor: A render, tile, or mesh pipeline state descriptor that describes the pipeline to create. - dynamicLinkingDescriptor: An optional parameter that provides additional configuration for linking the pipeline state object. - compilerTaskOptions: A description of the compilation process itself, providing parameters that influence execution of the compilation process. - error: An optional parameter into which Metal stores information in case of an error. - Returns: A new render pipeline state object upon success, `nil` otherwise.
      */
-    newRenderPipelineStateWithDescriptor$dynamicLinkingDescriptor$compilerTaskOptions$error$?(descriptor: _MTL4PipelineDescriptor, dynamicLinkingDescriptor: _MTL4RenderPipelineDynamicLinkingDescriptor | null, compilerTaskOptions: _MTL4CompilerTaskOptions | null, error: NobjcObject | null): _MTLRenderPipelineState | null;
+    newRenderPipelineStateWithDescriptor$dynamicLinkingDescriptor$compilerTaskOptions$error$(descriptor: _MTL4PipelineDescriptor, dynamicLinkingDescriptor: _MTL4RenderPipelineDynamicLinkingDescriptor | null, compilerTaskOptions: _MTL4CompilerTaskOptions | null, error: NobjcObject | null): _MTLRenderPipelineState | null;
     /**
      * Creates a new render pipeline state from another, previously unspecialized, pipeline state. Metal specializes the pipeline state with new state values the descriptor provides, observing the following rules: * The compiler only updates properties that were originally specified as *unspecialized*. It doesn't modify other already-specialized properties * The compiler sets to their default behavior any unspecialized properties that your passed-in descriptor doesn't specialize Additionally, there are some cases where the Metal can't specialize a pipeline: * If the original pipeline state object doesn't have any unspecialized properties * You can't re-specialize a previously specialized pipeline state object - Parameters: - descriptor: A render pipeline state descriptor or any type: default, tile, or mesh render pipeline descriptor. - pipeline: A render pipeline state containing unspecialized substate. - error: An optional parameter into which Metal stores information in case of an error. - Returns: a fully-specialized pipeline state object.
      */
-    newRenderPipelineStateBySpecializationWithDescriptor$pipeline$error$?(descriptor: _MTL4PipelineDescriptor, pipeline: _MTLRenderPipelineState, error: NobjcObject | null): _MTLRenderPipelineState | null;
+    newRenderPipelineStateBySpecializationWithDescriptor$pipeline$error$(descriptor: _MTL4PipelineDescriptor, pipeline: _MTLRenderPipelineState, error: NobjcObject | null): _MTLRenderPipelineState | null;
     /**
      * Creates a new binary visible or intersection function synchronously. - Parameters: - descriptor: A binary function descriptor to use for creating the binary function. - compilerTaskOptions: A descriptor of the compilation itself, providing parameters that influence execution of the compilation process. - error: An optional parameter into which Metal stores information in case of an error. - Returns: a new binary function upon success, `nil` otherwise.
      */
-    newBinaryFunctionWithDescriptor$compilerTaskOptions$error$?(descriptor: _MTL4BinaryFunctionDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, error: NobjcObject | null): _MTL4BinaryFunction | null;
+    newBinaryFunctionWithDescriptor$compilerTaskOptions$error$(descriptor: _MTL4BinaryFunctionDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, error: NobjcObject | null): _MTL4BinaryFunction | null;
     /**
      * Creates a new Metal library instance asynchronously. - Parameters: - descriptor: A description of the library to create. - completionHandler: A block Metal calls when it finishes the build task. - Returns: a compiler task representing the asynchronous compilation task.
      */
-    newLibraryWithDescriptor$completionHandler$?(descriptor: _MTL4LibraryDescriptor, completionHandler: (arg0: _MTLLibrary, arg1: _NSError) => void): _MTL4CompilerTask;
+    newLibraryWithDescriptor$completionHandler$(descriptor: _MTL4LibraryDescriptor, completionHandler: (arg0: _MTLLibrary, arg1: _NSError) => void): _MTL4CompilerTask;
     /**
      * Creates a new dynamic Metal library instance asynchronously. - Parameters: - library: A library from which this compiler creates the new a dynamic library - completionHandler: A block Metal calls when it finishes the build task. - Returns: A compiler task representing the asynchronous compilation task.
      */
-    newDynamicLibrary$completionHandler$?(library: _MTLLibrary, completionHandler: (arg0: _MTLDynamicLibrary, arg1: _NSError) => void): _MTL4CompilerTask;
+    newDynamicLibrary$completionHandler$(library: _MTLLibrary, completionHandler: (arg0: _MTLDynamicLibrary, arg1: _NSError) => void): _MTL4CompilerTask;
     /**
      * Creates a new dynamic library from the contents of a file at an URL location synchronously. - Parameters: - url: An URL referencing a file whose contents this compiler uses to build a dynamic library. - completionHandler: A block Metal calls when it finishes the build task. - Returns: a compiler task representing the asynchronous compilation task.
      */
-    newDynamicLibraryWithURL$completionHandler$?(url: _NSURL, completionHandler: (arg0: _MTLDynamicLibrary, arg1: _NSError) => void): _MTL4CompilerTask;
+    newDynamicLibraryWithURL$completionHandler$(url: _NSURL, completionHandler: (arg0: _MTLDynamicLibrary, arg1: _NSError) => void): _MTL4CompilerTask;
     /**
      * Creates a new compute pipeline state asynchronously. - Parameters: - descriptor: A compute pipeline state descriptor, describing the compute pipeline to create. - compilerTaskOptions: A descriptor of the compilation itself, providing parameters that influence execution of the compilation process. - completionHandler: A block Metal calls when it finishes the build task. - Returns: a compiler task representing the asynchronous compilation task.
      */
-    newComputePipelineStateWithDescriptor$compilerTaskOptions$completionHandler$?(descriptor: _MTL4ComputePipelineDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, completionHandler: (arg0: _MTLComputePipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
+    newComputePipelineStateWithDescriptor$compilerTaskOptions$completionHandler$(descriptor: _MTL4ComputePipelineDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, completionHandler: (arg0: _MTLComputePipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
     /**
      * Creates a new compute pipeline state asynchronously. - Parameters: - descriptor: A compute pipeline state descriptor, describing the compute pipeline to create. - dynamicLinkingDescriptor: An optional parameter that provides additional configuration for linking the pipeline state object. - compilerTaskOptions: A description of the compilation process itself, providing parameters that influence execution of the compilation process. - completionHandler: A block Metal calls when it finishes the build task. - Returns: a compiler task representing the asynchronous compilation task.
      */
-    newComputePipelineStateWithDescriptor$dynamicLinkingDescriptor$compilerTaskOptions$completionHandler$?(descriptor: _MTL4ComputePipelineDescriptor, dynamicLinkingDescriptor: _MTL4PipelineStageDynamicLinkingDescriptor | null, compilerTaskOptions: _MTL4CompilerTaskOptions | null, completionHandler: (arg0: _MTLComputePipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
+    newComputePipelineStateWithDescriptor$dynamicLinkingDescriptor$compilerTaskOptions$completionHandler$(descriptor: _MTL4ComputePipelineDescriptor, dynamicLinkingDescriptor: _MTL4PipelineStageDynamicLinkingDescriptor | null, compilerTaskOptions: _MTL4CompilerTaskOptions | null, completionHandler: (arg0: _MTLComputePipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
     /**
      * Creates a new render pipeline state asynchronously. Use this method to build any render pipeline type, including render, tile, and mesh render pipeline states. The type of the descriptor you pass indicates the pipeline type this method builds. Passing in a compute pipeline descriptor to the `descriptor` parameter produces an error. - Parameters: - descriptor: A render, tile, or mesh pipeline state descriptor that describes the pipeline to create. - compilerTaskOptions: A description of the compilation process itself, providing parameters that influence execution of the compilation process. - completionHandler: A block Metal calls when it finishes the build task. - Returns: a compiler task representing the asynchronous compilation task.
      */
-    newRenderPipelineStateWithDescriptor$compilerTaskOptions$completionHandler$?(descriptor: _MTL4PipelineDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, completionHandler: (arg0: _MTLRenderPipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
+    newRenderPipelineStateWithDescriptor$compilerTaskOptions$completionHandler$(descriptor: _MTL4PipelineDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, completionHandler: (arg0: _MTLRenderPipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
     /**
      * Creates a new render pipeline state asynchronously. Use this method to build any render pipeline type, including render, tile, and mesh render pipeline states. The type of the descriptor you pass indicates the pipeline type this method builds. Passing in a compute pipeline descriptor to the `descriptor` parameter produces an error. - Parameters: - descriptor: A render, tile, or mesh pipeline state descriptor that describes the pipeline to create. - dynamicLinkingDescriptor: An optional parameter that provides additional configuration for linking the pipeline state object. - compilerTaskOptions: A description of the compilation process itself, providing parameters that influence execution of the compilation process. - completionHandler: A block Metal calls when it finishes the build task. - Returns: a compiler task representing the asynchronous compilation task.
      */
-    newRenderPipelineStateWithDescriptor$dynamicLinkingDescriptor$compilerTaskOptions$completionHandler$?(descriptor: _MTL4PipelineDescriptor, dynamicLinkingDescriptor: _MTL4RenderPipelineDynamicLinkingDescriptor | null, compilerTaskOptions: _MTL4CompilerTaskOptions | null, completionHandler: (arg0: _MTLRenderPipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
+    newRenderPipelineStateWithDescriptor$dynamicLinkingDescriptor$compilerTaskOptions$completionHandler$(descriptor: _MTL4PipelineDescriptor, dynamicLinkingDescriptor: _MTL4RenderPipelineDynamicLinkingDescriptor | null, compilerTaskOptions: _MTL4CompilerTaskOptions | null, completionHandler: (arg0: _MTLRenderPipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
     /**
      * Creates a new render pipeline state from another, previously unspecialized, pipeline state Metal specializes the pipeline state with new state values the descriptor provides, observing the following rules: * The compiler only updates properties that were originally specified as *unspecialized*. It doesn't modify other already-specialized properties * The compiler sets to their default behavior any unspecialized properties that your passed-in descriptor doesn't specialize Additionally, there are some cases where the Metal can't specialize a pipeline: * If the original pipeline state object doesn't have any unspecialized properties * You can't re-specialize a previously specialized pipeline state object - Parameters: - descriptor: A render pipeline state descriptor or any type: default, tile, or mesh render pipeline descriptor. - pipeline: A render pipeline state containing unspecialized substate. - completionHandler: A block Metal calls when it finishes the build task. - Returns: a compiler task representing the asynchronous compilation task.
      */
-    newRenderPipelineStateBySpecializationWithDescriptor$pipeline$completionHandler$?(descriptor: _MTL4PipelineDescriptor, pipeline: _MTLRenderPipelineState, completionHandler: (arg0: _MTLRenderPipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
+    newRenderPipelineStateBySpecializationWithDescriptor$pipeline$completionHandler$(descriptor: _MTL4PipelineDescriptor, pipeline: _MTLRenderPipelineState, completionHandler: (arg0: _MTLRenderPipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
     /**
      * Returns a new compiler task that asyncrhonously creates a binary version of a GPU visible function or GPU intersection function. - Parameters: - descriptor: A configuration that tells the method which GPU function to make into a binary function and which options to apply when compiling it. - compilerTaskOptions: A configuration for the compiler task. - completionHandler: A completetion handler that you provide, which the task calls when it finishes compiling the binary function.
      */
-    newBinaryFunctionWithDescriptor$compilerTaskOptions$completionHandler$?(descriptor: _MTL4BinaryFunctionDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, completionHandler: (arg0: _MTL4BinaryFunction, arg1: _NSError) => void): _MTL4CompilerTask;
+    newBinaryFunctionWithDescriptor$compilerTaskOptions$completionHandler$(descriptor: _MTL4BinaryFunctionDescriptor, compilerTaskOptions: _MTL4CompilerTaskOptions | null, completionHandler: (arg0: _MTL4BinaryFunction, arg1: _NSError) => void): _MTL4CompilerTask;
     /**
      * Creates a new ML pipeline state with descriptor. - Parameters: - descriptor: A machine learning pipeline state descriptor to use for creating the new pipeline state. - error: An optional parameter into which Metal stores information in case of an error. - Returns: A machine learning pipeline state if operation is successful, otherwise `nil`.
      */
-    newMachineLearningPipelineStateWithDescriptor$error$?(descriptor: _MTL4MachineLearningPipelineDescriptor, error: NobjcObject | null): _MTL4MachineLearningPipelineState | null;
+    newMachineLearningPipelineStateWithDescriptor$error$(descriptor: _MTL4MachineLearningPipelineDescriptor, error: NobjcObject | null): _MTL4MachineLearningPipelineState | null;
     /**
      * Creates a new machine learning pipeline state asynchronously. - Parameters: - descriptor: A machine learning pipeline state descriptor to use for creating the new pipeline state. - completionHandler: A block Metal calls when it finishes the build task. - Returns: a compiler task representing the asynchronous compilation task.
      */
-    newMachineLearningPipelineStateWithDescriptor$completionHandler$?(descriptor: _MTL4MachineLearningPipelineDescriptor, completionHandler: (arg0: _MTL4MachineLearningPipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
+    newMachineLearningPipelineStateWithDescriptor$completionHandler$(descriptor: _MTL4MachineLearningPipelineDescriptor, completionHandler: (arg0: _MTL4MachineLearningPipelineState, arg1: _NSError) => void): _MTL4CompilerTask;
     /** Returns the device that this compiler belongs to. */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
     /** Returns the optional label you specify at creation time. */
-    label?(): _NSString | null;
+    label(): _NSString | null;
     /**
      * Returns the pipeline data set serializer into which this compiler stores data for all pipelines it creates.
      */
-    pipelineDataSetSerializer?(): _MTL4PipelineDataSetSerializer | null;
+    pipelineDataSetSerializer(): _MTL4PipelineDataSetSerializer | null;
 }

package/dist/Metal/MTL4CompilerTask.d.ts

@@ -4,9 +4,9 @@ export interface _MTL4CompilerTask {
     /**
      * Waits synchronously for this compile task to complete by blocking the calling thread.
      */
-    waitUntilCompleted?(): void;
+    waitUntilCompleted(): void;
     /** Returns the compiler instance that this asynchronous compiler task belongs to. */
-    compiler?(): _MTL4Compiler;
+    compiler(): _MTL4Compiler;
     /** Returns the compiler task status. The default is `MTL4CompilerStatusNone`. */
-    status?(): MTL4CompilerTaskStatus;
+    status(): MTL4CompilerTaskStatus;
 }