objcjs-types 0.3.0 → 0.5.0

package/dist/CoreImage/CIKernel.d.ts

@@ -37,7 +37,7 @@ export declare class _CIKernel extends _NSObject {
     /**
      * Apply the receiver CIKernel to produce a new CIImage object. The 'extent' is the bounding box of all non-clear pixels produced by the kernel. The 'callback' is a block that should return the rectangle of each input image that is needed to produce a given rectangle in the coordinate space of the new image. The 'args' is an array of parameters needed to describe the new image. The object types of the items in the array correspond to the argument types of the kernel function. For example, if the first argument in the kernel is a sampler, then the first object in the array must be a CIImage.
      */
-    applyWithExtent$roiCallback$arguments$(extent: CGRect, callback: NobjcObject, args: _NSArray | null): _CIImage | null;
+    applyWithExtent$roiCallback$arguments$(extent: CGRect, callback: (arg0: number, arg1: CGRect) => CGRect, args: _NSArray | null): _CIImage | null;
     /** The name of the kernel. */
     name(): _NSString;
 }

package/dist/CoreImage/CIRenderDestination.d.ts

@@ -26,7 +26,7 @@ export declare class _CIRenderDestination extends _NSObject {
     /**
      * Create a CIRenderDestination based on a Metal texture. Rendering to a MTLTexture-backed CIRenderDestination is only supported by MTLTexture-backed CIContexts. The provider 'block' will be called lazily when the destination is rendered to. The block must return a texture with a MTLTextureType of MTLTextureType2D. The 'width', 'height' and 'pixelFormat' argument values should be the same as the width, height and pixelFormat of the MTLTexture that will be returned by 'block' An optional MTLCommandBuffer can be specified, with which to use for rendering to the MTLTexture. NOTE: Rendering to a texture initialized with a commandBuffer requires encoding all the commands to render an image into the specified buffer. This may impact system responsiveness and may result in higher memory usage if the image requires many passes to render. To avoid this impact, it is recommended to create a context using [CIContext contextWithMTLCommandQueue:] and create the CIRenderDestination without specifying a buffer. The destination's 'colorspace' property will default a CGColorSpace created with kCGColorSpaceSRGB, kCGColorSpaceExtendedSRGB, or kCGColorSpaceGenericGrayGamma2_2.
      */
-    initWithWidth$height$pixelFormat$commandBuffer$mtlTextureProvider$(width: number, height: number, pixelFormat: MTLPixelFormat, commandBuffer: _MTLCommandBuffer | null, block: NobjcObject | null): _CIRenderDestination;
+    initWithWidth$height$pixelFormat$commandBuffer$mtlTextureProvider$(width: number, height: number, pixelFormat: MTLPixelFormat, commandBuffer: _MTLCommandBuffer | null, block: (() => _MTLTexture) | null): _CIRenderDestination;
     /**
      * Create a CIRenderDestination based on an OpenGL texture. Rendering to a GLTexture-backed CIRenderDestination is only supported by GLContext-backed CIContexts. The texture id must be bound to a GLContext that is shared with that of the GLContext-backed CIContext. The destination's 'colorspace' property will default a CGColorSpace created with kCGColorSpaceSRGB, kCGColorSpaceExtendedSRGB, or kCGColorSpaceGenericGrayGamma2_2.
      */

package/dist/CoreImage/CIWarpKernel.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _CIImage } from "./CIImage.js";
 import type { _CIKernel } from "./CIKernel.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
@@ -15,5 +14,5 @@ export declare class _CIWarpKernel extends _CIKernel {
     /**
      * Apply the receiver CIWarpKernel to produce a new CIImage object. The 'extent' is the bounding box of all pixel coordinates that are warped by the kernel to fall within the extent of 'image'. The 'image' is the input image that will be warped into a new image. The 'callback' is a block that should return the rectangle of the input image that is needed to produce a given rectangle in the coordinate space of the new image. The 'args' is an array of parameters needed to describe the warping function. The object types of the items in the array correspond to the argument types of the kernel function. For example, if the first argument in the kernel is a vec3, then the first object in the array must be a CIVector of count 3.
      */
-    applyWithExtent$roiCallback$inputImage$arguments$(extent: CGRect, callback: NobjcObject, image: _CIImage, args: _NSArray | null): _CIImage | null;
+    applyWithExtent$roiCallback$inputImage$arguments$(extent: CGRect, callback: (arg0: number, arg1: CGRect) => CGRect, image: _CIImage, args: _NSArray | null): _CIImage | null;
 }

package/dist/CoreLocation/CLBackgroundActivitySession.d.ts

@@ -1,5 +1,5 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _CLBackgroundActivitySessionDiagnostic } from "./CLBackgroundActivitySessionDiagnostic.js";
 export declare class _CLBackgroundActivitySession extends _NSObject {
     static alloc(): _CLBackgroundActivitySession;
     static new(): _CLBackgroundActivitySession;
@@ -11,7 +11,7 @@ export declare class _CLBackgroundActivitySession extends _NSObject {
     /**
      * backgroundActivitySessionWithQueue:handler: Discussion: Starts a background activity session while delivering diagnostic updates to the handler. queue: Specifies the queue to which the handler is submitted with each available diagnostic. handler: Specifies the block that will be invoked with each update. See -backgroundActivitySession for more details
      */
-    static backgroundActivitySessionWithQueue$handler$(queue: _NSObject, handler: NobjcObject): _CLBackgroundActivitySession;
+    static backgroundActivitySessionWithQueue$handler$(queue: _NSObject, handler: (diagnostic: _CLBackgroundActivitySessionDiagnostic) => void): _CLBackgroundActivitySession;
     /**
      * invalidate Discussion: Ends the session immediately. Any UI giving visual attestation to this background session will also be terminated. Once the session is invalidated it cannot become active again.
      */

package/dist/CoreLocation/CLGeocoder.d.ts

@@ -1,5 +1,7 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSLocale } from "../Foundation/NSLocale.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -14,28 +16,28 @@ export declare class _CLGeocoder extends _NSObject {
      * reverse geocode requests
      * @deprecated Use MKReverseGeocodingRequest
      */
-    reverseGeocodeLocation$completionHandler$(location: NobjcObject, completionHandler: NobjcObject): void;
+    reverseGeocodeLocation$completionHandler$(location: NobjcObject, completionHandler: (arg0: _NSArray, arg1: _NSError) => void): void;
     /** @deprecated Use MKReverseGeocodingRequest */
-    reverseGeocodeLocation$preferredLocale$completionHandler$(location: NobjcObject, locale: _NSLocale | null, completionHandler: NobjcObject): void;
+    reverseGeocodeLocation$preferredLocale$completionHandler$(location: NobjcObject, locale: _NSLocale | null, completionHandler: (arg0: _NSArray, arg1: _NSError) => void): void;
     /**
      * forward geocode requests geocodeAddressDictionary:completionHandler: takes an address dictionary as defined by the AddressBook framework. You can obtain an address dictionary from an ABPerson by retrieving the kABPersonAddressProperty property. Alternately, one can be constructed using the kABPersonAddress* keys defined in <AddressBook /ABPerson.h>.
      * @deprecated Use MKReverseGeocodingRequest
      */
-    geocodeAddressDictionary$completionHandler$(addressDictionary: _NSDictionary, completionHandler: NobjcObject): void;
+    geocodeAddressDictionary$completionHandler$(addressDictionary: _NSDictionary, completionHandler: (arg0: _NSArray, arg1: _NSError) => void): void;
     /** @deprecated Use MKGeocodingRequest */
-    geocodeAddressString$inRegion$completionHandler$(addressString: _NSString, region: _CLRegion | null, completionHandler: NobjcObject): void;
+    geocodeAddressString$inRegion$completionHandler$(addressString: _NSString, region: _CLRegion | null, completionHandler: (arg0: _NSArray, arg1: _NSError) => void): void;
     /** @deprecated Use MKGeocodingRequest */
-    geocodeAddressString$inRegion$preferredLocale$completionHandler$(addressString: _NSString, region: _CLRegion | null, locale: _NSLocale | null, completionHandler: NobjcObject): void;
+    geocodeAddressString$inRegion$preferredLocale$completionHandler$(addressString: _NSString, region: _CLRegion | null, locale: _NSLocale | null, completionHandler: (arg0: _NSArray, arg1: _NSError) => void): void;
     /** @deprecated Use MKGeocodingRequest */
-    geocodeAddressString$inRegionCenteredAt$inRegionRadius$preferredLocale$completionHandler$(addressString: _NSString, centroid: CLLocationCoordinate2D, radius: number, locale: _NSLocale | null, completionHandler: NobjcObject): void;
+    geocodeAddressString$inRegionCenteredAt$inRegionRadius$preferredLocale$completionHandler$(addressString: _NSString, centroid: CLLocationCoordinate2D, radius: number, locale: _NSLocale | null, completionHandler: (arg0: _NSArray, arg1: _NSError) => void): void;
     /** @deprecated Use MKGeocodingRequest */
-    geocodeAddressString$completionHandler$(addressString: _NSString, completionHandler: NobjcObject): void;
+    geocodeAddressString$completionHandler$(addressString: _NSString, completionHandler: (arg0: _NSArray, arg1: _NSError) => void): void;
     /** @deprecated Use MKGeocodingRequest */
     cancelGeocode(): void;
     /** @deprecated Use MKReverseGeocodingRequest */
-    geocodePostalAddress$completionHandler$(postalAddress: _CNPostalAddress, completionHandler: NobjcObject): void;
+    geocodePostalAddress$completionHandler$(postalAddress: _CNPostalAddress, completionHandler: (arg0: _NSArray, arg1: _NSError) => void): void;
     /** @deprecated Use MKReverseGeocodingRequest */
-    geocodePostalAddress$preferredLocale$completionHandler$(postalAddress: _CNPostalAddress, locale: _NSLocale | null, completionHandler: NobjcObject): void;
+    geocodePostalAddress$preferredLocale$completionHandler$(postalAddress: _CNPostalAddress, locale: _NSLocale | null, completionHandler: (arg0: _NSArray, arg1: _NSError) => void): void;
     /** @deprecated Use MKReverseGeocodingRequest */
     geocoding(): boolean;
 }

package/dist/CoreLocation/CLLocationManager.d.ts

@@ -1,4 +1,7 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSData } from "../Foundation/NSData.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -66,7 +69,7 @@ export declare class _CLLocationManager extends _NSObject {
     /**
      * requestTemporaryFullAccuracyAuthorizationWithPurposeKey:completion: Discussion: If your app doesn't have permission to access accurate location (see -accuracyAuthorization), you can use this method to request temporary access to accurate location. This access will expire automatically, but it won't expire while the user is still engaged with your app. So, for example, while your app is in the foreground your app will retain the temporary access it was granted. Similarly, if your app starts a Continuous Background Location session with the background location indicator enabled (see -showsBackgroundLocationIndicator), your access to accurate location will remain as long as the background location indicator remains enabled. This allows your app to provide session-oriented experiences which require accurate location (e.g. fitness or navigation), even if the user has decided not to grant your app persistent access to accurate location. When CoreLocation prepares the prompt for display, it will look at the NSLocationTemporaryUsageDescriptionDictionary key in your Info.plist. The value should be a dictionary containing usage descriptions. The purposeKey you provide to this method must correspond to an entry in that dictionary. To retrieve a localized string, CoreLocation will load your InfoPlist.strings file and try to look up a string using the purposeKey you provided. If that fails, CoreLocation will use the content provided in your Info.plist. For example, suppose your Info.plist contains the following. <key >NSLocationTemporaryUsageDescriptionDictionary </key > <dict > <key >ExampleUsageDescription </key > <string >This app needs accurate location so it can verify that you're in a supported region. </string > <key >AnotherUsageDescription </key > <string >This app needs accurate location so it can show you relevant results. </string > </dict > In this case, you would be able to provide either "ExampleUsageDescription" or "AnotherUsageDescription" for the purposeKey argument. Passing any other string would result in the prompt not being displayed. To localize these usage descriptions, you would add entries for "ExampleUsageDescription" and "AnotherUsageDescription" to your InfoPlist.strings file. CoreLocation may decide against showing the user a prompt. For example, if your app already has access to accurate location or it is currently in the background. When that happens, your completion block will be called with an appropriate NSError. If the user responded to the prompt, your completion block will be called with a nil error. At that point, you may query the state of your CLLocationManager to see if you have been granted accurate access. The completion block will be called in the same threading context where delegate callbacks occur. That is, it will be called on the runloop where the CLLocationManager was originally initialized.
      */
-    requestTemporaryFullAccuracyAuthorizationWithPurposeKey$completion$(purposeKey: _NSString, completion: NobjcObject | null): void;
+    requestTemporaryFullAccuracyAuthorizationWithPurposeKey$completion$(purposeKey: _NSString, completion: ((arg0: _NSError) => void) | null): void;
     /**
      * requestTemporaryFullAccuracyAuthorizationWithPurposeKey: Discussion: This is a variant of requestTemporaryAccurateLocationAuthorizationWithPurposeKey:completion: which doesn't take a completion block. This is equivalent to passing in a nil completion block.
      */
@@ -98,7 +101,7 @@ export declare class _CLLocationManager extends _NSObject {
     /**
      * startMonitoringLocationPushes Discussion: Request an Apple Push Notification service token to be used to send location pushes. Incoming location pushes launch the app's Location Push Service Extension. Requires the com.apple.developer.location.push entitlement.
      */
-    startMonitoringLocationPushesWithCompletion$(completion: NobjcObject | null): void;
+    startMonitoringLocationPushesWithCompletion$(completion: ((token: _NSData, arg1: _NSError) => void) | null): void;
     /** stopMonitoringLocationPushes Discussion: Stop monitoring for location pushes. */
     stopMonitoringLocationPushes(): void;
     /**
@@ -152,7 +155,7 @@ export declare class _CLLocationManager extends _NSObject {
     /**
      * requestHistoricalLocationsWithPurposeKey:sampleCount:completionHandler: Discussion: Request asynchronous delivery of historical location information. If the app is currently configured correctly, historical locations are available, and this request is approved by the user via prompt, then the historical locations will be delivered to the completion handler. Otherwise, the completion handler will be invoked with an empty array. Historical location availability is subject to privacy limits and should never be assumed available. If historic location is not available, no prompt will be presented to the user, and the empty array will be returned. The sampleCount parameter may be used to limit the number of returned locations by decimation. Correct configuration requires the App to: - Have effective authorization to receive the user's current location. - Carry the required entitlement: com.apple.developer.corelocation.wilderness-safety - Have a NSLocationWildernessSafetyUsageDescriptionDictionary in its info.plist and related localized resources - Pass a key identifying a usage description string in that dictionary to be included in the prompt to the user if one is shown. The completion handler will receive a non-nil error object in the event of misconfiguration. Requires the com.apple.developer.corelocation.wilderness-safety entitlement.
      */
-    requestHistoricalLocationsWithPurposeKey$sampleCount$completionHandler$(purposeKey: _NSString, sampleCount: number, handler: NobjcObject | null): void;
+    requestHistoricalLocationsWithPurposeKey$sampleCount$completionHandler$(purposeKey: _NSString, sampleCount: number, handler: ((arg0: _NSArray, arg1: _NSError) => void) | null): void;
     /**
      * startMonitoringVisits Discussion: Begin monitoring for visits. All CLLLocationManagers allocated by your application, both current and future, will deliver detected visits to their delegates. This will continue until -stopMonitoringVisits is sent to any such CLLocationManager, even across application relaunch events. Detected visits are sent to the delegate's -locationManager:didVisit: method.
      */

package/dist/CoreLocation/CLLocationManagerDelegate.d.ts

@@ -8,6 +8,7 @@ import type { _CLVisit } from "./CLVisit.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSError } from "../Foundation/NSError.js";
 import type { CLAuthorizationStatus } from "./CLAuthorizationStatus.js";
+import type { CLRegionState } from "./CLRegionState.js";
 export interface _CLLocationManagerDelegate {
     /**
      * locationManager:didUpdateToLocation:fromLocation: Discussion: Invoked when a new location is available. oldLocation may be nil if there is no previous location available. This method is deprecated. If locationManager:didUpdateLocations: is implemented, this method will not be called.
@@ -29,7 +30,7 @@ export interface _CLLocationManagerDelegate {
     /**
      * locationManager:didDetermineState:forRegion: Discussion: Invoked when there's a state transition for a monitored region or in response to a request for state via a a call to requestStateForRegion:.
      */
-    locationManager$didDetermineState$forRegion$?(manager: _CLLocationManager, state: NobjcObject, region: _CLRegion): void;
+    locationManager$didDetermineState$forRegion$?(manager: _CLLocationManager, state: CLRegionState, region: _CLRegion): void;
     /**
      * locationManager:didRangeBeacons:inRegion: Discussion: Invoked when a new set of beacons are available in the specified region. beacons is an array of CLBeacon objects. If beacons is empty, it may be assumed no beacons that match the specified region are nearby. Similarly if a specific beacon no longer appears in beacons, it may be assumed the beacon is no longer received by the device.
      * @deprecated Use locationManager:didRangeBeacons:satisfyingConstraint:

package/dist/CoreLocation/CLLocationPushServiceError.d.ts

@@ -0,0 +1,8 @@
+export declare const CLLocationPushServiceError: {
+    readonly Unknown: 0;
+    readonly MissingPushExtension: 1;
+    readonly MissingPushServerEnvironment: 2;
+    readonly MissingEntitlement: 3;
+    readonly UnsupportedPlatform: 4;
+};
+export type CLLocationPushServiceError = typeof CLLocationPushServiceError[keyof typeof CLLocationPushServiceError];

package/dist/CoreLocation/CLLocationPushServiceError.js

@@ -0,0 +1,8 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const CLLocationPushServiceError = {
+    Unknown: 0,
+    MissingPushExtension: 1,
+    MissingPushServerEnvironment: 2,
+    MissingEntitlement: 3,
+    UnsupportedPlatform: 4,
+};

package/dist/CoreLocation/CLLocationPushServiceExtension.d.ts

@@ -1,8 +1,7 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 export interface _CLLocationPushServiceExtension {
     /** Call the completion handler once the location push has been handled. */
-    didReceiveLocationPushPayload$completion$?(payload: _NSDictionary, completion: NobjcObject): void;
+    didReceiveLocationPushPayload$completion$?(payload: _NSDictionary, completion: () => void): void;
     /** Called just before this extension is terminated by the system. */
     serviceExtensionWillTerminate?(): void;
 }

package/dist/CoreLocation/CLLocationUpdater.d.ts

@@ -1,5 +1,5 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _CLUpdate } from "./CLUpdate.js";
 import type { CLLiveUpdateConfiguration } from "./CLLiveUpdateConfiguration.js";
 export declare class _CLLocationUpdater extends _NSObject {
     static alloc(): _CLLocationUpdater;
@@ -8,11 +8,11 @@ export declare class _CLLocationUpdater extends _NSObject {
     /**
      * liveUpdaterWithQueue:handler: Discussion: Returns a new CLLocationUpdater with the given queue and handler, using the default live update configuration. queue: Specifies the queue to which the handler is submitted with each available update. handler: Specifies the block that will be invoked with each update. CoreLocation will ensure the app has a few seconds of runtime to process each location update it is authorized to receive. If the app crashes, or exits for any reason while updates are flowing, it will be launched for the next update, which it may receive by calling this method again to express resumed interest. If this method is not called again, or the resulting updater is not resumed again, then CoreLocation will automatically stop the flow of updates.
      */
-    static liveUpdaterWithQueue$handler$(queue: _NSObject, handler: NobjcObject | null): _CLLocationUpdater | null;
+    static liveUpdaterWithQueue$handler$(queue: _NSObject, handler: ((update: _CLUpdate) => void) | null): _CLLocationUpdater | null;
     /**
      * liveUpdaterWithConfiguration:queue:handler: Discussion: Returns a new CLLocationUpdater with the given a CLLiveUpdateConfiguration, queue and handler. configuration: Specifies the live update configuration which should be used. queue: Specifies the queue to which the handler is submitted with each available update. handler: Specifies the block that will be invoked with each update. CoreLocation will ensure the app has a few seconds of runtime to process each location update it is authorized to receive. If the app crashes, crashes, or exits for any reason while updates are flowing, it will be launched for the next update, which it may receive by calling this method again to express resumed interest. If this method is not called again, or the resulting updater is not resumed again, then CoreLocation will automatically stop the flow of updates.
      */
-    static liveUpdaterWithConfiguration$queue$handler$(configuration: CLLiveUpdateConfiguration, queue: _NSObject, handler: NobjcObject | null): _CLLocationUpdater | null;
+    static liveUpdaterWithConfiguration$queue$handler$(configuration: CLLiveUpdateConfiguration, queue: _NSObject, handler: ((update: _CLUpdate) => void) | null): _CLLocationUpdater | null;
     /**
      * resume Discussion: Start delivery of Updates to the handler, or resume from where -pause was called. -resume must be called to start the flow of updates when a CLLocationUpdater is first obtained.
      */

package/dist/CoreLocation/CLMonitor.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -13,7 +12,7 @@ export declare class _CLMonitor extends _NSObject {
     /**
      * requestMonitorWithConfiguration:completion: Discussion: Creates or opens, a `CLMonitor` instance with the given name. The completion handler will be called with the instance of `CLMonitor` on the queue that was set in the configuration instance. Conditions can be added for monitoring or removed from monitoring by this instance of `CLMonitor`. When an event occurs, the passed in block would be called on the specified queue. The callback handler is invoked with this instance of `CLMonitor` and an instance of `CLMonitoringEvent` containing the identifier under which the condition is monitored, an optional instance of `CLCondition` containing specifics, the new state, and the timestamp of the event. All interaction directly with the returned `CLMonitor` must occur on the specified queue. Failing to do so will result in undefined behavior. Conditions added to an instance of `CLMonitor` will persist until removed from monitoring. However, CoreLocation will stop monitoring conditions if an event is pending for them, but no `CLMonitor` has been configured to receive it. The conditions are stored in an opaque file at ~/Library/CoreLocation/BundleId (or Process name)/`name`.monitor. Note that for containerized Apps this will be inside the Data container. Apps need to observe when protected data becomes available using `UIApplicationProtectedDataDidBecomeAvailable` before creating a `CLMonitor` instance. Persistence of Conditions enables an app to query efficiently for conditions currently being monitored and the last event delivered for each. The app can choose to initialize the monitoring state for a condition. By default, it is set to `CLMonitoringStateUnknown`. - Note: Only one instance of `CLMonitor` with a given name may be opened at a time. Attempting to open another instance with the same name will return `false`.
      */
-    static requestMonitorWithConfiguration$completion$(config: _CLMonitorConfiguration, completionHandler: NobjcObject): void;
+    static requestMonitorWithConfiguration$completion$(config: _CLMonitorConfiguration, completionHandler: (monitor: _CLMonitor) => void): void;
     /**
      * addConditionForMonitoring:identifier: Discussion: Adds `condition` to be monitored under `identifier`. It initializes the monitoring state to `CLMonitoringStateUnknown`.
      */

package/dist/CoreLocation/CLMonitorConfiguration.d.ts

@@ -1,6 +1,7 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
+import type { _CLMonitor } from "./CLMonitor.js";
+import type { _CLMonitoringEvent } from "./CLMonitoringEvent.js";
 export declare class _CLMonitorConfiguration extends _NSObject {
     static alloc(): _CLMonitorConfiguration;
     static new(): _CLMonitorConfiguration;
@@ -8,7 +9,7 @@ export declare class _CLMonitorConfiguration extends _NSObject {
     /**
      * Returns a configuration object which may be used to create or open an instance of `CLMonitor`. name : Identifies the instance of `CLMonitor` which should be created or opened. `name` should contain only alpha-numeric characters and cannot start with "_". queue : Dispatch queue which should be used to synchronize access to the CLMonitor instance. All interactions related to the `CLMonitor` instance should be performed on this queue. Events generated by the `CLMonitor` instance will be delivered to the handler on this queue. Accessing `CLMonitor` outside of the queue will result in undefined behavior. handler : The callback handler to be submitted to `queue` for each event.
      */
-    static configWithMonitorName$queue$eventHandler$(name: _NSString, queue: _NSObject, eventHandler: NobjcObject): _CLMonitorConfiguration;
+    static configWithMonitorName$queue$eventHandler$(name: _NSString, queue: _NSObject, eventHandler: (monitor: _CLMonitor, event: _CLMonitoringEvent) => void): _CLMonitorConfiguration;
     /** name Discussion: Name of the Monitor instance to create or open. */
     name(): _NSString;
     /**
@@ -18,5 +19,5 @@ export declare class _CLMonitorConfiguration extends _NSObject {
     /**
      * handler Discussion: Handler block which will be used as the event handler for the `CLMonitor` instance.
      */
-    eventHandler(): NobjcObject;
+    eventHandler(): (arg0: _CLMonitor, arg1: _CLMonitoringEvent) => void;
 }

package/dist/CoreLocation/CLRegionState.d.ts

@@ -0,0 +1,6 @@
+export declare const CLRegionState: {
+    readonly Unknown: 0;
+    readonly Inside: 1;
+    readonly Outside: 2;
+};
+export type CLRegionState = typeof CLRegionState[keyof typeof CLRegionState];

package/dist/CoreLocation/CLRegionState.js

@@ -0,0 +1,6 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const CLRegionState = {
+    Unknown: 0,
+    Inside: 1,
+    Outside: 2,
+};

package/dist/CoreLocation/CLServiceSession.d.ts

@@ -1,6 +1,6 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
+import type { _CLServiceSessionDiagnostic } from "./CLServiceSessionDiagnostic.js";
 import type { CLServiceSessionAuthorizationRequirement } from "./CLServiceSessionAuthorizationRequirement.js";
 export declare class _CLServiceSession extends _NSObject {
     static alloc(): _CLServiceSession;
@@ -13,7 +13,7 @@ export declare class _CLServiceSession extends _NSObject {
     /**
      * sessionRequiringAuthorization:queue:handler: Discussion: Creates a CLServiceSession instance with specified authorization requirement. Session behaves the same as decribed for sessionRequiringAuthorization: queue: Specifies the queue to which the handler is submitted for receiving diagnostic updates handler: Specifies the block that will be invoked with each diagnostic update.
      */
-    static sessionRequiringAuthorization$queue$handler$(authorizationRequirement: CLServiceSessionAuthorizationRequirement, queue: _NSObject, handler: NobjcObject): _CLServiceSession;
+    static sessionRequiringAuthorization$queue$handler$(authorizationRequirement: CLServiceSessionAuthorizationRequirement, queue: _NSObject, handler: (diagnostic: _CLServiceSessionDiagnostic) => void): _CLServiceSession;
     /**
      * sessionRequiringAuthorization:fullAccuracyPurposeKey: Discussion: Creates a CLServiceSession instance with specified authorization requirement and fullAccuracy Purpose Key authorizationRequirement: Same as applicable for sessionRequiringAuthorization: i.e Passing an authorization requirement other than .none will cause Location Services to seek the corresponding level of authorization from the user when possible. fullAccuracyPurposeKey: Names a string in the NSLocationTemporaryUsageDescriptionDictionary. Location Services will request temporary full accuracy authorization from the user using this string if necessary while this session is outstanding.
      */
@@ -21,7 +21,7 @@ export declare class _CLServiceSession extends _NSObject {
     /**
      * sessionRequiringAuthorization:fullAccuracyPurposeKey:queue:handler: Discussion: Creates a CLServiceSession instance with specified authorization requirement and fullAccuracy Purpose Key same as sessionRequiringAuthorization:fullAccuracyPurposeKey: This variant allows to specify a queue to which specified callback handler will be submitted for receiving diagnostic updates.
      */
-    static sessionRequiringAuthorization$fullAccuracyPurposeKey$queue$handler$(authorizationRequirement: CLServiceSessionAuthorizationRequirement, purposeKey: _NSString, queue: _NSObject, handler: NobjcObject): _CLServiceSession;
+    static sessionRequiringAuthorization$fullAccuracyPurposeKey$queue$handler$(authorizationRequirement: CLServiceSessionAuthorizationRequirement, purposeKey: _NSString, queue: _NSObject, handler: (diagnostic: _CLServiceSessionDiagnostic) => void): _CLServiceSession;
     /**
      * invalidate Discussion: Ends the session immediately. Once the session is invalidated it cannot become active again.
      */

package/dist/CoreLocation/index.d.ts

@@ -79,6 +79,8 @@ export { CLAuthorizationStatus } from "./CLAuthorizationStatus.js";
 export { CLDeviceOrientation } from "./CLDeviceOrientation.js";
 export { CLError } from "./CLError.js";
 export { CLLiveUpdateConfiguration } from "./CLLiveUpdateConfiguration.js";
+export { CLLocationPushServiceError } from "./CLLocationPushServiceError.js";
 export { CLMonitoringState } from "./CLMonitoringState.js";
 export { CLProximity } from "./CLProximity.js";
+export { CLRegionState } from "./CLRegionState.js";
 export { CLServiceSessionAuthorizationRequirement } from "./CLServiceSessionAuthorizationRequirement.js";

package/dist/CoreLocation/index.js

@@ -31,6 +31,8 @@ export { CLAuthorizationStatus } from "./CLAuthorizationStatus.js";
 export { CLDeviceOrientation } from "./CLDeviceOrientation.js";
 export { CLError } from "./CLError.js";
 export { CLLiveUpdateConfiguration } from "./CLLiveUpdateConfiguration.js";
+export { CLLocationPushServiceError } from "./CLLocationPushServiceError.js";
 export { CLMonitoringState } from "./CLMonitoringState.js";
 export { CLProximity } from "./CLProximity.js";
+export { CLRegionState } from "./CLRegionState.js";
 export { CLServiceSessionAuthorizationRequirement } from "./CLServiceSessionAuthorizationRequirement.js";

package/dist/CoreMIDI/MIDICIDiscoveryManager.d.ts

@@ -1,9 +1,9 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 export declare class _MIDICIDiscoveryManager extends _NSObject {
     static alloc(): _MIDICIDiscoveryManager;
     static new(): _MIDICIDiscoveryManager;
     init(): _MIDICIDiscoveryManager;
     static sharedInstance(): _MIDICIDiscoveryManager;
-    discoverWithHandler$(completedHandler: NobjcObject): void;
+    discoverWithHandler$(completedHandler: (arg0: _NSArray) => void): void;
 }

package/dist/CoreMIDI/MIDICISession.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSData } from "../Foundation/NSData.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSNumber } from "../Foundation/NSNumber.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _MIDICIDeviceInfo } from "./MIDICIDeviceInfo.js";
@@ -10,7 +11,7 @@ export declare class _MIDICISession extends _NSObject {
     static alloc(): _MIDICISession;
     static new(): _MIDICISession;
     init(): _MIDICISession;
-    initWithDiscoveredNode$dataReadyHandler$disconnectHandler$(discoveredNode: _MIDICIDiscoveredNode, handler: NobjcObject, disconnectHandler: NobjcObject): _MIDICISession;
+    initWithDiscoveredNode$dataReadyHandler$disconnectHandler$(discoveredNode: _MIDICIDiscoveredNode, handler: () => void, disconnectHandler: (arg0: _MIDICISession, arg1: _NSError) => void): _MIDICISession;
     /**
      * Given a MIDI channel number, return the supported profiles. Note that the arrays will be empty if this property is queried before data is ready.
      */
@@ -48,11 +49,11 @@ export declare class _MIDICISession extends _NSObject {
     /**
      * An optional block called when a device signals that a profile has been enabled or disabled.
      */
-    profileChangedCallback(): NobjcObject | null;
-    setProfileChangedCallback$(value: NobjcObject | null): void;
+    profileChangedCallback(): ((arg0: _MIDICISession, arg1: number, arg2: _MIDICIProfile, arg3: boolean) => void) | null;
+    setProfileChangedCallback$(value: ((arg0: _MIDICISession, arg1: number, arg2: _MIDICIProfile, arg3: boolean) => void) | null): void;
     /**
      * An optional block called when a device sends profile-specific data to the session.
      */
-    profileSpecificDataHandler(): NobjcObject | null;
-    setProfileSpecificDataHandler$(value: NobjcObject | null): void;
+    profileSpecificDataHandler(): ((arg0: _MIDICISession, arg1: number, arg2: _MIDICIProfile, arg3: _NSData) => void) | null;
+    setProfileSpecificDataHandler$(value: ((arg0: _MIDICISession, arg1: number, arg2: _MIDICIProfile, arg3: _NSData) => void) | null): void;
 }

package/dist/CoreMIDI/MIDIUMPMutableEndpoint.d.ts

@@ -10,7 +10,7 @@ export declare class _MIDIUMPMutableEndpoint extends _MIDIUMPEndpoint {
     /**
      * @method initWithName:deviceInfo:productInstanceID:MIDIProtocol:destinationCallback @brief Initializer for creating a new MIDIUMPEndpoint. @param name The UMP endpoint name. @param deviceInfo The MIDI 2 device ID info for the UMP endpoint. @param productInstanceID The product instance ID, up to 42 characters. @param MIDIProtocol The MIDI protocol. @param destinationCallback The receive callback used to create the UMP endpoint's MIDI destination associated, which can be used to observe or process incoming MIDI traffic. @discussion This operation will fail if the device ID information is malformed or if virtual MIDI endpoint creation is not allowed (for example, on iOS, if your app doesn't list 'audio' in UIBackgroundModes).
      */
-    initWithName$deviceInfo$productInstanceID$MIDIProtocol$destinationCallback$(name: _NSString, deviceInfo: _MIDI2DeviceInfo, productInstanceID: _NSString, MIDIProtocol: NobjcObject, destinationCallback: NobjcObject): _MIDIUMPMutableEndpoint | null;
+    initWithName$deviceInfo$productInstanceID$MIDIProtocol$destinationCallback$(name: _NSString, deviceInfo: _MIDI2DeviceInfo, productInstanceID: _NSString, MIDIProtocol: NobjcObject, destinationCallback: (arg0: NobjcObject, arg1: NobjcObject) => void): _MIDIUMPMutableEndpoint | null;
     /**
      * @method setName:error: @brief Set the endpoints name. @param name A string representing the name of the endpoint. @param error The out-error used if an error occurs. @return YES for success. NO in the event of a failure, in which case the error is returned in error. @discussion This operation will fail if the name could not be set.
      */

package/dist/CoreMIDI/functions.d.ts

@@ -2,11 +2,11 @@ import type { NobjcObject } from "objc-js";
 export declare function MIDIBluetoothDriverActivateAllConnections(): number;
 export declare function MIDIBluetoothDriverDisconnect(uuid: Uint8Array): number;
 export declare function MIDIClientCreate(name: Uint8Array, notifyProc: NobjcObject | null, notifyRefCon: Uint8Array | null, outClient: NobjcObject): number;
-export declare function MIDIClientCreateWithBlock(name: Uint8Array, outClient: NobjcObject, notifyBlock: NobjcObject | null): number;
+export declare function MIDIClientCreateWithBlock(name: Uint8Array, outClient: NobjcObject, notifyBlock: ((arg0: NobjcObject) => void) | null): number;
 export declare function MIDIClientDispose(client: number): number;
 export declare function MIDIDestinationCreate(client: number, name: Uint8Array, readProc: NobjcObject, refCon: Uint8Array | null, outDest: NobjcObject): number;
-export declare function MIDIDestinationCreateWithBlock(client: number, name: Uint8Array, outDest: NobjcObject, readBlock: NobjcObject): number;
-export declare function MIDIDestinationCreateWithProtocol(client: number, name: Uint8Array, protocol: NobjcObject, outDest: NobjcObject, readBlock: NobjcObject): number;
+export declare function MIDIDestinationCreateWithBlock(client: number, name: Uint8Array, outDest: NobjcObject, readBlock: (arg0: NobjcObject, arg1: NobjcObject) => void): number;
+export declare function MIDIDestinationCreateWithProtocol(client: number, name: Uint8Array, protocol: NobjcObject, outDest: NobjcObject, readBlock: (arg0: NobjcObject, arg1: NobjcObject) => void): number;
 export declare function MIDIDeviceAddEntity(device: number, name: Uint8Array, embedded: NobjcObject, numSourceEndpoints: number, numDestinationEndpoints: number, newEntity: NobjcObject): number;
 export declare function MIDIDeviceCreate(owner: NobjcObject | null, name: Uint8Array, manufacturer: Uint8Array, model: Uint8Array, outDevice: NobjcObject): number;
 export declare function MIDIDeviceDispose(device: number): number;
@@ -48,8 +48,8 @@ export declare function MIDIGetSerialPortDrivers(outDriverNames: NobjcObject | n
 export declare function MIDIGetSerialPortOwner(portName: Uint8Array, outDriverName: NobjcObject | null): number;
 export declare function MIDIGetSource(sourceIndex0: number): number;
 export declare function MIDIInputPortCreate(client: number, portName: Uint8Array, readProc: NobjcObject, refCon: Uint8Array | null, outPort: NobjcObject): number;
-export declare function MIDIInputPortCreateWithBlock(client: number, portName: Uint8Array, outPort: NobjcObject, readBlock: NobjcObject): number;
-export declare function MIDIInputPortCreateWithProtocol(client: number, portName: Uint8Array, protocol: NobjcObject, outPort: NobjcObject, receiveBlock: NobjcObject): number;
+export declare function MIDIInputPortCreateWithBlock(client: number, portName: Uint8Array, outPort: NobjcObject, readBlock: (arg0: NobjcObject, arg1: NobjcObject) => void): number;
+export declare function MIDIInputPortCreateWithProtocol(client: number, portName: Uint8Array, protocol: NobjcObject, outPort: NobjcObject, receiveBlock: (arg0: NobjcObject, arg1: NobjcObject) => void): number;
 export declare function MIDIObjectFindByUniqueID(inUniqueID: number, outObject: NobjcObject | null, outObjectType: NobjcObject | null): number;
 export declare function MIDIObjectGetDataProperty(obj: number, propertyID: Uint8Array, outData: NobjcObject | null): number;
 export declare function MIDIObjectGetDictionaryProperty(obj: number, propertyID: Uint8Array, outDict: NobjcObject | null): number;

package/dist/CoreMIDI/functions.js

@@ -10,7 +10,7 @@ export function MIDIClientCreate(name, notifyProc, notifyRefCon, outClient) {
     return callFunction("MIDIClientCreate", { returns: "i", args: ["^", "@", "^v", "@"] }, name, notifyProc, notifyRefCon, outClient);
 }
 export function MIDIClientCreateWithBlock(name, outClient, notifyBlock) {
-    return callFunction("MIDIClientCreateWithBlock", { returns: "i", args: ["^", "@", "@"] }, name, outClient, notifyBlock);
+    return callFunction("MIDIClientCreateWithBlock", { returns: "i", args: ["^", "@", "@?"] }, name, outClient, notifyBlock);
 }
 export function MIDIClientDispose(client) {
     return callFunction("MIDIClientDispose", { returns: "i", args: ["I"] }, client);
@@ -19,10 +19,10 @@ export function MIDIDestinationCreate(client, name, readProc, refCon, outDest) {
     return callFunction("MIDIDestinationCreate", { returns: "i", args: ["I", "^", "@", "^v", "@"] }, client, name, readProc, refCon, outDest);
 }
 export function MIDIDestinationCreateWithBlock(client, name, outDest, readBlock) {
-    return callFunction("MIDIDestinationCreateWithBlock", { returns: "i", args: ["I", "^", "@", "@"] }, client, name, outDest, readBlock);
+    return callFunction("MIDIDestinationCreateWithBlock", { returns: "i", args: ["I", "^", "@", "@?"] }, client, name, outDest, readBlock);
 }
 export function MIDIDestinationCreateWithProtocol(client, name, protocol, outDest, readBlock) {
-    return callFunction("MIDIDestinationCreateWithProtocol", { returns: "i", args: ["I", "^", "@", "@", "@"] }, client, name, protocol, outDest, readBlock);
+    return callFunction("MIDIDestinationCreateWithProtocol", { returns: "i", args: ["I", "^", "@", "@", "@?"] }, client, name, protocol, outDest, readBlock);
 }
 export function MIDIDeviceAddEntity(device, name, embedded, numSourceEndpoints, numDestinationEndpoints, newEntity) {
     return callFunction("MIDIDeviceAddEntity", { returns: "i", args: ["I", "^", "C", "L", "L", "@"] }, device, name, embedded, numSourceEndpoints, numDestinationEndpoints, newEntity);
@@ -148,10 +148,10 @@ export function MIDIInputPortCreate(client, portName, readProc, refCon, outPort)
     return callFunction("MIDIInputPortCreate", { returns: "i", args: ["I", "^", "@", "^v", "@"] }, client, portName, readProc, refCon, outPort);
 }
 export function MIDIInputPortCreateWithBlock(client, portName, outPort, readBlock) {
-    return callFunction("MIDIInputPortCreateWithBlock", { returns: "i", args: ["I", "^", "@", "@"] }, client, portName, outPort, readBlock);
+    return callFunction("MIDIInputPortCreateWithBlock", { returns: "i", args: ["I", "^", "@", "@?"] }, client, portName, outPort, readBlock);
 }
 export function MIDIInputPortCreateWithProtocol(client, portName, protocol, outPort, receiveBlock) {
-    return callFunction("MIDIInputPortCreateWithProtocol", { returns: "i", args: ["I", "^", "@", "@", "@"] }, client, portName, protocol, outPort, receiveBlock);
+    return callFunction("MIDIInputPortCreateWithProtocol", { returns: "i", args: ["I", "^", "@", "@", "@?"] }, client, portName, protocol, outPort, receiveBlock);
 }
 export function MIDIObjectFindByUniqueID(inUniqueID, outObject, outObjectType) {
     return callFunction("MIDIObjectFindByUniqueID", { returns: "i", args: ["i", "@", "@"] }, inUniqueID, outObject, outObjectType);

package/dist/CoreMIDI/index.d.ts

@@ -60,4 +60,3 @@ export type { _MIDIUMPMutableFunctionBlock };
 import type { _MIDICIProfileResponderDelegate } from "./MIDICIProfileResponderDelegate.js";
 export type { _MIDICIProfileResponderDelegate };
 export { MIDINetworkConnectionPolicy } from "./MIDINetworkConnectionPolicy.js";
-export * from "./functions.js";

package/dist/CoreMIDI/index.js

@@ -22,4 +22,3 @@ export const MIDIUMPFunctionBlock = _bindClass(CoreMIDI, "MIDIUMPFunctionBlock")
 export const MIDIUMPMutableEndpoint = _bindClass(CoreMIDI, "MIDIUMPMutableEndpoint");
 export const MIDIUMPMutableFunctionBlock = _bindClass(CoreMIDI, "MIDIUMPMutableFunctionBlock");
 export { MIDINetworkConnectionPolicy } from "./MIDINetworkConnectionPolicy.js";
-export * from "./functions.js";

package/dist/CoreML/MLComputePlan.d.ts

@@ -1,4 +1,4 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 import type { _MLComputePlanCost } from "./MLComputePlanCost.js";
@@ -15,11 +15,11 @@ export declare class _MLComputePlan extends _NSObject {
     /**
      * Construct the compute plan of a model asynchronously given the location of its on-disk representation. @param url The location of its on-disk representation (.mlmodelc directory). @param configuration The model configuration. @param handler When the compute plan is constructed successfully or unsuccessfully, the completion handler is invoked with a valid MLComputePlan instance or NSError object.
      */
-    static loadContentsOfURL$configuration$completionHandler$(url: _NSURL, configuration: _MLModelConfiguration, handler: NobjcObject | null): void;
+    static loadContentsOfURL$configuration$completionHandler$(url: _NSURL, configuration: _MLModelConfiguration, handler: ((computePlan: _MLComputePlan, error: _NSError) => void) | null): void;
     /**
      * Construct the compute plan of a model asynchronously given the model asset. @param asset The model asset. @param configuration The model configuration. @param handler When the compute plan is constructed successfully or unsuccessfully, the completion handler is invoked with a valid MLComputePlan instance or NSError object.
      */
-    static loadModelAsset$configuration$completionHandler$(asset: _MLModelAsset, configuration: _MLModelConfiguration, handler: NobjcObject | null): void;
+    static loadModelAsset$configuration$completionHandler$(asset: _MLModelAsset, configuration: _MLModelConfiguration, handler: ((computePlan: _MLComputePlan, error: _NSError) => void) | null): void;
     /**
      * Returns the estimated cost of executing an ML Program operation. @param operation An ML Program operation. @returns The estimated cost of executing the operation or nil if the cost couldn't be estimated.
      */

package/dist/CoreML/MLModel.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 import type { _MLArrayBatchProvider } from "./MLArrayBatchProvider.js";
@@ -25,11 +26,11 @@ export declare class _MLModel extends _NSObject {
     /**
      * Construct a model asynchronously given the location of its on-disk representation and configuration. Model loading may take time when the model content is not immediately available (e.g. encrypted model). Use this factory method especially when the caller is on the main thread. @param url the location of its on-disk representation (.mlmodelc directory). @param configuration The model configuration @param handler When the model load completes successfully or unsuccessfully, the completion handler is invoked with a valid MLModel instance or NSError object.
      */
-    static loadContentsOfURL$configuration$completionHandler$(url: _NSURL, configuration: _MLModelConfiguration, handler: NobjcObject | null): void;
+    static loadContentsOfURL$configuration$completionHandler$(url: _NSURL, configuration: _MLModelConfiguration, handler: ((model: _MLModel, error: _NSError) => void) | null): void;
     /**
      * Construct a model asynchronously from a compiled model asset. @param asset Compiled model asset derived from in-memory or on-disk Core ML model @param configuration Model configuration that hold options for loading a model @param handler When the model load completes successfully or unsuccessfully, the completion handler is invoked with a valid MLModel instance or NSError object.
      */
-    static loadModelAsset$configuration$completionHandler$(asset: _MLModelAsset, configuration: _MLModelConfiguration, handler: NobjcObject | null): void;
+    static loadModelAsset$configuration$completionHandler$(asset: _MLModelAsset, configuration: _MLModelConfiguration, handler: ((model: _MLModel, error: _NSError) => void) | null): void;
     /**
      * Compile a .mlmodel for this device @param modelURL URL file path to .mlmodel file you wish to compile @param error Any errors are surfaced here @returns a URL to the compiled .mlmodelc directory if successful The model is compiled to a temporary location on disk You must move the compiled model to a permanent location if you wish to keep it @discussion The returned model can be loaded using: @code [MLModel modelWithContentsOfURL:error:] @endcode
      * @deprecated Use the asynchronous interface compileModelAtURL:completionHandler:error: instead.
@@ -38,7 +39,7 @@ export declare class _MLModel extends _NSObject {
     /**
      * Compile a .mlmodel or .mlpackage for this device. Perform the compilation asynchronously. @param modelURL URL file path to .mlmodel file you wish to compile @param handler When the model compilation completes successfully the completion handler is invoked with a valid URL to the compiled .mlmodelc directory. On failure, signified by nil compiledModelURL, the NSError object is populated. @discussion The model is compiled to a temporary location in the file system. You must move the compiled model to a permanent location if you wish to keep it. Then the model can be loaded using the returned URL: @code [MLModel modelWithContentsOfURL:error:] @endcode
      */
-    static compileModelAtURL$completionHandler$(modelURL: _NSURL, handler: NobjcObject | null): void;
+    static compileModelAtURL$completionHandler$(modelURL: _NSURL, handler: ((compiledModelURL: _NSURL, error: _NSError) => void) | null): void;
     /**
      * The list of available compute devices for CoreML. Use the method to get the list of compute devices that MLModel's prediction can use. Some compute devices on the hardware are exclusive to the domain ML frameworks such as Vision and SoundAnalysis and not available to CoreML. See also `MLComputeDevice.allComputeDevices`.
      */
@@ -54,11 +55,11 @@ export declare class _MLModel extends _NSObject {
     /**
      * Run a prediction on a model asynchronously. This is a convenience overload method of `prediction(from:options:) async` that uses the default prediction options. - Parameters - input: The input features to make a prediction from. - completionHandler: A block that will be invoked once the prediction has completed successfully or unsuccessfully. On success, it is invoked with a valid model output. On failure, it is invoked with a nil output and NSError
      */
-    predictionFromFeatures$completionHandler$(input: _MLFeatureProvider, completionHandler: NobjcObject | null): void;
+    predictionFromFeatures$completionHandler$(input: _MLFeatureProvider, completionHandler: ((output: _MLFeatureProvider, error: _NSError) => void) | null): void;
     /**
      * Run a prediction on a model asynchronously. - Parameters - input: The input features to make a prediction from. - options: Prediction options to modify how the prediction is run. - completionHandler: A block that will be invoked once the prediction has completed successfully or unsuccessfully. On success, it is invoked with a valid model output. On failure, it is invoked with a nil output and NSError
      */
-    predictionFromFeatures$options$completionHandler$(input: _MLFeatureProvider, options: _MLPredictionOptions, completionHandler: NobjcObject | null): void;
+    predictionFromFeatures$options$completionHandler$(input: _MLFeatureProvider, options: _MLPredictionOptions, completionHandler: ((output: _MLFeatureProvider, error: _NSError) => void) | null): void;
     /** Batch prediction without explicit options */
     predictionsFromBatch$error$(inputBatch: _MLBatchProvider, error: NobjcObject | null): _MLArrayBatchProvider | null;
     /** Batch prediction with explicit options */
@@ -80,7 +81,7 @@ export declare class _MLModel extends _NSObject {
     /**
      * Run a stateful prediction asynchronously. Use this method to run predictions on a stateful model. Do not request a prediction while another prediction that shares the same state is in-flight, otherwise the behavior is undefined. ```swift let state = model.newState() let prediction = try await model.prediction(from: inputFeatures, using: state) ``` - Parameters - input: The input features to make a prediction from. - state: The state object created by `newState()` method. - options: Prediction options to modify how the prediction is run. - completionHandler: A block that will be invoked once the prediction has completed successfully or unsuccessfully. On success, it is invoked with a valid model output. On failure, it is invoked with a nil output and NSError
      */
-    predictionFromFeatures$usingState$options$completionHandler$(inputFeatures: _MLFeatureProvider, state: _MLState, options: _MLPredictionOptions, completionHandler: NobjcObject | null): void;
+    predictionFromFeatures$usingState$options$completionHandler$(inputFeatures: _MLFeatureProvider, state: _MLState, options: _MLPredictionOptions, completionHandler: ((output: _MLFeatureProvider, error: _NSError) => void) | null): void;
     /** A model holds a description of its required inputs and expected outputs. */
     modelDescription(): _MLModelDescription;
     /** The load-time parameters used to instantiate this MLModel object. */

package/dist/CoreML/MLModelAsset.d.ts

@@ -1,9 +1,12 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSData } from "../Foundation/NSData.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 { _MLModelDescription } from "./MLModelDescription.js";
 export declare class _MLModelAsset extends _NSObject {
     static alloc(): _MLModelAsset;
     static new(): _MLModelAsset;
@@ -23,13 +26,13 @@ export declare class _MLModelAsset extends _NSObject {
     /**
      * The default model descripton. Use this method to get the description of the model such as the feature descriptions, the model author, and other metadata. For the multi-function model asset, this method vends the description for the default function. Use `modelDescription(for:)` to get the model description of other functions. ```swift let modelAsset = try MLModelAsset(url: modelURL) let modelDescription = try await modelAsset.modelDescription() print(modelDescription) ```
      */
-    modelDescriptionWithCompletionHandler$(handler: NobjcObject | null): void;
+    modelDescriptionWithCompletionHandler$(handler: ((modelDescription: _MLModelDescription, error: _NSError) => void) | null): void;
     /**
      * The model descripton for a specified function. Use this method to get the description of the model such as the feature descriptions, the model author, and other metadata. ```swift let modelAsset = try MLModelAsset(url: modelURL) let modelDescription = try await modelAsset.modelDescription(of: "my_function") print(modelDescription) ```
      */
-    modelDescriptionOfFunctionNamed$completionHandler$(functionName: _NSString, handler: NobjcObject | null): void;
+    modelDescriptionOfFunctionNamed$completionHandler$(functionName: _NSString, handler: ((modelDescription: _MLModelDescription, error: _NSError) => void) | null): void;
     /**
      * The list of function names in the model asset. Some model types (e.g. ML Program) supports multiple functions. Use this method to query the function names. The method vends the empty array when the model doesn't use the multi-function configuration. ```swift let modelAsset = try MLModelAsset(url: modelURL) let functionNames = try await modelAsset.functionNames print(functionNames) // For example, ["my_function1", "my_function2"]; ```
      */
-    functionNamesWithCompletionHandler$(handler: NobjcObject | null): void;
+    functionNamesWithCompletionHandler$(handler: ((functionNames: _NSArray, error: _NSError) => void) | null): void;
 }