objcjs-types 0.1.0 → 0.2.1

package/dist/AVFoundation/AVAssetTrack.d.ts

@@ -1,9 +1,11 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _AVAsset } from "./AVAsset.js";
 import type { _AVAssetTrackSegment } from "./AVAssetTrackSegment.js";
+import type { _AVAsynchronousKeyValueLoading } from "./AVAsynchronousKeyValueLoading.js";
 import type { _AVSampleCursor } from "./AVSampleCursor.js";
 import type { CGAffineTransform } from "../structs/CGAffineTransform.js";
 import type { CGSize } from "../structs/CGSize.js";
@@ -18,7 +20,7 @@ export declare class _AVAssetTrack extends _NSObject {
     /**
      * Reports whether the track references media with the specified media characteristic. - Parameter mediaCharacteristic: The media characteristic of interest, e.g. AVMediaCharacteristicVisual, AVMediaCharacteristicAudible, AVMediaCharacteristicLegible, etc., as defined above. - Returns: YES if the track references media with the specified characteristic, otherwise NO.
      */
-    hasMediaCharacteristic$(mediaCharacteristic: number): boolean;
+    hasMediaCharacteristic$(mediaCharacteristic: _NSString): boolean;
     /**
      * Supplies the AVAssetTrackSegment from the segments array with a target timeRange that either contains the specified track time or is the closest to it among the target timeRanges of the track's segments. If the trackTime does not map to a sample presentation time (e.g. it's outside the track's timeRange), the segment closest in time to the specified trackTime is returned. - Parameter trackTime: The trackTime for which an AVAssetTrackSegment is requested. - Returns: An AVAssetTrackSegment.
      * @deprecated Use loadSegment(forTrackTime:) instead
@@ -27,7 +29,7 @@ export declare class _AVAssetTrack extends _NSObject {
     /**
      * Loads the AVAssetTrackSegment from the segments array with a target timeRange that either contains the specified track time or is the closest to it among the target timeRanges of the track's segments. If the trackTime does not map to a sample presentation time (e.g. it's outside the track's timeRange), the segment closest in time to the specified trackTime is returned. - Parameter trackTime: The trackTime for which an AVAssetTrackSegment is requested. - Parameter completionHandler: A block that is invoked when loading is complete, vending an AVAssetTrackSegment or an error.
      */
-    loadSegmentForTrackTime$completionHandler$(trackTime: CMTime, completionHandler: NobjcObject): void;
+    loadSegmentForTrackTime$completionHandler$(trackTime: CMTime, completionHandler: NobjcObject | null): void;
     /**
      * Maps the specified trackTime through the appropriate time mapping and returns the resulting sample presentation time. - Parameter trackTime: The trackTime for which a sample presentation time is requested. - Returns: A CMTime; will be invalid if the trackTime is out of range
      * @deprecated Use loadSamplePresentationTime(forTrackTime:) instead
@@ -36,7 +38,7 @@ export declare class _AVAssetTrack extends _NSObject {
     /**
      * Maps the specified trackTime through the appropriate time mapping and loads the resulting sample presentation time. - Parameter trackTime: The trackTime for which a sample presentation time is requested. - Parameter completionHandler: A block that is invoked when loading is complete, vending a CMTime (which will be invalid if the trackTime is out of range) or an error.
      */
-    loadSamplePresentationTimeForTrackTime$completionHandler$(trackTime: CMTime, completionHandler: NobjcObject): void;
+    loadSamplePresentationTimeForTrackTime$completionHandler$(trackTime: CMTime, completionHandler: NobjcObject | null): void;
     /**
      * Provides an NSArray of AVMetadataItems, one for each metadata item in the container of the specified format. Becomes callable without blocking when the key @"availableMetadataFormats" has been loaded - Parameter format: The metadata format for which items are requested. - Returns: An NSArray containing AVMetadataItems.
      * @deprecated Use loadMetadata(for:) instead
@@ -45,7 +47,7 @@ export declare class _AVAssetTrack extends _NSObject {
     /**
      * Loads an NSArray of AVMetadataItems, one for each metadata item in the container of the specified format. - Parameter format: The metadata format for which items are requested. - Parameter completionHandler: A block that is invoked when loading is complete, vending the array of metadata items (which may be empty if there is no metadata of the specified format) or an error.
      */
-    loadMetadataForFormat$completionHandler$(format: AVMetadataFormat, completionHandler: NobjcObject): void;
+    loadMetadataForFormat$completionHandler$(format: AVMetadataFormat, completionHandler: NobjcObject | null): void;
     /**
      * Provides an NSArray of AVAssetTracks, one for each track associated with the receiver with the specified type of track association. Becomes callable without blocking when the key @"availableTrackAssociationTypes" has been loaded. - Parameter trackAssociationType: The type of track association for which associated tracks are requested. - Returns: An NSArray containing AVAssetTracks; may be empty if there is no associated tracks of the specified type.
      * @deprecated Use loadAssociatedTracks(ofType:) instead
@@ -54,7 +56,7 @@ export declare class _AVAssetTrack extends _NSObject {
     /**
      * Provides an NSArray of AVAssetTracks, one for each track associated with the receiver with the specified type of track association. - Parameter trackAssociationType: The type of track association for which associated tracks are requested. - Parameter completionHandler: A block that is invoked when loading is comlete, vending an array of tracks (which may be empty if there is no associated tracks of the specified type) or an error. `
      */
-    loadAssociatedTracksOfType$completionHandler$(trackAssociationType: AVTrackAssociationType, completionHandler: NobjcObject): void;
+    loadAssociatedTracksOfType$completionHandler$(trackAssociationType: AVTrackAssociationType, completionHandler: NobjcObject | null): void;
     /**
      * Creates an instance of AVSampleCursor and positions it at or near the specified presentation timestamp. If the receiver's asset has a value of YES for providesPreciseDurationAndTiming, the sample cursor will be accurately positioned at the receiver's last media sample with presentation timestamp less than or equal to the desired timestamp, or, if there are no such samples, the first sample in presentation order. If the receiver's asset has a value of NO for providesPreciseDurationAndTiming, and it is prohibitively expensive to locate the precise sample at the desired timestamp, the sample cursor may be approximately positioned. This method will return nil if there are no samples in the track. - Parameter presentationTimeStamp: The desired initial presentation timestamp of the returned AVSampleCursor. - Returns: An instance of AVSampleCursor.
      */
@@ -70,11 +72,11 @@ export declare class _AVAssetTrack extends _NSObject {
     /** Provides a reference to the AVAsset of which the AVAssetTrack is a part */
     asset(): _AVAsset | null;
     /** Indicates the persistent unique identifier for this track of the asset */
-    trackID(): NobjcObject;
+    trackID(): number;
     /**
      * Indicates the media type for this track, e.g. AVMediaTypeVideo, AVMediaTypeAudio, etc., as defined in AVMediaFormat.h.
      */
-    mediaType(): number;
+    mediaType(): _NSString;
     /**
      * Provides an array of CMFormatDescriptions each of which indicates the format of media samples referenced by the track; a track that presents uniform media, e.g. encoded according to the same encoding settings, will provide an array with a count of 1.
      * @deprecated Use load(.isPlayable) instead
@@ -107,7 +109,7 @@ export declare class _AVAssetTrack extends _NSObject {
     /**
      * Indicates a timescale in which time values for the track can be operated upon without extraneous numerical conversion
      */
-    naturalTimeScale(): NobjcObject;
+    naturalTimeScale(): number;
     /**
      * Indicates the estimated data rate of the media data referenced by the track, in units of bits per second
      */
@@ -182,3 +184,5 @@ export declare class _AVAssetTrack extends _NSObject {
      */
     canProvideSampleCursors(): boolean;
 }
+export interface _AVAssetTrack extends _NSCopying, _AVAsynchronousKeyValueLoading {
+}

package/dist/AVFoundation/AVAssetTrackGroup.d.ts

@@ -1,4 +1,5 @@
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 export declare class _AVAssetTrackGroup extends _NSObject {
     static alloc(): _AVAssetTrackGroup;
@@ -9,3 +10,5 @@ export declare class _AVAssetTrackGroup extends _NSObject {
      */
     trackIDs(): _NSArray;
 }
+export interface _AVAssetTrackGroup extends _NSCopying {
+}

package/dist/AVFoundation/AVAssetVariantQualifier.d.ts

@@ -1,3 +1,4 @@
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSPredicate } from "../Foundation/NSPredicate.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -73,3 +74,5 @@ export declare class _AVAssetVariantQualifier extends _NSObject {
      */
     static predicateForAudioSampleRate$operatorType$(sampleRate: number, operatorType: NSPredicateOperatorType): _NSPredicate;
 }
+export interface _AVAssetVariantQualifier extends _NSCopying {
+}

package/dist/AVFoundation/AVAssetWriter.d.ts

@@ -3,6 +3,7 @@ import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 import type { _UTType } from "../UniformTypeIdentifiers/UTType.js";
 import type { _AVAssetWriterDelegate } from "./AVAssetWriterDelegate.js";
@@ -18,11 +19,11 @@ export declare class _AVAssetWriter extends _NSObject {
     /**
      * Returns an instance of AVAssetWriter configured to write to a file in a specified container format. The location of the file to be written. The URL must be a file URL. A UTI indicating the format of the file to be written. On return, if initialization of the AVAssetWriter fails, points to an NSError describing the nature of the failure. An instance of AVAssetWriter. Writing will fail if a file already exists at the specified URL. UTIs for container formats that can be written are declared in AVMediaFormat.h.
      */
-    static assetWriterWithURL$fileType$error$(outputURL: _NSURL, outputFileType: number, outError: NobjcObject): _AVAssetWriter | null;
+    static assetWriterWithURL$fileType$error$(outputURL: _NSURL, outputFileType: _NSString, outError: NobjcObject | null): _AVAssetWriter | null;
     /**
      * Creates an instance of AVAssetWriter configured to write to a file in a specified container format. The location of the file to be written. The URL must be a file URL. A UTI indicating the format of the file to be written. On return, if initialization of the AVAssetWriter fails, points to an NSError describing the nature of the failure. An instance of AVAssetWriter. Writing will fail if a file already exists at the specified URL. This method throws an exception if the output file type is not declared in AVMediaFormat.h.
      */
-    initWithURL$fileType$error$(outputURL: _NSURL, outputFileType: number, outError: NobjcObject): _AVAssetWriter | null;
+    initWithURL$fileType$error$(outputURL: _NSURL, outputFileType: _NSString, outError: NobjcObject | null): _AVAssetWriter | null;
     /**
      * Creates an instance of AVAssetWriter configured to output segment data in a specified container format. A UTType indicating the format of the segment data to be output. An instance of AVAssetWriter. Clients that want to receive segment data through the -assetWriter:didOutputSegmentData:segmentType:segmentReport: or -assetWriter:didOutputSegmentData:segmentType: delegate method should use this initializer instead of -initWithURL:fileType:error:. Clients may use +typeWithIdentifier: with a UTI to create an instance of UTType. See <UniformTypeIdentifiers /UTType.h>. This method throws an exception if the output content type UTI for container format is not declared in AVMediaFormat.h.
      */
@@ -30,7 +31,7 @@ export declare class _AVAssetWriter extends _NSObject {
     /**
      * Tests whether output settings for a specific media type are supported by the receiver's file format. The output settings that are to be tested. The media type for which the output settings are to be tested. Media types are defined in AVMediaFormat.h. A BOOL indicating whether the given output settings can be used for the given media type. This method determines whether the output settings for the specified media type can be used with the receiver's file format. For example, video compression settings that specify H.264 compression are not compatible with file formats that cannot contain H.264-compressed video. Attempting to add an input with output settings and a media type for which this method returns NO will cause an exception to be thrown.
      */
-    canApplyOutputSettings$forMediaType$(outputSettings: _NSDictionary | null, mediaType: number): boolean;
+    canApplyOutputSettings$forMediaType$(outputSettings: _NSDictionary | null, mediaType: _NSString): boolean;
     /**
      * Tests whether an input can be added to the receiver. The AVAssetWriterInput object to be tested. A BOOL indicating whether the input can be added to the receiver. An input that accepts media data of a type that is not compatible with the receiver, or with output settings that are not compatible with the receiver, cannot be added.
      */
@@ -85,7 +86,7 @@ export declare class _AVAssetWriter extends _NSObject {
     /**
      * The UTI of the file format of the file for which the instance of AVAssetWriter was initialized for writing.
      */
-    outputFileType(): number;
+    outputFileType(): _NSString;
     /**
      * The media types for which inputs can be added to the receiver. Some media types may not be accepted within the file format with which an AVAssetWriter was initialized.
      */
@@ -145,8 +146,8 @@ export declare class _AVAssetWriter extends _NSObject {
     /**
      * For file types that contain a 'moov' atom, such as QuickTime Movie files, specifies the asset-level time scale to be used. The default value is 0, which indicates that the receiver should choose a convenient value, if applicable. This property cannot be set after writing has started.
      */
-    movieTimeScale(): NobjcObject;
-    setMovieTimeScale$(value: NobjcObject): void;
+    movieTimeScale(): number;
+    setMovieTimeScale$(value: number): void;
     /**
      * The instances of AVAssetWriterInputGroup that have been added to the AVAssetWriter. The value of this property is an NSArray containing concrete instances of AVAssetWriterInputGroup. Input groups can be added to the receiver using the addInputGroup: method.
      */

package/dist/AVFoundation/AVAssetWriterInput.d.ts

@@ -16,24 +16,24 @@ export declare class _AVAssetWriterInput extends _NSObject {
     /**
      * Creates a new input of the specified media type to receive sample buffers for writing to the output file. Each new input accepts data for a new track of the AVAssetWriter's output file. Inputs are added to an asset writer using -[AVAssetWriter addInput:]. Passing nil for output settings instructs the input to pass through appended samples, doing no processing before they are written to the output file. This is useful if, for example, you are appending buffers that are already in a desirable compressed format. However, if not writing to a QuickTime Movie file (i.e. the AVAssetWriter was initialized with a file type other than AVFileTypeQuickTimeMovie), AVAssetWriter only supports passing through a restricted set of media types and subtypes. In order to pass through media data to files other than AVFileTypeQuickTimeMovie, a non-NULL format hint must be provided using +assetWriterInputWithMediaType:outputSettings:sourceFormatHint: instead of this method. For AVMediaTypeAudio the following keys are not currently supported in the outputSettings dictionary: AVSampleRateConverterAudioQualityKey. When using this method to construct a new instance, an audio settings dictionary must be fully specified, meaning that it must contain AVFormatIDKey, AVSampleRateKey, and AVNumberOfChannelsKey. If no other channel layout information is available, a value of 1 for AVNumberOfChannelsKey will result in mono output and a value of 2 will result in stereo output. If AVNumberOfChannelsKey specifies a channel count greater than 2, the dictionary must also specify a value for AVChannelLayoutKey. For kAudioFormatLinearPCM, all relevant AVLinearPCM*Key keys must be included, and for kAudioFormatAppleLossless, AVEncoderBitDepthHintKey keys must be included. See +assetWriterInputWithMediaType:outputSettings:sourceFormatHint: for a way to avoid having to specify a value for each of those keys. For AVMediaTypeVideo, any output settings dictionary must request a compressed video format. This means that the value passed in for outputSettings must follow the rules for compressed video output, as laid out in AVVideoSettings.h. When using this method to construct a new instance, a video settings dictionary must be fully specified, meaning that it must contain AVVideoCodecKey, AVVideoWidthKey, and AVVideoHeightKey. See +assetWriterInputWithMediaType:outputSettings:sourceFormatHint: for a way to avoid having to specify a value for each of those keys. On iOS, the only values currently supported for AVVideoCodecKey are AVVideoCodecTypeH264 and AVVideoCodecTypeJPEG. AVVideoCodecTypeH264 is not supported on iPhone 3G. For AVVideoScalingModeKey, the value AVVideoScalingModeFit is not supported. - Parameter mediaType: The media type of samples that will be accepted by the input. Media types are defined in AVMediaFormat.h. - Parameter outputSettings: The settings used for encoding the media appended to the output. See AVAudioSettings.h for AVMediaTypeAudio or AVVideoSettings.h for AVMediaTypeVideo and for more information on how to construct an output settings dictionary. If you only require simple preset-based output settings, see AVOutputSettingsAssistant. - Returns: An instance of AVAssetWriterInput.
      */
-    static assetWriterInputWithMediaType$outputSettings$(mediaType: number, outputSettings: _NSDictionary | null): _AVAssetWriterInput;
+    static assetWriterInputWithMediaType$outputSettings$(mediaType: _NSString, outputSettings: _NSDictionary | null): _AVAssetWriterInput;
     /**
      * Creates a new input of the specified media type to receive sample buffers for writing to the output file. A version of +assetWriterInputWithMediaType:outputSettings: that includes the ability to hint at the format of media data that will be appended to the new instance of AVAssetWriterInput. When a source format hint is provided, the outputSettings dictionary is not required to be fully specified. For AVMediaTypeAudio, this means that AVFormatIDKey is the only required key. For AVMediaTypeVideo, this means that AVVideoCodecKey is the only required key. Values for the remaining keys will be chosen by the asset writer input, with consideration given to the attributes of the source format. To guarantee successful file writing, clients who specify a format hint should ensure that subsequently-appended buffers are of the specified format. This method throws an exception for any of the following reasons: - the media type of the format description does not match the media type passed into this method - the width and height of video format hint are not positive - the output settings do not match the supplied media type - for video inputs, the output settings do not contain a required key (AVVideoCodecKey, AVVideoWidthKey, AVVideoHeightKey) - the output scaling mode is AVVideoScalingModeFit - the output settings contain AVSampleRateConverterAudioQualityKey or AVVideoDecompressionPropertiesKey - Parameter mediaType: The media type of samples that will be accepted by the input. Media types are defined in AVMediaFormat.h. - Parameter outputSettings: The settings used for encoding the media appended to the output. See AVAudioSettings.h for AVMediaTypeAudio or AVVideoSettings.h for AVMediaTypeVideo and for more information on how to construct an output settings dictionary. If you only require simple preset-based output settings, see AVOutputSettingsAssistant. - Parameter sourceFormatHint: A hint about the format of media data that will be appended to the new input. - Returns: An instance of AVAssetWriterInput.
      */
-    static assetWriterInputWithMediaType$outputSettings$sourceFormatHint$(mediaType: number, outputSettings: _NSDictionary | null, sourceFormatHint: NobjcObject): _AVAssetWriterInput;
+    static assetWriterInputWithMediaType$outputSettings$sourceFormatHint$(mediaType: _NSString, outputSettings: _NSDictionary | null, sourceFormatHint: NobjcObject | null): _AVAssetWriterInput;
     /**
      * Creates a new input of the specified media type to receive sample buffers for writing to the output file. Each new input accepts data for a new track of the AVAssetWriter's output file. Inputs are added to an asset writer using -[AVAssetWriter addInput:]. Passing nil for output settings instructs the input to pass through appended samples, doing no processing before they are written to the output file. This is useful if, for example, you are appending buffers that are already in a desirable compressed format. However, if not writing to a QuickTime Movie file (i.e. the AVAssetWriter was initialized with a file type other than AVFileTypeQuickTimeMovie), AVAssetWriter only supports passing through a restricted set of media types and subtypes. In order to pass through media data to files other than AVFileTypeQuickTimeMovie, a non-NULL format hint must be provided using -initWithMediaType:outputSettings:sourceFormatHint: instead of this method. For AVMediaTypeAudio the following keys are not currently supported in the outputSettings dictionary: AVSampleRateConverterAudioQualityKey. When using this initializer, an audio settings dictionary must be fully specified, meaning that it must contain AVFormatIDKey, AVSampleRateKey, and AVNumberOfChannelsKey. If no other channel layout information is available, a value of 1 for AVNumberOfChannelsKey will result in mono output and a value of 2 will result in stereo output. If AVNumberOfChannelsKey specifies a channel count greater than 2, the dictionary must also specify a value for AVChannelLayoutKey. For kAudioFormatLinearPCM, all relevant AVLinearPCM*Key keys must be included, and for kAudioFormatAppleLossless, AVEncoderBitDepthHintKey keys must be included. See -initWithMediaType:outputSettings:sourceFormatHint: for a way to avoid having to specify a value for each of those keys. For AVMediaTypeVideo, any output settings dictionary must request a compressed video format. This means that the value passed in for outputSettings must follow the rules for compressed video output, as laid out in AVVideoSettings.h. When using this initializer, a video settings dictionary must be fully specified, meaning that it must contain AVVideoCodecKey, AVVideoWidthKey, and AVVideoHeightKey. See -initWithMediaType:outputSettings:sourceFormatHint: for a way to avoid having to specify a value for each of those keys. On iOS, the only values currently supported for AVVideoCodecKey are AVVideoCodecTypeH264 and AVVideoCodecTypeJPEG. AVVideoCodecTypeH264 is not supported on iPhone 3G. For AVVideoScalingModeKey, the value AVVideoScalingModeFit is not supported. This method throws an exception for any of the following reasons: - the media type of the format description does not match the media type passed into this method - the output settings do not match the supplied media type - for video inputs, the output settings do not contain a required key (AVVideoCodecKey, AVVideoWidthKey, AVVideoHeightKey) - the output scaling mode is AVVideoScalingModeFit - the output settings contain AVSampleRateConverterAudioQualityKey or AVVideoDecompressionPropertiesKey - Parameter mediaType: The media type of samples that will be accepted by the input. Media types are defined in AVMediaFormat.h. - Parameter outputSettings: The settings used for encoding the media appended to the output. See AVAudioSettings.h for AVMediaTypeAudio or AVVideoSettings.h for AVMediaTypeVideo and for more information on how to construct an output settings dictionary. If you only require simple preset-based output settings, see AVOutputSettingsAssistant. - Returns: An instance of AVAssetWriterInput.
      */
-    initWithMediaType$outputSettings$(mediaType: number, outputSettings: _NSDictionary | null): _AVAssetWriterInput;
+    initWithMediaType$outputSettings$(mediaType: _NSString, outputSettings: _NSDictionary | null): _AVAssetWriterInput;
     /**
      * Creates a new input of the specified media type to receive sample buffers for writing to the output file. This is the designated initializer of AVAssetWriterInput. A version of -initWithMediaType:outputSettings: that includes the ability to hint at the format of media data that will be appended to the new instance of AVAssetWriterInput. When a source format hint is provided, the outputSettings dictionary is not required to be fully specified. For AVMediaTypeAudio, this means that AVFormatIDKey is the only required key. For AVMediaTypeVideo, this means that AVVideoCodecKey is the only required key. Values for the remaining keys will be chosen by the asset writer input, with consideration given to the attributes of the source format. To guarantee successful file writing, clients who specify a format hint should ensure that subsequently-appended buffers are of the specified format. This method throws an exception for any of the following reasons: - the media type of the format description does not match the media type passed into this method - the width and height of video format hint are not positive - the output settings do not match the supplied media type - for video inputs, the output settings do not contain a required key (AVVideoCodecKey, AVVideoWidthKey, AVVideoHeightKey) - the output scaling mode is AVVideoScalingModeFit - the output settings contain AVSampleRateConverterAudioQualityKey or AVVideoDecompressionPropertiesKey - Parameter mediaType: The media type of samples that will be accepted by the input. Media types are defined in AVMediaFormat.h. - Parameter outputSettings: The settings used for encoding the media appended to the output. See AVAudioSettings.h for AVMediaTypeAudio or AVVideoSettings.h for AVMediaTypeVideo and for more information on how to construct an output settings dictionary. If you only require simple preset-based output settings, see AVOutputSettingsAssistant. - Parameter sourceFormatHint: A hint about the format of media data that will be appended to the new input. - Returns: An instance of AVAssetWriterInput.
      */
-    initWithMediaType$outputSettings$sourceFormatHint$(mediaType: number, outputSettings: _NSDictionary | null, sourceFormatHint: NobjcObject): _AVAssetWriterInput;
+    initWithMediaType$outputSettings$sourceFormatHint$(mediaType: _NSString, outputSettings: _NSDictionary | null, sourceFormatHint: NobjcObject | null): _AVAssetWriterInput;
     /**
      * Instructs the receiver to invoke a client-supplied block repeatedly, at its convenience, in order to gather media data for writing to the output file. The block should append media data to the input either until the input's readyForMoreMediaData property becomes NO or until there is no more media data to supply (at which point it may choose to mark the input as finished via -markAsFinished). The block should then exit. After the block exits, if the input has not been marked as finished, once the input has processed the media data it has received and becomes ready for more media data again, it will invoke the block again in order to obtain more. A typical use of this method, with a block that supplies media data to an input while respecting the input's readyForMoreMediaData property, might look like this: ```objc [myAVAssetWriterInput requestMediaDataWhenReadyOnQueue:myInputSerialQueue usingBlock:^{ while ([myAVAssetWriterInput isReadyForMoreMediaData]) { CMSampleBufferRef nextSampleBuffer = [self copyNextSampleBufferToWrite]; if (nextSampleBuffer) { [myAVAssetWriterInput appendSampleBuffer:nextSampleBuffer]; CFRelease(nextSampleBuffer); } else { [myAVAssetWriterInput markAsFinished]; break; } } }]; ``` This method is not recommended for use with a push-style buffer source, such as AVCaptureAudioDataOutput or AVCaptureVideoDataOutput, because such a combination will likely require intermediate queueing of buffers. Instead, this method is better suited to a pull-style buffer source such as AVAssetReaderOutput, as illustrated in the above example. When using a push-style buffer source, it is generally better to immediately append each buffer to the AVAssetWriterInput, directly via -[AVAssetWriter appendSampleBuffer:], as it is received. Using this strategy, it is often possible to avoid having to queue up buffers in between the buffer source and the AVAssetWriterInput. Note that many of these push-style buffer sources also produce buffers in real-time, in which case the client should set expectsMediaDataInRealTime to YES. Before calling this method, you must ensure that the receiver is attached to an AVAssetWriter via a prior call to -addInput: and that -startWriting has been called on the asset writer. This method throws an exception if this method is called more than once. - Parameter queue: The queue on which the block should be invoked. - Parameter block: The block the input should invoke to obtain media data.
      * @deprecated Use the input receiver's async append(...) method on its own task instead
      */
-    requestMediaDataWhenReadyOnQueue$usingBlock$(queue: NobjcObject, block: NobjcObject): void;
+    requestMediaDataWhenReadyOnQueue$usingBlock$(queue: _NSObject, block: NobjcObject): void;
     /**
      * Appends samples to the receiver. The timing information in the sample buffer, considered relative to the time passed to -[AVAssetWriter startSessionAtSourceTime:], will be used to determine the timing of those samples in the output file. For track types other than audio tracks, to determine the duration of all samples in the output file other than the very last sample that's appended, the difference between the sample buffer's output DTS and the following sample buffer's output DTS will be used. The duration of the last sample is determined as follows: 1. If a marker sample buffer with kCMSampleBufferAttachmentKey_EndsPreviousSampleDuration is appended following the last media-bearing sample, the difference between the output DTS of the marker sample buffer and the output DTS of the last media-bearing sample will be used. 2. If the marker sample buffer is not provided and if the output duration of the last media-bearing sample is valid, it will be used. 3. if the output duration of the last media-bearing sample is not valid, the duration of the second-to-last sample will be used. For audio tracks, the properties of each appended sample buffer are used to determine corresponding output durations. The receiver will retain the CMSampleBuffer until it is done with it, and then release it. Do not modify a CMSampleBuffer or its contents after you have passed it to this method. If the sample buffer contains audio data and the AVAssetWriterInput was intialized with an outputSettings dictionary then the format must be linear PCM. If the outputSettings dictionary was nil then audio data can be provided in a compressed format, and it will be passed through to the output without any re-compression. Note that advanced formats like AAC will have encoder delay present in their bitstreams. This data is inserted by the encoder and is necessary for proper decoding, but it is not meant to be played back. Clients who provide compressed audio bitstreams must use kCMSampleBufferAttachmentKey_TrimDurationAtStart to mark the encoder delay (generally restricted to the first sample buffer). Packetization can cause there to be extra audio frames in the last packet which are not meant to be played back. These remainder frames should be marked with kCMSampleBufferAttachmentKey_TrimDurationAtEnd. CMSampleBuffers obtained from AVAssetReader will already have the necessary trim attachments. Please see http://developer.apple.com/mac/library/technotes/tn2009/tn2258.html for more information about encoder delay. When attaching trims make sure that the output PTS of the sample buffer is what you expect. For example if you called -[AVAssetWriter startSessionAtSourceTime:kCMTimeZero] and you want your audio to start at time zero in the output file then make sure that the output PTS of the first non-fully trimmed audio sample buffer is kCMTimeZero. If the sample buffer contains a CVPixelBuffer then the choice of pixel format will affect the performance and quality of the encode. For optimal performance the format of the pixel buffer should match one of the native formats supported by the selected video encoder. Below are some recommendations: The H.264 and HEVC encoders natively support kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange and kCVPixelFormatType_420YpCbCr8BiPlanarFullRange, which should be used with 8-bit 4:2:0 video and full range input respectively; other related pixel formats in CoreVideo/CVPixelBuffer.h are ideal for 4:2:2 and 4:4:4 (and for HEVC, 10-bit). The JPEG encoder on iOS and Apple Silicon macOS natively supports kCVPixelFormatType_422YpCbCr8FullRange. If you need to work in the RGB domain then kCVPixelFormatType_32BGRA is recommended on iOS and macOS. Pixel buffers not in a natively supported format will be converted internally prior to encoding when possible. Pixel format conversions within the same range (video or full) are generally faster than conversions between different ranges. The ProRes encoders can preserve high bit depth sources, supporting up to 12bits/ch. ProRes 4444 can contain a mathematically lossless alpha channel and it doesn't do any chroma subsampling. This makes ProRes 4444 ideal for quality critical applications. If you are working with 8bit sources ProRes is also a good format to use due to its high image quality. Use either of the recommended pixel formats above. Note that RGB pixel formats by definition have 4:4:4 chroma sampling. If you are working with high bit depth sources the following yuv pixel formats are recommended when encoding to ProRes: kCVPixelFormatType_4444AYpCbCr16, kCVPixelFormatType_422YpCbCr16, and kCVPixelFormatType_422YpCbCr10. When working in the RGB domain kCVPixelFormatType_64ARGB is recommended. Scaling and color matching are not currently supported when using AVAssetWriter with any of these high bit depth pixel formats. Please make sure that your track's output settings dictionary specifies the same width and height as the buffers you will be appending. Do not include AVVideoScalingModeKey or AVVideoColorPropertiesKey. As of macOS 10.10 and iOS 8.0, this method can be used to add sample buffers that reference existing data in a file instead of containing media data to be appended to the file. This can be used to generate tracks that are not self-contained. In order to append such a sample reference to the track create a CMSampleBufferRef with a NULL dataBuffer and dataReady set to true and set the kCMSampleBufferAttachmentKey_SampleReferenceURL and kCMSampleBufferAttachmentKey_SampleReferenceByteOffset attachments on the sample buffer. Further documentation on how to create such a "sample reference" sample buffer can be found in the description of the kCMSampleBufferAttachmentKey_SampleReferenceURL and kCMSampleBufferAttachmentKey_SampleReferenceByteOffset attachment keys in the CMSampleBuffer documentation. Before calling this method, you must ensure that the receiver is attached to an AVAssetWriter via a prior call to -addInput: and that -startWriting has been called on the asset writer. It is an error to invoke this method before starting a session (via -[AVAssetWriter startSessionAtSourceTime:]) or after ending a session (via -[AVAssetWriter endSessionAtSourceTime:]). This method throws an exception if the sample buffer's media type does not match the asset writer input's media type. - Parameter sampleBuffer: The CMSampleBuffer to be appended. - Returns: A BOOL value indicating success of appending the sample buffer. If a result of NO is returned, clients can check the value of AVAssetWriter.status to determine whether the writing operation completed, failed, or was cancelled. If the status is AVAssetWriterStatusFailed, AVAsset.error will contain an instance of NSError that describes the failure.
      * @deprecated Use SampleBufferReceiver.append(_:) instead
@@ -54,7 +54,7 @@ export declare class _AVAssetWriterInput extends _NSObject {
     /**
      * Instructs the receiver to invoke a client-supplied block whenever a new pass has begun. A typical block passed to this method will perform the following steps: 1. Query the value of the receiver's currentPassDescription property and reconfigure the source of media data (e.g. AVAssetReader) accordingly 2. Call -requestMediaDataWhenReadyOnQueue:usingBlock: to begin appending data for the current pass 3. Exit When all media data has been appended for the current request, call -markCurrentPassAsFinished to begin the process of determining whether an additional pass is warranted. If an additional pass is warranted, the block passed to this method will be invoked to begin the next pass. If no additional passes are needed, the block passed to this method will be invoked one final time so the client can invoke -markAsFinished in response to the value of currentPassDescription becoming nil. Before calling this method, you must ensure that the receiver is attached to an AVAssetWriter via a prior call to -addInput: and that -startWriting has been called on the asset writer. This method throws an exception if called more than once. - Parameter queue: The queue on which the block should be invoked. - Parameter block: A block the receiver should invoke whenever a new pass has begun.
      */
-    respondToEachPassDescriptionOnQueue$usingBlock$(queue: NobjcObject, block: NobjcObject): void;
+    respondToEachPassDescriptionOnQueue$usingBlock$(queue: _NSObject, block: NobjcObject): void;
     /**
      * Instructs the receiver to analyze the media data that has been appended and determine whether the results could be improved by re-encoding certain segments. When the value of canPerformMultiplePasses is YES, call this method after you have appended all of your media data. After the receiver analyzes whether an additional pass is warranted, the value of currentPassDescription will change (usually asynchronously) to describe how to set up for the next pass. Although it is possible to use key-value observing to determine when the value of currentPassDescription has changed, it is typically more convenient to invoke -respondToEachPassDescriptionOnQueue:usingBlock: in order to start the work for each pass. After re-appending the media data for all of the time ranges of the new pass, call this method again to determine whether additional segments should be re-appended in another pass. Calling this method effectively cancels any previous invocation of -requestMediaDataWhenReadyOnQueue:usingBlock:, meaning that -requestMediaDataWhenReadyOnQueue:usingBlock: can be invoked again for each new pass. -respondToEachPassDescriptionOnQueue:usingBlock: provides a convenient way to consolidate these invocations in your code. After each pass, you have the option of keeping the most recent results by calling -markAsFinished instead of this method. If the value of currentPassDescription is nil at the beginning of a pass, call -markAsFinished to tell the receiver to not expect any further media data. If the value of canPerformMultiplePasses is NO, the value of currentPassDescription will immediately become nil after calling this method. Before calling this method, you must ensure that the receiver is attached to an AVAssetWriter via a prior call to -addInput: and that -startWriting has been called on the asset writer.
      */
@@ -62,7 +62,7 @@ export declare class _AVAssetWriterInput extends _NSObject {
     /**
      * The media type of the samples that can be appended to the receiver. The value of this property is one of the media types defined in AVMediaFormat.h.
      */
-    mediaType(): number;
+    mediaType(): _NSString;
     /**
      * The settings used for encoding the media appended to the output. The value of this property is an NSDictionary that contains values for keys as specified by either AVAudioSettings.h for AVMediaTypeAudio or AVVideoSettings.h for AVMediaTypeVideo. A value of nil indicates that the receiver will pass through appended samples, doing no processing before they are written to the output file.
      */
@@ -120,8 +120,8 @@ export declare class _AVAssetWriterInput extends _NSObject {
     /**
      * For file types that support media time scales, such as QuickTime Movie files, specifies the media time scale to be used. The default value is 0, which indicates that the receiver should choose a convenient value, if applicable. It is an error to set a value other than 0 if the receiver has media type AVMediaTypeAudio. This property cannot be set after writing has started. This property throws an exception if a value is set on an asset writer input with media type AVMediaTypeAudio.
      */
-    mediaTimeScale(): NobjcObject;
-    setMediaTimeScale$(value: NobjcObject): void;
+    mediaTimeScale(): number;
+    setMediaTimeScale$(value: number): void;
     /**
      * For file types that support media chunk duration, such as QuickTime Movie files, specifies the duration to be used for each chunk of sample data in the output file. Chunk duration can influence the granularity of the I/O performed when reading a media file, e.g. during playback. A larger chunk duration can result in fewer reads from disk, at the potential expense of a higher memory footprint. A "chunk" contains one or more samples. The total duration of the samples in a chunk is no greater than this preferred chunk duration, or the duration of a single sample if the sample's duration is greater than this preferred chunk duration. The default value is kCMTimeInvalid, which means that the receiver will choose an appropriate default value. This property cannot be set after -startWriting has been called on the receiver. This property throws an exception if a duration is set which is non-numeric or non-positive (see CMTIME_IS_NUMERIC).
      */

package/dist/AVFoundation/AVAssetWriterInputPixelBufferAdaptor.d.ts

@@ -28,5 +28,5 @@ export declare class _AVAssetWriterInputPixelBufferAdaptor extends _NSObject {
     /**
      * A pixel buffer pool that will vend and efficiently recycle CVPixelBuffer objects that can be appended to the receiver. For maximum efficiency, clients should create CVPixelBuffer objects for appendPixelBuffer:withPresentationTime: by using this pool with the CVPixelBufferPoolCreatePixelBuffer() function. The value of this property will be NULL before -[AVAssetWriter startWriting] is called on the associated AVAssetWriter object. This property is key value observable. This property throws an exception if a pixel buffer pool cannot be created with this asset writer input pixel buffer adaptor's source pixel buffer attributes (must specify width, height, and either pixel format or pixel format description).
      */
-    pixelBufferPool(): NobjcObject;
+    pixelBufferPool(): NobjcObject | null;
 }

package/dist/AVFoundation/AVAssetWriterInputTaggedPixelBufferGroupAdaptor.d.ts

@@ -30,5 +30,5 @@ export declare class _AVAssetWriterInputTaggedPixelBufferGroupAdaptor extends _N
     /**
      * A pixel buffer pool that will vend and efficiently recycle CVPixelBuffer objects of tagged buffer groups that can be appended to the receiver. For maximum efficiency, clients should create CVPixelBuffer objects of tagged buffer groups for appendTaggedPixelBufferGroup:withPresentationTime: by using this pool with the CVPixelBufferPoolCreatePixelBuffer() function. The value of this property will be NULL before -[AVAssetWriter startWriting] is called on the associated AVAssetWriter object. Clients should read this property after -[AVAssetWriter startWriting] calling to get a non-NULL value. This property is not key value observable.
      */
-    pixelBufferPool(): NobjcObject;
+    pixelBufferPool(): NobjcObject | null;
 }

package/dist/AVFoundation/AVAsynchronousCIImageFilteringRequest.d.ts

@@ -1,3 +1,4 @@
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _CIContext } from "../CoreImage/CIContext.js";
@@ -25,3 +26,5 @@ export declare class _AVAsynchronousCIImageFilteringRequest extends _NSObject {
      */
     sourceImage(): _CIImage;
 }
+export interface _AVAsynchronousCIImageFilteringRequest extends _NSCopying {
+}

package/dist/AVFoundation/AVAsynchronousKeyValueLoading.d.ts

@@ -3,9 +3,9 @@ import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { AVKeyValueStatus } from "./AVKeyValueStatus.js";
 export interface _AVAsynchronousKeyValueLoading {
-    statusOfValueForKey$error$?(key: _NSString, outError: NobjcObject): AVKeyValueStatus;
+    statusOfValueForKey$error$?(key: _NSString, outError: NobjcObject | null): AVKeyValueStatus;
     /**
      * @constant AVCaptureInputPortFormatDescriptionDidChangeNotification @abstract This notification is posted when the value of an AVCaptureInputPort instance's formatDescription property changes. @discussion The notification object is the AVCaptureInputPort instance whose format description changed.
      */
-    loadValuesAsynchronouslyForKeys$completionHandler$?(keys: _NSArray, handler: NobjcObject): void;
+    loadValuesAsynchronouslyForKeys$completionHandler$?(keys: _NSArray, handler: NobjcObject | null): void;
 }

package/dist/AVFoundation/AVAsynchronousVideoCompositionRequest.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _AVSpatialVideoConfiguration } from "./AVSpatialVideoConfiguration.js";
@@ -15,16 +16,16 @@ export declare class _AVAsynchronousVideoCompositionRequest extends _NSObject {
      * Returns the source CVPixelBufferRef for the given track ID If the track contains tagged buffers, a pixel buffer from one of the tagged buffers will be returned. - Parameter trackID: The track ID for the requested source frame
      * @deprecated Use sourceReadOnlyPixelBuffer(byTrackID:) instead
      */
-    sourceFrameByTrackID$(trackID: NobjcObject): NobjcObject;
+    sourceFrameByTrackID$(trackID: number): NobjcObject | null;
     /**
      * Returns the source CMSampleBufferRef for the given track ID - Parameter trackID: The track ID for the requested source sample buffer
      * @deprecated Use sourceReadySampleBuffer(byTrackID:) instead
      */
-    sourceSampleBufferByTrackID$(trackID: NobjcObject): NobjcObject;
+    sourceSampleBufferByTrackID$(trackID: number): NobjcObject | null;
     /**
      * Returns the source AVTimedMetadataGroup * for the given track ID - Parameter trackID: The track ID for the requested source timed metadata group.
      */
-    sourceTimedMetadataByTrackID$(trackID: NobjcObject): _AVTimedMetadataGroup | null;
+    sourceTimedMetadataByTrackID$(trackID: number): _AVTimedMetadataGroup | null;
     /**
      * The method that the custom compositor calls when composition succeeds. - Parameter composedVideoFrame: The video frame to finish with. Call finishWithComposedTaggedBufferGroup: instead if outputBufferDescription is non-nil.
      * @deprecated Use finish(withComposedVideoFrame: CVReadOnlyPixelBuffer) instead
@@ -41,7 +42,7 @@ export declare class _AVAsynchronousVideoCompositionRequest extends _NSObject {
     /**
      * Returns the source CMTaggedBufferGroupRef for the given track ID. Returns nil if the video track does not contain tagged buffers. Returns nil if the track does not contain video. This function should only be called when supportsSourceTaggedBuffers is YES. - Parameter trackID: The track ID for the requested source tagged buffer group.
      */
-    sourceTaggedBufferGroupByTrackID$(trackID: NobjcObject): NobjcObject;
+    sourceTaggedBufferGroupByTrackID$(trackID: number): NobjcObject | null;
     /**
      * The method that the custom compositor calls when composition succeeds. - Parameter taggedBufferGroup: The tagged buffer group containing the composed tagged buffers. The tagged buffers must be compatible with the outputBufferDescription specified in the video composition. The outputBufferDescription must not be nil when calling this function. NOTE: If ``AVVideoComposition/spatialConfigurations`` is not empty, then ``attach(spatialVideoConfiguration:to:)`` must be called with one of the spatial configurations. An exception will be thrown otherwise. Also, all pixel buffers must be associated with the same spatial configuration. An exception will be thrown otherwise.
      */
@@ -65,3 +66,5 @@ export declare class _AVAsynchronousVideoCompositionRequest extends _NSObject {
     /** The AVVideoCompositionInstruction to use to compose the frame. */
     videoCompositionInstruction(): _AVVideoCompositionInstruction;
 }
+export interface _AVAsynchronousVideoCompositionRequest extends _NSCopying {
+}

package/dist/AVFoundation/AVAudioMix.d.ts

@@ -1,4 +1,6 @@
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
+import type { _NSMutableCopying } from "../Foundation/NSMutableCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 export declare class _AVAudioMix extends _NSObject {
     static alloc(): _AVAudioMix;
@@ -9,3 +11,5 @@ export declare class _AVAudioMix extends _NSObject {
      */
     inputParameters(): _NSArray;
 }
+export interface _AVAudioMix extends _NSCopying, _NSMutableCopying {
+}

package/dist/AVFoundation/AVAudioMixInputParameters.d.ts

@@ -1,4 +1,6 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
+import type { _NSMutableCopying } from "../Foundation/NSMutableCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { CMTime } from "../structs/CMTime.js";
 import type { AVAudioTimePitchAlgorithm } from "./AVAudioTimePitchAlgorithm.js";
@@ -9,11 +11,11 @@ export declare class _AVAudioMixInputParameters extends _NSObject {
     /**
      * Obtains the volume ramp that includes the specified time. If a ramp with a timeRange that contains the specified time has been set, information about the effective ramp for that time is supplied. Otherwise, information about the first ramp that starts after the specified time is supplied. A pointer to a float to receive the starting volume value for the volume ramp. May be NULL. A pointer to a float to receive the ending volume value for the volume ramp. May be NULL. A pointer to a CMTimeRange to receive the timeRange of the volume ramp. May be NULL. An indication of success. NO will be returned if the specified time is beyond the duration of the last volume ramp that has been set.
      */
-    getVolumeRampForTime$startVolume$endVolume$timeRange$(time: CMTime, startVolume: NobjcObject, endVolume: NobjcObject, timeRange: NobjcObject): boolean;
+    getVolumeRampForTime$startVolume$endVolume$timeRange$(time: CMTime, startVolume: NobjcObject | null, endVolume: NobjcObject | null, timeRange: NobjcObject | null): boolean;
     /**
      * Indicates the trackID of the audio track to which the parameters should be applied.
      */
-    trackID(): NobjcObject;
+    trackID(): number;
     /**
      * Indicates the processing algorithm used to manage audio pitch at varying rates and for scaled audio edits. Constants for various time pitch algorithms, e.g. AVAudioTimePitchSpectral, are defined in AVAudioProcessingSettings.h. Can be nil, in which case the audioTimePitchAlgorithm set on the AVPlayerItem, AVAssetExportSession, or AVAssetReaderAudioMixOutput on which the AVAudioMix is set will be used for the associated track.
      */
@@ -21,3 +23,5 @@ export declare class _AVAudioMixInputParameters extends _NSObject {
     /** Indicates the audio processing tap that will be used for the audio track. */
     audioTapProcessor(): NobjcObject;
 }
+export interface _AVAudioMixInputParameters extends _NSCopying, _NSMutableCopying {
+}

package/dist/AVFoundation/AVCaption.d.ts

@@ -1,5 +1,8 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
+import type { _NSMutableCopying } from "../Foundation/NSMutableCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _AVCaptionRegion } from "./AVCaptionRegion.js";
 import type { _AVCaptionRuby } from "./AVCaptionRuby.js";
@@ -21,31 +24,31 @@ export declare class _AVCaption extends _NSObject {
     /**
      * @method textColorAtIndex:range: @abstract The color of the character(s). @discussion A value of NULL means that the color is not specified. The caller must release the returned object via CGColorRelease. The range parameter receives UTF-16 code unit index range the style is effective. The range will indicate where the current style returned (including NULL) will be active and allows discovery of the next change in the style. CEA608 closed captions support the following 8 colors with 1.0 alpha value. White (RGB:1.0, 1.0, 1.0) Red (RGB:1.0, 0.0, 0.0) Blue (RGB:0.0, 0.0, 1.0) Green (RGB:0.0, 1.0, 0.0) Yellow (RGB:1.0, 1.0, 0.0) Cyan (RGB:0.0, 1.0, 1.0) Magenta (RGB:1.0, 0.0, 1.0) Black (RGB:0.0, 0.0, 0.0)
      */
-    textColorAtIndex$range$(index: number, outRange: NobjcObject): NobjcObject;
+    textColorAtIndex$range$(index: number, outRange: NobjcObject | null): NobjcObject;
     /**
      * @method backgroundColorAtIndex:range: @abstract The background color of the character(s). @discussion A value of NULL means that the color is not specified. The caller must release the returned object via CGColorRelease. The range parameter receives UTF-16 code unit index range the style is effective. After returning from the call, the range will indicate where the current style returned (including NULL) will be active and allows discovery of the next change in the style. iTT format ignores this property. CEA608 closed captions support the following 8 colors with 1.0, 0.5 and 0.0 alpha values. White (RGB:1.0, 1.0, 1.0) Red (RGB:1.0, 0.0, 0.0) Blue (RGB:0.0, 0.0, 1.0) Green (RGB:0.0, 1.0, 0.0) Yellow (RGB:1.0, 1.0, 0.0) Cyan (RGB:0.0, 1.0, 1.0) Magenta (RGB:1.0, 0.0, 1.0) Black (RGB:0.0, 0.0, 0.0)
      */
-    backgroundColorAtIndex$range$(index: number, outRange: NobjcObject): NobjcObject;
+    backgroundColorAtIndex$range$(index: number, outRange: NobjcObject | null): NobjcObject;
     /**
      * @method fontWeightAtIndex:range: @abstract Indicates the font weight of the character(s). @discussion The range parameter receives UTF-16 code unit index range the style is effective. After returning from the call, the range will indicate where the current style returned will be active and allows discovery of the next change in the style. CEA608 closed captions ignore this property. A visible distinction between AVCaptionFontWeightNormal and AVCaptionFontWeightBold may not exist if the font used has only one weight. This can be more common with CJK fonts where individual fonts can be quite large in terms of storage. Nevertheless, AVCaption still carries the font weight semantics so if the same AVCaption is applied to a different font having multiple weights, the distinction will become visible.
      */
-    fontWeightAtIndex$range$(index: number, outRange: NobjcObject): AVCaptionFontWeight;
+    fontWeightAtIndex$range$(index: number, outRange: NobjcObject | null): AVCaptionFontWeight;
     /**
      * @method fontStyleAtIndex:range: @abstract Indicates the font style of the character(s). @discussion The range parameter receives UTF-16 code unit index range the style is effective. After returning from the call, the range will indicate where the current style returned will be active and allows discovery of the next change in the style. Some writing systems may not have italic glyphs for characters and so fonts with italic forms are not available. For example, Japanese fonts do not typically have italic forms for most characters although there may be special cases for Latin characters. Nevertheless, AVCaption still carries the font style semantics even though there may be no visible rendering distinction between using AVCaptionFontStyleNormal and AVCaptionFontStyleItalic with that language.
      */
-    fontStyleAtIndex$range$(index: number, outRange: NobjcObject): AVCaptionFontStyle;
+    fontStyleAtIndex$range$(index: number, outRange: NobjcObject | null): AVCaptionFontStyle;
     /**
      * @method decorationAtIndex:range: @abstract Character decoration @discussion The value of OR-ed value of AVCaptionDecoration as NSInteger. The range parameter receives UTF-16 code unit index range the style is effective. After returning from the call, the range will indicate where the current style returned will be active and allows discovery of the next change in the style. CEA608 closed captions support only AVCaptionDecorationNone and AVCaptionDecorationUnderline.
      */
-    decorationAtIndex$range$(index: number, outRange: NobjcObject): AVCaptionDecoration;
+    decorationAtIndex$range$(index: number, outRange: NobjcObject | null): AVCaptionDecoration;
     /**
      * @method textCombineAtIndex:range: @abstract Text combine (Tate-Chu-Yoko) @discussion The style is effective only in a vertical text region. When specified, the renderer combines all the characters in the style range so that their glyph areas consume the nominal bounding box of a single em square of the surrounding vertical text.
      */
-    textCombineAtIndex$range$(index: number, outRange: NobjcObject): AVCaptionTextCombine;
+    textCombineAtIndex$range$(index: number, outRange: NobjcObject | null): AVCaptionTextCombine;
     /**
      * @method rubyAtIndex:range: @abstract Get Ruby associated with the characters. @discussion The range parameter receives UTF-16 code unit index range where the ruby text is applied. After returning from the call, the range will indicate where the current style returned (including NULL) will be active and allows discovery of the next change in the style. It returns nil when the text doesn't have a ruby at the position. CEA608 closed captions ignore this property.
      */
-    rubyAtIndex$range$(index: number, outRange: NobjcObject): _AVCaptionRuby | null;
+    rubyAtIndex$range$(index: number, outRange: NobjcObject | null): _AVCaptionRuby | null;
     /**
      * @property text @abstract The text content of the caption. @discussion The text may contain any of the line breaking character sequences (LF, CR, or CF+LF) and separating the lines in the presentation. The Apple iTT format supports all Unicode code points allowed in a XML document. Any XML special characters such as '&' are converted to a corresponding character reference syntax when written to the destination file. CEA608 closed captions support the following Unicode characters. Range: U+0020 - U+005F Range: U+0061 - U+007E Range: U+00A1 - U+00A5 Characters: U+00A9, U+00AB, U+00AE, U+00B0, U+00BB, U+00BD, U+00BF Range: U+00C0-U+00C5 Range: U+00C7-U+00CF Range: U+00D1-U+00D6 Range: U+00D8-U+00DC Range: U+00DF-U+00E5 Range: U+00E7-U+00EF Range: U+00F1-U+00FC Range: U+2018-U+2019 Range: U+2018-U+201D Character: U+2022 Range: U+2120-U+2122 Characters: U+2501, U+2503, U+250F, U+2513, U+2517, U+251B, U+2588, U+266A CEA608 closed captions don't support the line breaking character sequences (LF, CR, or CF+LF).
      */
@@ -64,3 +67,5 @@ export declare class _AVCaption extends _NSObject {
     textAlignment(): AVCaptionTextAlignment;
     animation(): AVCaptionAnimation;
 }
+export interface _AVCaption extends _NSCopying, _NSMutableCopying, _NSSecureCoding {
+}

package/dist/AVFoundation/AVCaptionConversionValidator.d.ts

@@ -19,7 +19,7 @@ export declare class _AVCaptionConversionValidator extends _NSObject {
     /**
      * @method validateCaptionConversionWithWarningHandler: @abstract Initiates the specified validation and changes the value of status to AVCaptionConversionValidatorStatusValidating. @param handler Specifies a block to be executed in order to warn you of a specific problem. @discussion It is an error to invoke this method when the value of status is greater than AVCaptionConversionValidatorStatusUnknown. If you wish to stop a validation operation in progress before it has been completed, send the message stopValidating to the receiver. When the validation is complete and all warnings have been reported, the block will be executed once with a value of nil for its warning parameter. When this occurs, the value of status will have been changed to AVCaptionConversionValidatorStatusCompleted.
      */
-    validateCaptionConversionWithWarningHandler$(handler: NobjcObject): void;
+    validateCaptionConversionWithWarningHandler$(handler: NobjcObject | null): void;
     /**
      * @method stopValidating @abstract Stops validation and changes the value of status to AVCaptionConversionValidatorStatusStopped. @discussion You can call this method at any time, even within your warning handler.
      */

package/dist/AVFoundation/AVCaptionFormatConformer.d.ts

@@ -17,7 +17,7 @@ export declare class _AVCaptionFormatConformer extends _NSObject {
     /**
      * @method conformedCaptionForCaption:error: @abstract Creates a format-compliant caption that conforms to a specific format by converting a given canonical caption. @param caption Specifies a canonical caption to be converted. @param outError A pointer where a NSError object may be returned. @result A format-compliant caption that conforms to a specific format.
      */
-    conformedCaptionForCaption$error$(caption: _AVCaption, outError: NobjcObject): _AVCaption | null;
+    conformedCaptionForCaption$error$(caption: _AVCaption, outError: NobjcObject | null): _AVCaption | null;
     /**
      * @property conformsCaptionsToTimeRange @abstract Specifies whether to conform the time range of a given canonical caption as well. @discussion When set to YES, conforms time range. When set to NO, the time range of the conformed caption will be same as a given canonical caption. In the case of conforming to CAE608 format, AVCaption is encoded so that each CAE608 control code (2 bytes) fits into 1 frame duration (1001/30000). When set to YES and if all the encoded data can not fit inside the canonical caption time range, the caption time range will be extended to fit all the data and will be returned in the conformed AVCaption. The default value is NO.
      */

package/dist/AVFoundation/AVCaptionRegion.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSCoder } from "../Foundation/NSCoder.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { AVCaptionPoint } from "../structs/AVCaptionPoint.js";
@@ -39,10 +40,6 @@ export declare class _AVCaptionRegion extends _NSObject {
      * @method isEqual: @abstract NSObject protocol method override @discussion This method throws an exception if the caption region's size has different units for width and height, or if the units are unrecognizeable.
      */
     isEqual$(object_: NobjcObject): boolean;
-    /**
-     * @method mutableCopyWithZone: @abstract NSMutableCopying protocol method override @discussion This method throws an exception if the caption region contains an identifier.
-     */
-    mutableCopyWithZone$(zone: NobjcObject): NobjcObject;
     /**
      * @property identifier @abstract Identifier for the region @discussion When regionIdentifier is nil, two regions with the same position and endPosition are considered to be same, that is captions referring these regions belong to the same region when serialized to a format like TTML. In addition, the AVCaptionRegion cannot be mutably copied. When regionIdentifier is not nil, two regions are same if and only if the region identifier is equal. It is a client's responsibility to ensure these AVCaptionRegion objects have the same properties.
      */
@@ -66,3 +63,5 @@ export declare class _AVCaptionRegion extends _NSObject {
      */
     writingMode(): AVCaptionRegionWritingMode;
 }
+export interface _AVCaptionRegion extends _NSCopying {
+}

package/dist/AVFoundation/AVCaptionRendererScene.d.ts

@@ -1,3 +1,4 @@
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { CMTimeRange } from "../structs/CMTimeRange.js";
 export declare class _AVCaptionRendererScene extends _NSObject {
@@ -17,3 +18,5 @@ export declare class _AVCaptionRendererScene extends _NSObject {
      */
     needsPeriodicRefresh(): boolean;
 }
+export interface _AVCaptionRendererScene extends _NSCopying {
+}

package/dist/AVFoundation/AVCaptionRuby.d.ts

@@ -1,4 +1,6 @@
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { AVCaptionRubyAlignment } from "./AVCaptionRubyAlignment.js";
 import type { AVCaptionRubyPosition } from "./AVCaptionRubyPosition.js";
@@ -17,3 +19,5 @@ export declare class _AVCaptionRuby extends _NSObject {
     /** @property alignment @abstract The alignment of ruby text. */
     alignment(): AVCaptionRubyAlignment;
 }
+export interface _AVCaptionRuby extends _NSCopying, _NSSecureCoding {
+}

package/dist/AVFoundation/AVCaptureAudioDataOutput.d.ts

@@ -1,7 +1,8 @@
-import type { NobjcObject } from "objc-js";
 import type { _AVCaptureAudioDataOutputSampleBufferDelegate } from "./AVCaptureAudioDataOutputSampleBufferDelegate.js";
 import type { _AVCaptureOutput } from "./AVCaptureOutput.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSString } from "../Foundation/NSString.js";
 export declare class _AVCaptureAudioDataOutput extends _AVCaptureOutput {
     static alloc(): _AVCaptureAudioDataOutput;
     static new(): _AVCaptureAudioDataOutput;
@@ -9,11 +10,11 @@ export declare class _AVCaptureAudioDataOutput extends _AVCaptureOutput {
     /**
      * Sets the receiver's delegate that will accept captured buffers and dispatch queue on which the delegate will be called. An object conforming to the AVCaptureAudioDataOutputSampleBufferDelegate protocol that will receive sample buffers after they are captured. A dispatch queue on which all sample buffer delegate methods will be called. When a new audio sample buffer is captured it will be vended to the sample buffer delegate using the captureOutput:didOutputSampleBuffer:fromConnection: delegate method. All delegate methods will be called on the specified dispatch queue. If the queue is blocked when new samples are captured, those samples will be automatically dropped when they become sufficiently late. This allows clients to process existing samples on the same queue without having to manage the potential memory usage increases that would otherwise occur when that processing is unable to keep up with the rate of incoming samples. Clients that need to minimize the chances of samples being dropped should specify a queue on which a sufficiently small amount of processing is being done outside of receiving sample buffers. However, if such clients migrate extra processing to another queue, they are responsible for ensuring that memory usage does not grow without bound from samples that have not been processed. A serial dispatch queue must be used to guarantee that audio samples will be delivered in order. The sampleBufferCallbackQueue parameter may not be NULL, except when setting sampleBufferDelegate to nil otherwise -setSampleBufferDelegate:queue: throws an NSInvalidArgumentException.
      */
-    setSampleBufferDelegate$queue$(sampleBufferDelegate: _AVCaptureAudioDataOutputSampleBufferDelegate | null, sampleBufferCallbackQueue: NobjcObject): void;
+    setSampleBufferDelegate$queue$(sampleBufferDelegate: _AVCaptureAudioDataOutputSampleBufferDelegate | null, sampleBufferCallbackQueue: _NSObject | null): void;
     /**
      * Specifies the recommended settings for use with an AVAssetWriterInput. Specifies the UTI of the file type to be written (see AVMediaFormat.h for a list of file format UTIs). A fully populated dictionary of keys and values that are compatible with AVAssetWriter. The value of this property is an NSDictionary containing values for compression settings keys defined in AVAudioSettings.h. This dictionary is suitable for use as the "outputSettings" parameter when creating an AVAssetWriterInput, such as, [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeAudio outputSettings:outputSettings sourceFormatHint:hint]; The dictionary returned contains all necessary keys and values needed by AVAssetWriter (see AVAssetWriterInput.h, -initWithMediaType:outputSettings: for a more in depth discussion). For QuickTime movie and ISO files, the recommended audio settings will always produce output comparable to that of AVCaptureMovieFileOutput. Note that the dictionary of settings is dependent on the current configuration of the receiver's AVCaptureSession and its inputs. The settings dictionary may change if the session's configuration changes. As such, you should configure your session first, then query the recommended audio settings.
      */
-    recommendedAudioSettingsForAssetWriterWithOutputFileType$(outputFileType: number): _NSDictionary | null;
+    recommendedAudioSettingsForAssetWriterWithOutputFileType$(outputFileType: _NSString): _NSDictionary | null;
     /**
      * The receiver's delegate. The value of this property is an object conforming to the AVCaptureAudioDataOutputSampleBufferDelegate protocol that will receive sample buffers after they are captured. The delegate is set using the setSampleBufferDelegate:queue: method.
      */
@@ -21,7 +22,7 @@ export declare class _AVCaptureAudioDataOutput extends _AVCaptureOutput {
     /**
      * The dispatch queue on which all sample buffer delegate methods will be called. The value of this property is a dispatch_queue_t. The queue is set using the setSampleBufferDelegate:queue: method.
      */
-    sampleBufferCallbackQueue(): NobjcObject;
+    sampleBufferCallbackQueue(): _NSObject | null;
     /**
      * Specifies the settings used to decode or re-encode audio before it is output by the receiver. The value of this property is an NSDictionary containing values for audio settings keys defined in AVAudioSettings.h. When audioSettings is set to nil, the AVCaptureAudioDataOutput vends samples in their device native format.
      */
@@ -30,6 +31,6 @@ export declare class _AVCaptureAudioDataOutput extends _AVCaptureOutput {
     /**
      * The audio channel layout tag of the audio sample buffers produced by the audio data output. When you set your audio data output's associated ``AVCaptureDeviceInput/multichannelAudioMode`` property to ``AVCaptureMultichannelAudioModeFirstOrderAmbisonics``, the ``AVCaptureSession`` allows up to two ``AVCaptureAudioDataOutput`` instances to be connected to the First-order Ambisonsics (FOA) input. If you connect a single ``AVCaptureAudioDataOutput`` instance, you must configure its ``AVCaptureAudioDataOutput/spatialAudioChannelLayoutTag`` property to produce either four channels of FOA audio or two channels of Stereo audio. If you connect two ``AVCaptureAudioDataOutput`` instances, you must configure one to output four channels of FOA audio and the other to output two channels of Stereo audio. Thus, when you set your associated ``AVCaptureDeviceInput/multichannelAudioMode`` property to ``AVCaptureMultichannelAudioModeFirstOrderAmbisonics``, you must set your connected ``AVCaptureAudioDataOutput`` instance's ``AVCaptureAudioDataOutput/spatialAudioChannelLayoutTag`` property to either `kAudioChannelLayoutTag_Stereo` for stereo, or `(kAudioChannelLayoutTag_HOA_ACN_SN3D | 4)` for FOA (see <doc ://com.apple.documentation/documentation/coreaudiotypes/audiochannellayouttag>). When you set your associated ``AVCaptureDeviceInput/multichannelAudioMode`` to any other value, the ``AVCaptureSession`` only supports one ``AVCaptureAudioDataOutput``, and you may only set ``AVCaptureAudioDataOutput/spatialAudioChannelLayoutTag`` to `kAudioChannelLayoutTag_Unknown` (the default value). Your ``AVCaptureSession`` validates your app's adherence to the the above rules when you call ``AVCaptureSession/startRunning:`` or ``AVCaptureSession/commitConfiguration`` and throws a `NSInvalidArgumentException` if necessary.
      */
-    spatialAudioChannelLayoutTag(): NobjcObject;
-    setSpatialAudioChannelLayoutTag$(value: NobjcObject): void;
+    spatialAudioChannelLayoutTag(): number;
+    setSpatialAudioChannelLayoutTag$(value: number): void;
 }