objcjs-types 0.2.1 → 0.3.0

package/dist/VideoToolbox/functions.d.ts

@@ -0,0 +1,81 @@
+import type { NobjcObject } from "objc-js";
+import type { CMTime } from "../structs/CMTime.js";
+import type { CMTimeRange } from "../structs/CMTimeRange.js";
+export declare function VTCompressionSessionBeginPass(session: NobjcObject, beginPassFlags: NobjcObject, reserved: NobjcObject | null): number;
+export declare function VTCompressionSessionCompleteFrames(session: NobjcObject, completeUntilPresentationTimeStamp: CMTime): number;
+export declare function VTCompressionSessionCreate(allocator: NobjcObject | null, width: number, height: number, codecType: number, encoderSpecification: NobjcObject | null, sourceImageBufferAttributes: NobjcObject | null, compressedDataAllocator: NobjcObject | null, outputCallback: NobjcObject | null, outputCallbackRefCon: Uint8Array | null, compressionSessionOut: NobjcObject | null): number;
+export declare function VTCompressionSessionEncodeFrame(session: NobjcObject, imageBuffer: NobjcObject, presentationTimeStamp: CMTime, duration: CMTime, frameProperties: NobjcObject | null, sourceFrameRefcon: Uint8Array | null, infoFlagsOut: NobjcObject | null): number;
+export declare function VTCompressionSessionEncodeFrameWithOutputHandler(session: NobjcObject, imageBuffer: NobjcObject, presentationTimeStamp: CMTime, duration: CMTime, frameProperties: NobjcObject | null, infoFlagsOut: NobjcObject | null, outputHandler: NobjcObject): number;
+export declare function VTCompressionSessionEncodeMultiImageFrame(session: NobjcObject, taggedBufferGroup: NobjcObject, presentationTimeStamp: CMTime, duration: CMTime, frameProperties: NobjcObject | null, sourceFrameRefcon: Uint8Array | null, infoFlagsOut: NobjcObject | null): number;
+export declare function VTCompressionSessionEncodeMultiImageFrameWithOutputHandler(session: NobjcObject, taggedBufferGroup: NobjcObject, presentationTimeStamp: CMTime, duration: CMTime, frameProperties: NobjcObject | null, infoFlagsOut: NobjcObject | null, outputHandler: NobjcObject): number;
+export declare function VTCompressionSessionEndPass(session: NobjcObject, furtherPassesRequestedOut: NobjcObject | null, reserved: NobjcObject | null): number;
+export declare function VTCompressionSessionGetPixelBufferPool(session: NobjcObject): NobjcObject | null;
+export declare function VTCompressionSessionGetTimeRangesForNextPass(session: NobjcObject, timeRangeCountOut: NobjcObject, timeRangeArrayOut: NobjcObject | null): number;
+export declare function VTCompressionSessionGetTypeID(): number;
+export declare function VTCompressionSessionInvalidate(session: NobjcObject): void;
+export declare function VTCompressionSessionPrepareToEncodeFrames(session: NobjcObject): number;
+export declare function VTCopyRAWProcessorExtensionProperties(formatDesc: NobjcObject, mediaExtensionPropertiesOut: NobjcObject | null): number;
+export declare function VTCopySupportedPropertyDictionaryForEncoder(width: number, height: number, codecType: number, encoderSpecification: NobjcObject | null, encoderIDOut: NobjcObject | null, supportedPropertiesOut: NobjcObject | null): number;
+export declare function VTCopyVideoDecoderExtensionProperties(formatDesc: NobjcObject, mediaExtensionPropertiesOut: NobjcObject | null): number;
+export declare function VTCopyVideoEncoderList(options: NobjcObject | null, listOfVideoEncodersOut: NobjcObject | null): number;
+export declare function VTCreateCGImageFromCVPixelBuffer(pixelBuffer: NobjcObject, options: NobjcObject | null, imageOut: NobjcObject | null): number;
+export declare function VTDecompressionSessionCanAcceptFormatDescription(session: NobjcObject, newFormatDesc: NobjcObject): NobjcObject;
+export declare function VTDecompressionSessionCopyBlackPixelBuffer(session: NobjcObject, pixelBufferOut: NobjcObject | null): number;
+export declare function VTDecompressionSessionCreate(allocator: NobjcObject | null, videoFormatDescription: NobjcObject, videoDecoderSpecification: NobjcObject | null, destinationImageBufferAttributes: NobjcObject | null, outputCallback: NobjcObject | null, decompressionSessionOut: NobjcObject | null): number;
+export declare function VTDecompressionSessionDecodeFrame(session: NobjcObject, sampleBuffer: NobjcObject, decodeFlags: NobjcObject, sourceFrameRefCon: Uint8Array | null, infoFlagsOut: NobjcObject | null): number;
+export declare function VTDecompressionSessionDecodeFrameWithMultiImageCapableOutputHandler(session: NobjcObject, sampleBuffer: NobjcObject, decodeFlags: NobjcObject, infoFlagsOut: NobjcObject | null, multiImageCapableOutputHandler: NobjcObject): number;
+export declare function VTDecompressionSessionDecodeFrameWithOptions(session: NobjcObject, sampleBuffer: NobjcObject, decodeFlags: NobjcObject, frameOptions: NobjcObject | null, sourceFrameRefCon: Uint8Array | null, infoFlagsOut: NobjcObject | null): number;
+export declare function VTDecompressionSessionDecodeFrameWithOptionsAndOutputHandler(session: NobjcObject, sampleBuffer: NobjcObject, decodeFlags: NobjcObject, frameOptions: NobjcObject | null, infoFlagsOut: NobjcObject | null, outputHandler: NobjcObject): number;
+export declare function VTDecompressionSessionDecodeFrameWithOutputHandler(session: NobjcObject, sampleBuffer: NobjcObject, decodeFlags: NobjcObject, infoFlagsOut: NobjcObject | null, outputHandler: NobjcObject): number;
+export declare function VTDecompressionSessionFinishDelayedFrames(session: NobjcObject): number;
+export declare function VTDecompressionSessionGetTypeID(): number;
+export declare function VTDecompressionSessionInvalidate(session: NobjcObject): void;
+export declare function VTDecompressionSessionSetMultiImageCallback(decompressionSession: NobjcObject, outputMultiImageCallback: NobjcObject, outputMultiImageRefcon: Uint8Array | null): number;
+export declare function VTDecompressionSessionWaitForAsynchronousFrames(session: NobjcObject): number;
+export declare function VTFrameSiloAddSampleBuffer(silo: NobjcObject, sampleBuffer: NobjcObject): number;
+export declare function VTFrameSiloCallBlockForEachSampleBuffer(silo: NobjcObject, timeRange: CMTimeRange, handler: NobjcObject): number;
+export declare function VTFrameSiloCallFunctionForEachSampleBuffer(silo: NobjcObject, timeRange: CMTimeRange, refcon: Uint8Array | null, callback: NobjcObject | null): number;
+export declare function VTFrameSiloCreate(allocator: NobjcObject | null, fileURL: NobjcObject | null, timeRange: CMTimeRange, options: NobjcObject | null, frameSiloOut: NobjcObject | null): number;
+export declare function VTFrameSiloGetProgressOfCurrentPass(silo: NobjcObject, progressOut: NobjcObject): number;
+export declare function VTFrameSiloGetTypeID(): number;
+export declare function VTFrameSiloSetTimeRangesForNextPass(silo: NobjcObject, timeRangeCount: number, timeRangeArray: NobjcObject): number;
+export declare function VTHDRPerFrameMetadataGenerationSessionAttachMetadata(hdrPerFrameMetadataGenerationSession: NobjcObject, pixelBuffer: NobjcObject, sceneChange: NobjcObject): number;
+export declare function VTHDRPerFrameMetadataGenerationSessionCreate(allocator: NobjcObject | null, framesPerSecond: number, options: NobjcObject | null, hdrPerFrameMetadataGenerationSessionOut: NobjcObject | null): number;
+export declare function VTHDRPerFrameMetadataGenerationSessionGetTypeID(): number;
+export declare function VTIsHardwareDecodeSupported(codecType: number): NobjcObject;
+export declare function VTIsStereoMVHEVCDecodeSupported(): NobjcObject;
+export declare function VTIsStereoMVHEVCEncodeSupported(): NobjcObject;
+export declare function VTMotionEstimationSessionCompleteFrames(session: NobjcObject): number;
+export declare function VTMotionEstimationSessionCopySourcePixelBufferAttributes(motionEstimationSession: NobjcObject, attributesOut: NobjcObject | null): number;
+export declare function VTMotionEstimationSessionCreate(allocator: NobjcObject | null, motionVectorProcessorSelectionOptions: NobjcObject | null, width: number, height: number, motionEstimationSessionOut: NobjcObject | null): number;
+export declare function VTMotionEstimationSessionEstimateMotionVectors(session: NobjcObject, referenceImage: NobjcObject, currentImage: NobjcObject, motionEstimationFrameFlags: NobjcObject, additionalFrameOptions: NobjcObject | null, outputHandler: NobjcObject): number;
+export declare function VTMotionEstimationSessionGetTypeID(): number;
+export declare function VTMotionEstimationSessionInvalidate(session: NobjcObject): void;
+export declare function VTMultiPassStorageClose(multiPassStorage: NobjcObject): number;
+export declare function VTMultiPassStorageCreate(allocator: NobjcObject | null, fileURL: NobjcObject | null, timeRange: CMTimeRange, options: NobjcObject | null, multiPassStorageOut: NobjcObject | null): number;
+export declare function VTMultiPassStorageGetTypeID(): number;
+export declare function VTPixelRotationSessionCreate(allocator: NobjcObject | null, pixelRotationSessionOut: NobjcObject | null): number;
+export declare function VTPixelRotationSessionGetTypeID(): number;
+export declare function VTPixelRotationSessionInvalidate(session: NobjcObject): void;
+export declare function VTPixelRotationSessionRotateImage(session: NobjcObject, sourceBuffer: NobjcObject, destinationBuffer: NobjcObject): number;
+export declare function VTPixelTransferSessionCreate(allocator: NobjcObject | null, pixelTransferSessionOut: NobjcObject | null): number;
+export declare function VTPixelTransferSessionGetTypeID(): number;
+export declare function VTPixelTransferSessionInvalidate(session: NobjcObject): void;
+export declare function VTPixelTransferSessionTransferImage(session: NobjcObject, sourceBuffer: NobjcObject, destinationBuffer: NobjcObject): number;
+export declare function VTRAWProcessingSessionCompleteFrames(session: NobjcObject): number;
+export declare function VTRAWProcessingSessionCopyProcessingParameters(session: NobjcObject, outParameterArray: NobjcObject | null): number;
+export declare function VTRAWProcessingSessionCreate(allocator: NobjcObject | null, formatDescription: NobjcObject, outputPixelBufferAttributes: NobjcObject | null, processingSessionOptions: NobjcObject | null, processingSessionOut: NobjcObject | null): number;
+export declare function VTRAWProcessingSessionGetTypeID(): number;
+export declare function VTRAWProcessingSessionInvalidate(session: NobjcObject): void;
+export declare function VTRAWProcessingSessionProcessFrame(session: NobjcObject, inputPixelBuffer: NobjcObject, frameOptions: NobjcObject | null, outputHandler: NobjcObject): number;
+export declare function VTRAWProcessingSessionSetParameterChangedHander(session: NobjcObject, parameterChangeHandler: NobjcObject | null): number;
+export declare function VTRAWProcessingSessionSetParameterChangedHandler(session: NobjcObject, parameterChangeHandler: NobjcObject | null): number;
+export declare function VTRAWProcessingSessionSetProcessingParameters(session: NobjcObject, processingParameters: NobjcObject): number;
+export declare function VTRegisterProfessionalVideoWorkflowVideoDecoders(): void;
+export declare function VTRegisterProfessionalVideoWorkflowVideoEncoders(): void;
+export declare function VTRegisterSupplementalVideoDecoderIfAvailable(codecType: number): void;
+export declare function VTSessionCopyProperty(session: NobjcObject, propertyKey: Uint8Array, allocator: NobjcObject | null, propertyValueOut: Uint8Array | null): number;
+export declare function VTSessionCopySerializableProperties(session: NobjcObject, allocator: NobjcObject | null, dictionaryOut: NobjcObject | null): number;
+export declare function VTSessionCopySupportedPropertyDictionary(session: NobjcObject, supportedPropertyDictionaryOut: NobjcObject | null): number;
+export declare function VTSessionSetProperties(session: NobjcObject, propertyDictionary: NobjcObject): number;
+export declare function VTSessionSetProperty(session: NobjcObject, propertyKey: Uint8Array, propertyValue: Uint8Array | null): number;

package/dist/VideoToolbox/functions.js

@@ -0,0 +1,236 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+import { callFunction } from "objc-js";
+export function VTCompressionSessionBeginPass(session, beginPassFlags, reserved) {
+    return callFunction("VTCompressionSessionBeginPass", { returns: "i" }, session, beginPassFlags, reserved);
+}
+export function VTCompressionSessionCompleteFrames(session, completeUntilPresentationTimeStamp) {
+    return callFunction("VTCompressionSessionCompleteFrames", { returns: "i", args: ["@", "{CMTime}"] }, session, completeUntilPresentationTimeStamp);
+}
+export function VTCompressionSessionCreate(allocator, width, height, codecType, encoderSpecification, sourceImageBufferAttributes, compressedDataAllocator, outputCallback, outputCallbackRefCon, compressionSessionOut) {
+    return callFunction("VTCompressionSessionCreate", { returns: "i", args: ["@", "i", "i", "I", "@", "@", "@", "@", "^v", "@"] }, allocator, width, height, codecType, encoderSpecification, sourceImageBufferAttributes, compressedDataAllocator, outputCallback, outputCallbackRefCon, compressionSessionOut);
+}
+export function VTCompressionSessionEncodeFrame(session, imageBuffer, presentationTimeStamp, duration, frameProperties, sourceFrameRefcon, infoFlagsOut) {
+    return callFunction("VTCompressionSessionEncodeFrame", { returns: "i", args: ["@", "@", "{CMTime}", "{CMTime}", "@", "^v", "@"] }, session, imageBuffer, presentationTimeStamp, duration, frameProperties, sourceFrameRefcon, infoFlagsOut);
+}
+export function VTCompressionSessionEncodeFrameWithOutputHandler(session, imageBuffer, presentationTimeStamp, duration, frameProperties, infoFlagsOut, outputHandler) {
+    return callFunction("VTCompressionSessionEncodeFrameWithOutputHandler", { returns: "i", args: ["@", "@", "{CMTime}", "{CMTime}", "@", "@", "@"] }, session, imageBuffer, presentationTimeStamp, duration, frameProperties, infoFlagsOut, outputHandler);
+}
+export function VTCompressionSessionEncodeMultiImageFrame(session, taggedBufferGroup, presentationTimeStamp, duration, frameProperties, sourceFrameRefcon, infoFlagsOut) {
+    return callFunction("VTCompressionSessionEncodeMultiImageFrame", { returns: "i", args: ["@", "@", "{CMTime}", "{CMTime}", "@", "^v", "@"] }, session, taggedBufferGroup, presentationTimeStamp, duration, frameProperties, sourceFrameRefcon, infoFlagsOut);
+}
+export function VTCompressionSessionEncodeMultiImageFrameWithOutputHandler(session, taggedBufferGroup, presentationTimeStamp, duration, frameProperties, infoFlagsOut, outputHandler) {
+    return callFunction("VTCompressionSessionEncodeMultiImageFrameWithOutputHandler", { returns: "i", args: ["@", "@", "{CMTime}", "{CMTime}", "@", "@", "@"] }, session, taggedBufferGroup, presentationTimeStamp, duration, frameProperties, infoFlagsOut, outputHandler);
+}
+export function VTCompressionSessionEndPass(session, furtherPassesRequestedOut, reserved) {
+    return callFunction("VTCompressionSessionEndPass", { returns: "i" }, session, furtherPassesRequestedOut, reserved);
+}
+export function VTCompressionSessionGetPixelBufferPool(session) {
+    return callFunction("VTCompressionSessionGetPixelBufferPool", { returns: "@" }, session);
+}
+export function VTCompressionSessionGetTimeRangesForNextPass(session, timeRangeCountOut, timeRangeArrayOut) {
+    return callFunction("VTCompressionSessionGetTimeRangesForNextPass", { returns: "i" }, session, timeRangeCountOut, timeRangeArrayOut);
+}
+export function VTCompressionSessionGetTypeID() {
+    return callFunction("VTCompressionSessionGetTypeID", { returns: "L" });
+}
+export function VTCompressionSessionInvalidate(session) {
+    callFunction("VTCompressionSessionInvalidate", undefined, session);
+}
+export function VTCompressionSessionPrepareToEncodeFrames(session) {
+    return callFunction("VTCompressionSessionPrepareToEncodeFrames", { returns: "i" }, session);
+}
+export function VTCopyRAWProcessorExtensionProperties(formatDesc, mediaExtensionPropertiesOut) {
+    return callFunction("VTCopyRAWProcessorExtensionProperties", { returns: "i" }, formatDesc, mediaExtensionPropertiesOut);
+}
+export function VTCopySupportedPropertyDictionaryForEncoder(width, height, codecType, encoderSpecification, encoderIDOut, supportedPropertiesOut) {
+    return callFunction("VTCopySupportedPropertyDictionaryForEncoder", { returns: "i", args: ["i", "i", "I", "@", "@", "@"] }, width, height, codecType, encoderSpecification, encoderIDOut, supportedPropertiesOut);
+}
+export function VTCopyVideoDecoderExtensionProperties(formatDesc, mediaExtensionPropertiesOut) {
+    return callFunction("VTCopyVideoDecoderExtensionProperties", { returns: "i" }, formatDesc, mediaExtensionPropertiesOut);
+}
+export function VTCopyVideoEncoderList(options, listOfVideoEncodersOut) {
+    return callFunction("VTCopyVideoEncoderList", { returns: "i" }, options, listOfVideoEncodersOut);
+}
+export function VTCreateCGImageFromCVPixelBuffer(pixelBuffer, options, imageOut) {
+    return callFunction("VTCreateCGImageFromCVPixelBuffer", { returns: "i" }, pixelBuffer, options, imageOut);
+}
+export function VTDecompressionSessionCanAcceptFormatDescription(session, newFormatDesc) {
+    return callFunction("VTDecompressionSessionCanAcceptFormatDescription", { returns: "C" }, session, newFormatDesc);
+}
+export function VTDecompressionSessionCopyBlackPixelBuffer(session, pixelBufferOut) {
+    return callFunction("VTDecompressionSessionCopyBlackPixelBuffer", { returns: "i" }, session, pixelBufferOut);
+}
+export function VTDecompressionSessionCreate(allocator, videoFormatDescription, videoDecoderSpecification, destinationImageBufferAttributes, outputCallback, decompressionSessionOut) {
+    return callFunction("VTDecompressionSessionCreate", { returns: "i" }, allocator, videoFormatDescription, videoDecoderSpecification, destinationImageBufferAttributes, outputCallback, decompressionSessionOut);
+}
+export function VTDecompressionSessionDecodeFrame(session, sampleBuffer, decodeFlags, sourceFrameRefCon, infoFlagsOut) {
+    return callFunction("VTDecompressionSessionDecodeFrame", { returns: "i", args: ["@", "@", "@", "^v", "@"] }, session, sampleBuffer, decodeFlags, sourceFrameRefCon, infoFlagsOut);
+}
+export function VTDecompressionSessionDecodeFrameWithMultiImageCapableOutputHandler(session, sampleBuffer, decodeFlags, infoFlagsOut, multiImageCapableOutputHandler) {
+    return callFunction("VTDecompressionSessionDecodeFrameWithMultiImageCapableOutputHandler", { returns: "i" }, session, sampleBuffer, decodeFlags, infoFlagsOut, multiImageCapableOutputHandler);
+}
+export function VTDecompressionSessionDecodeFrameWithOptions(session, sampleBuffer, decodeFlags, frameOptions, sourceFrameRefCon, infoFlagsOut) {
+    return callFunction("VTDecompressionSessionDecodeFrameWithOptions", { returns: "i", args: ["@", "@", "@", "@", "^v", "@"] }, session, sampleBuffer, decodeFlags, frameOptions, sourceFrameRefCon, infoFlagsOut);
+}
+export function VTDecompressionSessionDecodeFrameWithOptionsAndOutputHandler(session, sampleBuffer, decodeFlags, frameOptions, infoFlagsOut, outputHandler) {
+    return callFunction("VTDecompressionSessionDecodeFrameWithOptionsAndOutputHandler", { returns: "i" }, session, sampleBuffer, decodeFlags, frameOptions, infoFlagsOut, outputHandler);
+}
+export function VTDecompressionSessionDecodeFrameWithOutputHandler(session, sampleBuffer, decodeFlags, infoFlagsOut, outputHandler) {
+    return callFunction("VTDecompressionSessionDecodeFrameWithOutputHandler", { returns: "i" }, session, sampleBuffer, decodeFlags, infoFlagsOut, outputHandler);
+}
+export function VTDecompressionSessionFinishDelayedFrames(session) {
+    return callFunction("VTDecompressionSessionFinishDelayedFrames", { returns: "i" }, session);
+}
+export function VTDecompressionSessionGetTypeID() {
+    return callFunction("VTDecompressionSessionGetTypeID", { returns: "L" });
+}
+export function VTDecompressionSessionInvalidate(session) {
+    callFunction("VTDecompressionSessionInvalidate", undefined, session);
+}
+export function VTDecompressionSessionSetMultiImageCallback(decompressionSession, outputMultiImageCallback, outputMultiImageRefcon) {
+    return callFunction("VTDecompressionSessionSetMultiImageCallback", { returns: "i", args: ["@", "@", "^v"] }, decompressionSession, outputMultiImageCallback, outputMultiImageRefcon);
+}
+export function VTDecompressionSessionWaitForAsynchronousFrames(session) {
+    return callFunction("VTDecompressionSessionWaitForAsynchronousFrames", { returns: "i" }, session);
+}
+export function VTFrameSiloAddSampleBuffer(silo, sampleBuffer) {
+    return callFunction("VTFrameSiloAddSampleBuffer", { returns: "i" }, silo, sampleBuffer);
+}
+export function VTFrameSiloCallBlockForEachSampleBuffer(silo, timeRange, handler) {
+    return callFunction("VTFrameSiloCallBlockForEachSampleBuffer", { returns: "i", args: ["@", "{CMTimeRange}", "@"] }, silo, timeRange, handler);
+}
+export function VTFrameSiloCallFunctionForEachSampleBuffer(silo, timeRange, refcon, callback) {
+    return callFunction("VTFrameSiloCallFunctionForEachSampleBuffer", { returns: "i", args: ["@", "{CMTimeRange}", "^v", "@"] }, silo, timeRange, refcon, callback);
+}
+export function VTFrameSiloCreate(allocator, fileURL, timeRange, options, frameSiloOut) {
+    return callFunction("VTFrameSiloCreate", { returns: "i", args: ["@", "@", "{CMTimeRange}", "@", "@"] }, allocator, fileURL, timeRange, options, frameSiloOut);
+}
+export function VTFrameSiloGetProgressOfCurrentPass(silo, progressOut) {
+    return callFunction("VTFrameSiloGetProgressOfCurrentPass", { returns: "i" }, silo, progressOut);
+}
+export function VTFrameSiloGetTypeID() {
+    return callFunction("VTFrameSiloGetTypeID", { returns: "L" });
+}
+export function VTFrameSiloSetTimeRangesForNextPass(silo, timeRangeCount, timeRangeArray) {
+    return callFunction("VTFrameSiloSetTimeRangesForNextPass", { returns: "i", args: ["@", "q", "@"] }, silo, timeRangeCount, timeRangeArray);
+}
+export function VTHDRPerFrameMetadataGenerationSessionAttachMetadata(hdrPerFrameMetadataGenerationSession, pixelBuffer, sceneChange) {
+    return callFunction("VTHDRPerFrameMetadataGenerationSessionAttachMetadata", { returns: "i", args: ["@", "@", "C"] }, hdrPerFrameMetadataGenerationSession, pixelBuffer, sceneChange);
+}
+export function VTHDRPerFrameMetadataGenerationSessionCreate(allocator, framesPerSecond, options, hdrPerFrameMetadataGenerationSessionOut) {
+    return callFunction("VTHDRPerFrameMetadataGenerationSessionCreate", { returns: "i", args: ["@", "f", "@", "@"] }, allocator, framesPerSecond, options, hdrPerFrameMetadataGenerationSessionOut);
+}
+export function VTHDRPerFrameMetadataGenerationSessionGetTypeID() {
+    return callFunction("VTHDRPerFrameMetadataGenerationSessionGetTypeID", { returns: "L" });
+}
+export function VTIsHardwareDecodeSupported(codecType) {
+    return callFunction("VTIsHardwareDecodeSupported", { returns: "C", args: ["I"] }, codecType);
+}
+export function VTIsStereoMVHEVCDecodeSupported() {
+    return callFunction("VTIsStereoMVHEVCDecodeSupported", { returns: "C" });
+}
+export function VTIsStereoMVHEVCEncodeSupported() {
+    return callFunction("VTIsStereoMVHEVCEncodeSupported", { returns: "C" });
+}
+export function VTMotionEstimationSessionCompleteFrames(session) {
+    return callFunction("VTMotionEstimationSessionCompleteFrames", { returns: "i" }, session);
+}
+export function VTMotionEstimationSessionCopySourcePixelBufferAttributes(motionEstimationSession, attributesOut) {
+    return callFunction("VTMotionEstimationSessionCopySourcePixelBufferAttributes", { returns: "i" }, motionEstimationSession, attributesOut);
+}
+export function VTMotionEstimationSessionCreate(allocator, motionVectorProcessorSelectionOptions, width, height, motionEstimationSessionOut) {
+    return callFunction("VTMotionEstimationSessionCreate", { returns: "i", args: ["@", "@", "I", "I", "@"] }, allocator, motionVectorProcessorSelectionOptions, width, height, motionEstimationSessionOut);
+}
+export function VTMotionEstimationSessionEstimateMotionVectors(session, referenceImage, currentImage, motionEstimationFrameFlags, additionalFrameOptions, outputHandler) {
+    return callFunction("VTMotionEstimationSessionEstimateMotionVectors", { returns: "i" }, session, referenceImage, currentImage, motionEstimationFrameFlags, additionalFrameOptions, outputHandler);
+}
+export function VTMotionEstimationSessionGetTypeID() {
+    return callFunction("VTMotionEstimationSessionGetTypeID", { returns: "L" });
+}
+export function VTMotionEstimationSessionInvalidate(session) {
+    callFunction("VTMotionEstimationSessionInvalidate", undefined, session);
+}
+export function VTMultiPassStorageClose(multiPassStorage) {
+    return callFunction("VTMultiPassStorageClose", { returns: "i" }, multiPassStorage);
+}
+export function VTMultiPassStorageCreate(allocator, fileURL, timeRange, options, multiPassStorageOut) {
+    return callFunction("VTMultiPassStorageCreate", { returns: "i", args: ["@", "@", "{CMTimeRange}", "@", "@"] }, allocator, fileURL, timeRange, options, multiPassStorageOut);
+}
+export function VTMultiPassStorageGetTypeID() {
+    return callFunction("VTMultiPassStorageGetTypeID", { returns: "L" });
+}
+export function VTPixelRotationSessionCreate(allocator, pixelRotationSessionOut) {
+    return callFunction("VTPixelRotationSessionCreate", { returns: "i" }, allocator, pixelRotationSessionOut);
+}
+export function VTPixelRotationSessionGetTypeID() {
+    return callFunction("VTPixelRotationSessionGetTypeID", { returns: "L" });
+}
+export function VTPixelRotationSessionInvalidate(session) {
+    callFunction("VTPixelRotationSessionInvalidate", undefined, session);
+}
+export function VTPixelRotationSessionRotateImage(session, sourceBuffer, destinationBuffer) {
+    return callFunction("VTPixelRotationSessionRotateImage", { returns: "i" }, session, sourceBuffer, destinationBuffer);
+}
+export function VTPixelTransferSessionCreate(allocator, pixelTransferSessionOut) {
+    return callFunction("VTPixelTransferSessionCreate", { returns: "i" }, allocator, pixelTransferSessionOut);
+}
+export function VTPixelTransferSessionGetTypeID() {
+    return callFunction("VTPixelTransferSessionGetTypeID", { returns: "L" });
+}
+export function VTPixelTransferSessionInvalidate(session) {
+    callFunction("VTPixelTransferSessionInvalidate", undefined, session);
+}
+export function VTPixelTransferSessionTransferImage(session, sourceBuffer, destinationBuffer) {
+    return callFunction("VTPixelTransferSessionTransferImage", { returns: "i" }, session, sourceBuffer, destinationBuffer);
+}
+export function VTRAWProcessingSessionCompleteFrames(session) {
+    return callFunction("VTRAWProcessingSessionCompleteFrames", { returns: "i" }, session);
+}
+export function VTRAWProcessingSessionCopyProcessingParameters(session, outParameterArray) {
+    return callFunction("VTRAWProcessingSessionCopyProcessingParameters", { returns: "i" }, session, outParameterArray);
+}
+export function VTRAWProcessingSessionCreate(allocator, formatDescription, outputPixelBufferAttributes, processingSessionOptions, processingSessionOut) {
+    return callFunction("VTRAWProcessingSessionCreate", { returns: "i" }, allocator, formatDescription, outputPixelBufferAttributes, processingSessionOptions, processingSessionOut);
+}
+export function VTRAWProcessingSessionGetTypeID() {
+    return callFunction("VTRAWProcessingSessionGetTypeID", { returns: "L" });
+}
+export function VTRAWProcessingSessionInvalidate(session) {
+    callFunction("VTRAWProcessingSessionInvalidate", undefined, session);
+}
+export function VTRAWProcessingSessionProcessFrame(session, inputPixelBuffer, frameOptions, outputHandler) {
+    return callFunction("VTRAWProcessingSessionProcessFrame", { returns: "i" }, session, inputPixelBuffer, frameOptions, outputHandler);
+}
+export function VTRAWProcessingSessionSetParameterChangedHander(session, parameterChangeHandler) {
+    return callFunction("VTRAWProcessingSessionSetParameterChangedHander", { returns: "i" }, session, parameterChangeHandler);
+}
+export function VTRAWProcessingSessionSetParameterChangedHandler(session, parameterChangeHandler) {
+    return callFunction("VTRAWProcessingSessionSetParameterChangedHandler", { returns: "i" }, session, parameterChangeHandler);
+}
+export function VTRAWProcessingSessionSetProcessingParameters(session, processingParameters) {
+    return callFunction("VTRAWProcessingSessionSetProcessingParameters", { returns: "i" }, session, processingParameters);
+}
+export function VTRegisterProfessionalVideoWorkflowVideoDecoders() {
+    callFunction("VTRegisterProfessionalVideoWorkflowVideoDecoders");
+}
+export function VTRegisterProfessionalVideoWorkflowVideoEncoders() {
+    callFunction("VTRegisterProfessionalVideoWorkflowVideoEncoders");
+}
+export function VTRegisterSupplementalVideoDecoderIfAvailable(codecType) {
+    callFunction("VTRegisterSupplementalVideoDecoderIfAvailable", { args: ["I"] }, codecType);
+}
+export function VTSessionCopyProperty(session, propertyKey, allocator, propertyValueOut) {
+    return callFunction("VTSessionCopyProperty", { returns: "i", args: ["^", "^", "@", "^v"] }, session, propertyKey, allocator, propertyValueOut);
+}
+export function VTSessionCopySerializableProperties(session, allocator, dictionaryOut) {
+    return callFunction("VTSessionCopySerializableProperties", { returns: "i", args: ["^", "@", "@"] }, session, allocator, dictionaryOut);
+}
+export function VTSessionCopySupportedPropertyDictionary(session, supportedPropertyDictionaryOut) {
+    return callFunction("VTSessionCopySupportedPropertyDictionary", { returns: "i", args: ["^", "@"] }, session, supportedPropertyDictionaryOut);
+}
+export function VTSessionSetProperties(session, propertyDictionary) {
+    return callFunction("VTSessionSetProperties", { returns: "i", args: ["^", "@"] }, session, propertyDictionary);
+}
+export function VTSessionSetProperty(session, propertyKey, propertyValue) {
+    return callFunction("VTSessionSetProperty", { returns: "i", args: ["^", "^", "^"] }, session, propertyKey, propertyValue);
+}

package/dist/VideoToolbox/index.d.ts

@@ -69,3 +69,4 @@ export { VTSuperResolutionScalerConfigurationModelStatus } from "./VTSuperResolu
 export { VTSuperResolutionScalerConfigurationQualityPrioritization } from "./VTSuperResolutionScalerConfigurationQualityPrioritization.js";
 export { VTSuperResolutionScalerConfigurationRevision } from "./VTSuperResolutionScalerConfigurationRevision.js";
 export { VTSuperResolutionScalerParametersSubmissionMode } from "./VTSuperResolutionScalerParametersSubmissionMode.js";
+export * from "./functions.js";

package/dist/VideoToolbox/index.js

@@ -33,3 +33,4 @@ export { VTSuperResolutionScalerConfigurationModelStatus } from "./VTSuperResolu
 export { VTSuperResolutionScalerConfigurationQualityPrioritization } from "./VTSuperResolutionScalerConfigurationQualityPrioritization.js";
 export { VTSuperResolutionScalerConfigurationRevision } from "./VTSuperResolutionScalerConfigurationRevision.js";
 export { VTSuperResolutionScalerParametersSubmissionMode } from "./VTSuperResolutionScalerParametersSubmissionMode.js";
+export * from "./functions.js";

package/dist/Vision/functions.d.ts

@@ -0,0 +1,16 @@
+import type { NobjcObject } from "objc-js";
+import type { CGPoint } from "../structs/CGPoint.js";
+import type { CGRect } from "../structs/CGRect.js";
+import type { VNElementType } from "./VNElementType.js";
+export declare function VNElementTypeSize(elementType: VNElementType): number;
+export declare function VNImagePointForFaceLandmarkPoint(faceLandmarkPoint: NobjcObject, faceBoundingBox: CGRect, imageWidth: number, imageHeight: number): CGPoint;
+export declare function VNImagePointForNormalizedPoint(normalizedPoint: CGPoint, imageWidth: number, imageHeight: number): CGPoint;
+export declare function VNImagePointForNormalizedPointUsingRegionOfInterest(normalizedPoint: CGPoint, imageWidth: number, imageHeight: number, roi: CGRect): CGPoint;
+export declare function VNImageRectForNormalizedRect(normalizedRect: CGRect, imageWidth: number, imageHeight: number): CGRect;
+export declare function VNImageRectForNormalizedRectUsingRegionOfInterest(normalizedRect: CGRect, imageWidth: number, imageHeight: number, roi: CGRect): CGRect;
+export declare function VNNormalizedFaceBoundingBoxPointForLandmarkPoint(faceLandmarkPoint: NobjcObject, faceBoundingBox: CGRect, imageWidth: number, imageHeight: number): CGPoint;
+export declare function VNNormalizedPointForImagePoint(imagePoint: CGPoint, imageWidth: number, imageHeight: number): CGPoint;
+export declare function VNNormalizedPointForImagePointUsingRegionOfInterest(imagePoint: CGPoint, imageWidth: number, imageHeight: number, roi: CGRect): CGPoint;
+export declare function VNNormalizedRectForImageRect(imageRect: CGRect, imageWidth: number, imageHeight: number): CGRect;
+export declare function VNNormalizedRectForImageRectUsingRegionOfInterest(imageRect: CGRect, imageWidth: number, imageHeight: number, roi: CGRect): CGRect;
+export declare function VNNormalizedRectIsIdentityRect(normalizedRect: CGRect): boolean;

package/dist/Vision/functions.js

@@ -0,0 +1,38 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+import { callFunction } from "objc-js";
+export function VNElementTypeSize(elementType) {
+    return callFunction("VNElementTypeSize", { returns: "Q", args: ["q"] }, elementType);
+}
+export function VNImagePointForFaceLandmarkPoint(faceLandmarkPoint, faceBoundingBox, imageWidth, imageHeight) {
+    return callFunction("VNImagePointForFaceLandmarkPoint", { returns: "{CGPoint}", args: ["@", "{CGRect}", "Q", "Q"] }, faceLandmarkPoint, faceBoundingBox, imageWidth, imageHeight);
+}
+export function VNImagePointForNormalizedPoint(normalizedPoint, imageWidth, imageHeight) {
+    return callFunction("VNImagePointForNormalizedPoint", { returns: "{CGPoint}", args: ["{CGPoint}", "Q", "Q"] }, normalizedPoint, imageWidth, imageHeight);
+}
+export function VNImagePointForNormalizedPointUsingRegionOfInterest(normalizedPoint, imageWidth, imageHeight, roi) {
+    return callFunction("VNImagePointForNormalizedPointUsingRegionOfInterest", { returns: "{CGPoint}", args: ["{CGPoint}", "Q", "Q", "{CGRect}"] }, normalizedPoint, imageWidth, imageHeight, roi);
+}
+export function VNImageRectForNormalizedRect(normalizedRect, imageWidth, imageHeight) {
+    return callFunction("VNImageRectForNormalizedRect", { returns: "{CGRect}", args: ["{CGRect}", "Q", "Q"] }, normalizedRect, imageWidth, imageHeight);
+}
+export function VNImageRectForNormalizedRectUsingRegionOfInterest(normalizedRect, imageWidth, imageHeight, roi) {
+    return callFunction("VNImageRectForNormalizedRectUsingRegionOfInterest", { returns: "{CGRect}", args: ["{CGRect}", "Q", "Q", "{CGRect}"] }, normalizedRect, imageWidth, imageHeight, roi);
+}
+export function VNNormalizedFaceBoundingBoxPointForLandmarkPoint(faceLandmarkPoint, faceBoundingBox, imageWidth, imageHeight) {
+    return callFunction("VNNormalizedFaceBoundingBoxPointForLandmarkPoint", { returns: "{CGPoint}", args: ["@", "{CGRect}", "Q", "Q"] }, faceLandmarkPoint, faceBoundingBox, imageWidth, imageHeight);
+}
+export function VNNormalizedPointForImagePoint(imagePoint, imageWidth, imageHeight) {
+    return callFunction("VNNormalizedPointForImagePoint", { returns: "{CGPoint}", args: ["{CGPoint}", "Q", "Q"] }, imagePoint, imageWidth, imageHeight);
+}
+export function VNNormalizedPointForImagePointUsingRegionOfInterest(imagePoint, imageWidth, imageHeight, roi) {
+    return callFunction("VNNormalizedPointForImagePointUsingRegionOfInterest", { returns: "{CGPoint}", args: ["{CGPoint}", "Q", "Q", "{CGRect}"] }, imagePoint, imageWidth, imageHeight, roi);
+}
+export function VNNormalizedRectForImageRect(imageRect, imageWidth, imageHeight) {
+    return callFunction("VNNormalizedRectForImageRect", { returns: "{CGRect}", args: ["{CGRect}", "Q", "Q"] }, imageRect, imageWidth, imageHeight);
+}
+export function VNNormalizedRectForImageRectUsingRegionOfInterest(imageRect, imageWidth, imageHeight, roi) {
+    return callFunction("VNNormalizedRectForImageRectUsingRegionOfInterest", { returns: "{CGRect}", args: ["{CGRect}", "Q", "Q", "{CGRect}"] }, imageRect, imageWidth, imageHeight, roi);
+}
+export function VNNormalizedRectIsIdentityRect(normalizedRect) {
+    return callFunction("VNNormalizedRectIsIdentityRect", { returns: "B", args: ["{CGRect}"] }, normalizedRect);
+}

package/dist/Vision/index.d.ts

@@ -296,3 +296,4 @@ export { VNImageOption } from "./VNImageOption.js";
 export { VNRecognizedPointGroupKey } from "./VNRecognizedPointGroupKey.js";
 export { VNRecognizedPointKey } from "./VNRecognizedPointKey.js";
 export { VNVideoProcessingOption } from "./VNVideoProcessingOption.js";
+export * from "./functions.js";

package/dist/Vision/index.js

@@ -110,3 +110,4 @@ export { VNImageOption } from "./VNImageOption.js";
 export { VNRecognizedPointGroupKey } from "./VNRecognizedPointGroupKey.js";
 export { VNRecognizedPointKey } from "./VNRecognizedPointKey.js";
 export { VNVideoProcessingOption } from "./VNVideoProcessingOption.js";
+export * from "./functions.js";