objcjs-types 0.2.1 → 0.4.0

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/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);
+}