objcjs-types 0.3.0 → 0.5.0

package/dist/EventKit/EKEventStore.d.ts

@@ -1,6 +1,7 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDate } from "../Foundation/NSDate.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSPredicate } from "../Foundation/NSPredicate.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -29,19 +30,19 @@ export declare class _EKEventStore extends _NSObject {
      * @method initWithSources: @abstract Creates a new event store that only includes items and calendars for a subset of sources. @param sources The sources you want this event store to recognize. This may include delegate sources.
      */
     initWithSources$(sources: _NSArray): _EKEventStore;
-    requestFullAccessToEventsWithCompletion$(completion: NobjcObject): void;
+    requestFullAccessToEventsWithCompletion$(completion: (arg0: boolean, arg1: _NSError) => void): void;
     /**
      * @deprecated Use -requestFullAccessToEventsWithCompletion:, -requestWriteOnlyAccessToEventsWithCompletion:, or -requestFullAccessToRemindersWithCompletion:
      */
-    requestWriteOnlyAccessToEventsWithCompletion$(completion: NobjcObject): void;
+    requestWriteOnlyAccessToEventsWithCompletion$(completion: (arg0: boolean, arg1: _NSError) => void): void;
     /**
      * @deprecated Use -requestFullAccessToEventsWithCompletion:, -requestWriteOnlyAccessToEventsWithCompletion:, or -requestFullAccessToRemindersWithCompletion:
      */
-    requestFullAccessToRemindersWithCompletion$(completion: NobjcObject): void;
+    requestFullAccessToRemindersWithCompletion$(completion: (arg0: boolean, arg1: _NSError) => void): void;
     /**
      * @deprecated Use -requestFullAccessToEventsWithCompletion:, -requestWriteOnlyAccessToEventsWithCompletion:, or -requestFullAccessToRemindersWithCompletion:
      */
-    requestAccessToEntityType$completion$(entityType: EKEntityType, completion: NobjcObject): void;
+    requestAccessToEntityType$completion$(entityType: EKEntityType, completion: (arg0: boolean, arg1: _NSError) => void): void;
     /**
      * @method sourceWithIdentifier: @abstract Returns a source with a specified identifier.
      */
@@ -98,7 +99,7 @@ export declare class _EKEventStore extends _NSObject {
     /**
      * @method enumerateEventsMatchingPredicate:usingBlock: @abstract Searches for events that match the given predicate. @discussion This call executes a search for the events indicated by the predicate passed to it, calling the block specified in the callback parameter for each event. This method is synchronous. If you want async behavior, you should either use dispatch_async or NSOperation to run the query someplace other than the main thread. @param predicate The predicate to invoke. If this predicate was not created with the predicate creation functions in this class, an exception is raised. @param block The block to call for each event. Your block should return YES in the stop parameter to stop iterating.
      */
-    enumerateEventsMatchingPredicate$usingBlock$(predicate: _NSPredicate, block: NobjcObject): void;
+    enumerateEventsMatchingPredicate$usingBlock$(predicate: _NSPredicate, block: (arg0: _EKEvent, arg1: NobjcObject) => void): void;
     /**
      * @method predicateForEventsWithStartDate:endDate:calendars: @abstract Creates a predicate for use with eventsMatchingPredicate or enumerateEventsMatchingPredicate:usingBlock:. @discussion Creates a simple query predicate to search for events within a certain date range. At present, this will return events in the default time zone ([NSTimeZone defaultTimeZone]). For performance reasons, this method will only return events within a four year timespan. If the date range between the startDate and endDate is greater than four years, then it will be shortened to the first four years. @param startDate The start date. @param endDate The end date. @param calendars The calendars to search for events in, or nil to search all calendars.
      */
@@ -114,7 +115,7 @@ export declare class _EKEventStore extends _NSObject {
     /**
      * @method fetchRemindersMatchingPredicate:completion: @abstract Fetches reminders asynchronously. @discussion This method fetches reminders asynchronously and returns a value which can be used in cancelFetchRequest: to cancel the request later if desired. The completion block is called with an array of reminders that match the given predicate (or potentially nil).
      */
-    fetchRemindersMatchingPredicate$completion$(predicate: _NSPredicate, completion: NobjcObject | null): NobjcObject;
+    fetchRemindersMatchingPredicate$completion$(predicate: _NSPredicate, completion: ((reminders: _NSArray) => void) | null): NobjcObject;
     /**
      * @method cancelFetchRequest: @discussion Given a value returned from fetchRemindersMatchingPredicate, this method can be used to cancel the request. Once called, the completion block specified in fetchReminders... will not be called.
      */

package/dist/EventKit/EKVirtualConferenceProvider.d.ts

@@ -1,7 +1,9 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSExtensionRequestHandling } from "../Foundation/NSExtensionRequestHandling.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
+import type { _EKVirtualConferenceDescriptor } from "./EKVirtualConferenceDescriptor.js";
 export declare class _EKVirtualConferenceProvider extends _NSObject {
     static alloc(): _EKVirtualConferenceProvider;
     static new(): _EKVirtualConferenceProvider;
@@ -9,11 +11,11 @@ export declare class _EKVirtualConferenceProvider extends _NSObject {
     /**
      * @method fetchAvailableRoomTypesWithCompletionHandler: @abstract Called to determine the available virtual conference room types that the user can add to a calendar event. @discussion Your extension must override this method in order to present virtual conference options in Calendar's UI. When your extension has finished determining what room types are available, call the completion handler with an array of EKVirtualConferenceRoomTypeDescriptors. Most extensions will only need to provide one room type. @param completionHandler A block to call when your extension has finished retrieving available room types. If your extension is unable to provide any room types at this time, call this block with nil for the first argument and an appropriate NSError object for the second argument. Do not call this block with nil for both arguments. Similarly, do not call this block with both a non-nil array and a non-nil NSError. This block must be called when your extension has finished its work.
      */
-    fetchAvailableRoomTypesWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    fetchAvailableRoomTypesWithCompletionHandler$(completionHandler: ((arg0: _NSArray, arg1: _NSError) => void) | null): void;
     /**
      * @method fetchVirtualConferenceForIdentifier:completionHandler: @abstract Called to fetch the specific virtual conference details to add to an event. @discussion Your extension must override this method in order to add virtual conferences to calendar events. When your extension has finished retrieving the requested virtual conference details, create an EKVirtualConferenceDescriptor object containing the virtual conference details and call the completion handler with the EKVirtualConferenceDescriptor object as the first argument. @param identifier Represents the room type that the user chose. This is the same identifier that your extension chose for this EKVirtualConferenceRoomTypeDescriptor in an earlier call to fetchAvailableRoomTypesWithCompletionHandler:. @param completionHandler A block to call when your extension has finished retrieving the virtual conference details. If your extension is unable to retrieve virtual conference details at this time (for example, because network access is not available), call this block with nil for the first argument and an appropriate NSError object for the second argument. Do not call this block with nil for both arguments. Similarly, do not call this block with both a non-nil EKVirtualConferenceDescriptor and a non-nil NSError. This block must be called when your extension has finished its work.
      */
-    fetchVirtualConferenceForIdentifier$completionHandler$(identifier: _NSString, completionHandler: NobjcObject | null): void;
+    fetchVirtualConferenceForIdentifier$completionHandler$(identifier: _NSString, completionHandler: ((arg0: _EKVirtualConferenceDescriptor, arg1: _NSError) => void) | null): void;
 }
 export interface _EKVirtualConferenceProvider extends _NSExtensionRequestHandling {
 }

package/dist/ExceptionHandling/index.d.ts

@@ -3,4 +3,3 @@ export declare const ExceptionHandling: NobjcLibrary;
 import type { _NSExceptionHandler } from "./NSExceptionHandler.js";
 export declare const NSExceptionHandler: typeof _NSExceptionHandler;
 export type { _NSExceptionHandler };
-export * from "./functions.js";

package/dist/ExceptionHandling/index.js

@@ -3,4 +3,3 @@ import { NobjcLibrary } from "objc-js";
 import { _bindClass } from "../bind.js";
 export const ExceptionHandling = new NobjcLibrary("/System/Library/Frameworks/ExceptionHandling.framework/ExceptionHandling");
 export const NSExceptionHandler = _bindClass(ExceptionHandling, "NSExceptionHandler");
-export * from "./functions.js";

package/dist/ExecutionPolicy/EPDeveloperTool.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { EPDeveloperToolStatus } from "./EPDeveloperToolStatus.js";
 export declare class _EPDeveloperTool extends _NSObject {
@@ -11,7 +10,7 @@ export declare class _EPDeveloperTool extends _NSObject {
     /**
      * Checks whether developer tool privileges are already available and if not populates an entry in Settings for user approval. This method does not show any UI to the user or guide them towards Settings for approval, if necessary. - Parameter handler: A block called asynchronously with whether the privilege is available. > New info > Concurrency Note: You can call this method from synchronous code using a completion handler, > as shown on this page, or you can call it as an asynchronous method that has the > following declaration: > > ```swift > func requestAccess() async -> Bool > ``` > > For information about concurrency and asynchronous code in Swift, see <doc ://com.apple.documentation/documentation/swift/calling-objective-c-apis-asynchronously>.
      */
-    requestDeveloperToolAccessWithCompletionHandler$(handler: NobjcObject): void;
+    requestDeveloperToolAccessWithCompletionHandler$(handler: (granted: boolean) => void): void;
     /**
      * The current authorization status of the current process. - Returns: An EPDeveloperToolStatus indicating whether the current process has developer tool privileges.
      */

package/dist/ExecutionPolicy/EPError.d.ts

@@ -0,0 +1,5 @@
+export declare const EPError: {
+    readonly Generic: 1;
+    readonly NotADeveloperTool: 2;
+};
+export type EPError = typeof EPError[keyof typeof EPError];

package/dist/ExecutionPolicy/EPError.js

@@ -0,0 +1,5 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const EPError = {
+    Generic: 1,
+    NotADeveloperTool: 2,
+};

package/dist/ExecutionPolicy/index.d.ts

@@ -7,3 +7,4 @@ import type { _EPExecutionPolicy } from "./EPExecutionPolicy.js";
 export declare const EPExecutionPolicy: typeof _EPExecutionPolicy;
 export type { _EPExecutionPolicy };
 export { EPDeveloperToolStatus } from "./EPDeveloperToolStatus.js";
+export { EPError } from "./EPError.js";

package/dist/ExecutionPolicy/index.js

@@ -5,3 +5,4 @@ export const ExecutionPolicy = new NobjcLibrary("/System/Library/Frameworks/Exec
 export const EPDeveloperTool = _bindClass(ExecutionPolicy, "EPDeveloperTool");
 export const EPExecutionPolicy = _bindClass(ExecutionPolicy, "EPExecutionPolicy");
 export { EPDeveloperToolStatus } from "./EPDeveloperToolStatus.js";
+export { EPError } from "./EPError.js";

package/dist/ExternalAccessory/EAAccessoryManager.d.ts

@@ -1,4 +1,5 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSPredicate } from "../Foundation/NSPredicate.js";
 export declare class _EAAccessoryManager extends _NSObject {
@@ -6,7 +7,7 @@ export declare class _EAAccessoryManager extends _NSObject {
     static new(): _EAAccessoryManager;
     init(): _EAAccessoryManager;
     static sharedAccessoryManager(): _EAAccessoryManager;
-    showBluetoothAccessoryPickerWithNameFilter$completion$(predicate: _NSPredicate | null, completion: NobjcObject | null): void;
+    showBluetoothAccessoryPickerWithNameFilter$completion$(predicate: _NSPredicate | null, completion: ((arg0: _NSError) => void) | null): void;
     registerForLocalNotifications(): void;
     unregisterForLocalNotifications(): void;
     connectedAccessories(): NobjcObject;

package/dist/FSKit/FSBlockDeviceResource.d.ts

@@ -1,6 +1,7 @@
 import type { NobjcObject } from "objc-js";
 import type { _FSResource } from "./FSResource.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSString } from "../Foundation/NSString.js";
 export declare class _FSBlockDeviceResource extends _FSResource {
     static alloc(): _FSBlockDeviceResource;
@@ -9,7 +10,7 @@ export declare class _FSBlockDeviceResource extends _FSResource {
     /**
      * Reads data from the resource into a buffer and executes a block afterwards. For the read to succeed, requests must conform to any transfer requirements of the underlying resource. Disk drives typically require sector (`physicalBlockSize`) addressed operations of one or more sector-aligned offsets. - Parameters: - buffer: A buffer to receive the data. - offset: The offset into the resource from which to start reading. - length: A maximum number of bytes to read. The completion handler receives a parameter with the actual number of bytes read. - completionHandler: A block that executes after the read operation completes. If successful, the first parameter contains the number of bytes actually read. In the case of an error, the second parameter contains a non-`nil` error. This value is `EFAULT` if `buffer` is `NULL`, or `errno` if reading from the resource failed.
      */
-    readInto$startingAt$length$completionHandler$(buffer: Uint8Array, offset: NobjcObject, length: number, completionHandler: NobjcObject | null): void;
+    readInto$startingAt$length$completionHandler$(buffer: Uint8Array, offset: NobjcObject, length: number, completionHandler: ((actuallyRead: number, error: _NSError) => void) | null): void;
     /**
      * Synchronously reads data from the resource into a buffer. This is a synchronous version of ``readInto:startingAt:length:completionHandler:``. > Note: In some cases, this method performs a partial read. In this case, the return value is shorter than the requested length, and the `error` is set to `nil`. - Parameters: - buffer: A buffer to receive the data. - offset: The offset into the resource from which to start reading. - length: A maximum number of bytes to read. The method's return value contains the actual number of bytes read. - error: On return, any error encountered while reading data, or `nil` if no error occurred. - Returns: The actual number of bytes read.
      */
@@ -17,7 +18,7 @@ export declare class _FSBlockDeviceResource extends _FSResource {
     /**
      * Writes data from from a buffer to the resource and executes a block afterwards. For the write to succeed, requests must conform to any transfer requirements of the underlying resource. Disk drives typically require sector (`physicalBlockSize`) addressed operations of one or more sector-aligned offsets. - Parameters: - buffer: A buffer to provide the data. - offset: The offset into the resource from which to start writing. - length: A maximum number of bytes to write. The completion handler receives a parameter with the actual number of bytes write. - completionHandler: A block that executes after the write operation completes. If successful, the first parameter contains the number of bytes actually written. In the case of an error, the second parameter contains a non-`nil` error. This value is `EFAULT` if `buffer` is `NULL`, or `errno` if writing to the resource failed.
      */
-    writeFrom$startingAt$length$completionHandler$(buffer: Uint8Array, offset: NobjcObject, length: number, completionHandler: NobjcObject | null): void;
+    writeFrom$startingAt$length$completionHandler$(buffer: Uint8Array, offset: NobjcObject, length: number, completionHandler: ((actuallyWritten: number, error: _NSError) => void) | null): void;
     /**
      * Synchronously writes data from from a buffer to the resource and executes a block afterwards. This is a synchronous version of ``writeFrom:startingAt:length:completionHandler:``. > Note: In some cases, this method performs a partial write. In this case, the return value is shorter than the requested length, and the `error` is set to `nil`. - Parameters: - buffer: A buffer to provide the data. - offset: The offset into the resource from which to start writing. - length: A maximum number of bytes to write. The completion handler receives a parameter with the actual number of bytes write. - error: On return, any error encountered while writing data, or `nil` if no error occurred. - Returns: The actual number of bytes written.
      */

package/dist/FSKit/FSClient.d.ts

@@ -1,4 +1,5 @@
-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";
 export declare class _FSClient extends _NSObject {
     static alloc(): _FSClient;
@@ -9,5 +10,5 @@ export declare class _FSClient extends _NSObject {
     /**
      * Asynchronously retrieves an list of installed file system modules. In Swift, you can either call this method and pass a completion handler closure, or get the value of the `installedExtensions` property with the `async` keyword. - Parameter completionHandler: A block or closure that executes when FSKit finishes its fetch process. If the fetch succeeds, the first parameter contains an array of ``FSModuleIdentity`` instances that identify installed modules. If the fetch fails, the second parameter contains an error detailing the failure.
      */
-    fetchInstalledExtensionsWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    fetchInstalledExtensionsWithCompletionHandler$(completionHandler: ((arg0: _NSArray, arg1: _NSError) => void) | null): void;
 }

package/dist/FSKit/FSErrorCode.d.ts

@@ -0,0 +1,10 @@
+export declare const FSErrorCode: {
+    readonly FSErrorModuleLoadFailed: 4500;
+    readonly FSErrorResourceUnrecognized: 4501;
+    readonly FSErrorResourceDamaged: 4502;
+    readonly FSErrorResourceUnusable: 4503;
+    readonly FSErrorStatusOperationInProgress: 4504;
+    readonly FSErrorStatusOperationPaused: 4505;
+    readonly FSErrorInvalidDirectoryCookie: 4506;
+};
+export type FSErrorCode = typeof FSErrorCode[keyof typeof FSErrorCode];

package/dist/FSKit/FSErrorCode.js

@@ -0,0 +1,10 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const FSErrorCode = {
+    FSErrorModuleLoadFailed: 4500,
+    FSErrorResourceUnrecognized: 4501,
+    FSErrorResourceDamaged: 4502,
+    FSErrorResourceUnusable: 4503,
+    FSErrorStatusOperationInProgress: 4504,
+    FSErrorStatusOperationPaused: 4505,
+    FSErrorInvalidDirectoryCookie: 4506,
+};

package/dist/FSKit/FSFileSystemBase.d.ts

@@ -1,11 +1,11 @@
-import type { NobjcObject } from "objc-js";
 import type { _FSBlockDeviceResource } from "./FSBlockDeviceResource.js";
 import type { _FSContainerStatus } from "./FSContainerStatus.js";
+import type { _NSError } from "../Foundation/NSError.js";
 export interface _FSFileSystemBase {
     /**
      * Wipes existing file systems on the specified resource. This method wraps the `wipefs` functionality from `libutil`. For more information, see the `man` page for `wipefs`. - Parameters: - resource: The ``FSBlockDeviceResource`` to wipe. - completion: A block or closure that executes after the wipe operation completes. The completion handler receives a single parameter indicating any error that occurs during the operation. If the value is `nil`, the wipe operation succeeded.
      */
-    wipeResource$completionHandler$?(resource: _FSBlockDeviceResource, completion: NobjcObject | null): void;
+    wipeResource$completionHandler$?(resource: _FSBlockDeviceResource, completion: ((error: _NSError) => void) | null): void;
     /**
      * The status of the file system container, indicating its readiness and activity. A file system container starts in the ``FSContainerState/notReady`` state, and then transitions to the other values of the ``FSContainerState`` enumeration. The following diagram illustrates the possible state transitions. ![A flow diagram of four possible container states. The initial state, notReady, can transition to ready or blocked. The ready state can transition back to not ready, or to blocked or active. The blocked state can transition to ready or not ready. The active state can transition back to ready or to not ready.](fs-file-system-base) Your file system implementation updates this property as it changes state. Many events and operations may trigger a state transition, and some transitions depend on a specific file system's design. When using ``FSBlockDeviceResource``, implement the following common state transitions: * Calling `loadResource` transitions the state out of ``FSContainerState/notReady``. For all block device file systems, this operation changes the state to either ``FSContainerState/ready`` or ``FSContainerState/blocked``. * Calling `unloadResource` transitions to the ``FSContainerState/notReady`` state, as does device termination. * Transitioning from ``FSContainerState/blocked`` to ``FSContainerState/ready`` occurs as a result of resolving the underlying block favorably. * Transitioning from ``FSContainerState/ready`` to ``FSContainerState/blocked`` is unusal, but valid. * Transitioning between ``FSContainerState/ready`` and ``FSContainerState/active`` can result from maintenance operations such as ``FSManageableResourceMaintenanceOperations/startCheckWithTask:options:error:``. For a ``FSUnaryFileSystem``, this transition can also occur when activating or deactivating the container's single volume.
      */

package/dist/FSKit/FSOperationID.d.ts

@@ -0,0 +1,2 @@
+export declare const FSOperationID: {};
+export type FSOperationID = typeof FSOperationID[keyof typeof FSOperationID];

package/dist/FSKit/FSOperationID.js

@@ -0,0 +1,2 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const FSOperationID = {};

package/dist/FSKit/FSTask.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -17,6 +16,6 @@ export declare class _FSTask extends _NSObject {
     /**
      * A handler called by FSKit upon canceling the task. FSKit calls the cancellation handler within an independent execution context. If the handler can't complete its work successfully, it can return an error from the block or closure. FSKit logs any returned error and then terminates all activity in the container. The task object clears its `cancellationHandler` property after the task's cancellation or completion. This helps accelerate the cleanup of retained state. The exact structuring of the completion handler depends on the structuring of the code imlementing the task. As a concrete example, consider a check operation with the following class: @TabNavigator { @Tab("Objective-C") { ```obj-c @‎‌interface YourFileSystem : NSObject @property (retain) dispatch_group_t work_group; @property (nonatomic,getter=interrupted) BOOL interrupted; @end ``` } @Tab("Swift") { ```swift class YourFileSystem { let work_group: dispatch_group_t = DispatchGroup() var interrupted: Bool = false private lazy var leaveWorkGroupOnce = leaveWorkGroup() } ``` } } and a `startCheckWithTask` method with a helper method `performCheck` like the following: @TabNavigator { @Tab("Objective-C") { ```obj-c - (void)performCheck:(nonnull FSTask *)task progress:(nonnull NSProgress *)progress context:(YourFileSystemCancelationContext *)context { // See discussion for notes on implementing this method. } - (NSProgress * _Nullable)startCheckWithTask:(nonnull FSTask *)task options:(nonnull FSTaskOptions *)options error:(NSError *__autoreleasing _Nullable * _Nullable)error { dispatch_queue_t someQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); NSProgress *progress = [[NSProgress alloc] init]; YourFileSystemCancelationContext *checker= [[YourFileSystemCancelationContext alloc] init]; dispatch_group_enter(checker.work_group); [task setCancellationHandler:^NSError * _Nullable{ checker.interrupted = YES; dispatch_group_wait(checker.work_group, DISPATCH_TIME_FOREVER); return nil; }]; dispatch_async(someQueue, ^{[self performCheck:task progress:progress context:checker];}); return progress; } ``` } @Tab("Swift") { ```swift func performCheck(task: FSTask, progress: Progress, context: YourFileSystemCancelationContext) { // See discussion for notes on implementing this method. } func startCheck(task: FSTask, options: FSTaskOptions) throws -> Progress { let someQueue = DispatchQueue.global() let progress = Progress() let checkContext = YourFileSystemCancelationContext() checkContext.work_group.enter() task.cancellationHandler = { checkContext.interrupted = true checkContext.work_group.wait() return nil } someQueue.async { self.performCheck(task: task, progress: progress, context:checkContext) } return progress } ``` } } When canceled, the handler block in this example sets the checker's `interrupted` property, and then calls the <doc://com.apple.documentation/documentation/dispatch/dispatchgroup> method <doc://com.apple.documentation/documentation/dispatch/dispatchgroup/wait()> (Swift) or the function <doc://com.apple.documentation/documentation/dispatch/1452794-dispatch_group_wait> (Objective-C) on the checker's work group. Because neither of these operations can fail, the handler returns `nil` to indicate it didn't encounter an error. For simplicity, this example doesn't account for errors, whereas production code must do so. Furthermore, when fully implemented, the `performCheck` method should perform a check operation. Specifically, it should periodically update the progress object and check its `interrupted` variable. The check can either complete successfully, complete with an error, or enter the interrupted state. It should then call ``FSTask/didComplete(error:)`` wtih the appropriate error value or `nil`. Finally it should call `context.work_group.leave()` (Swift) or `dispatch_group_leave(context.work_group)` (Objective-C) to remove itself from its dispatch group.
      */
-    cancellationHandler(): NobjcObject | null;
-    setCancellationHandler$(value: NobjcObject | null): void;
+    cancellationHandler(): (() => _NSError) | null;
+    setCancellationHandler$(value: (() => _NSError) | null): void;
 }

package/dist/FSKit/FSUnaryFileSystemOperations.d.ts

@@ -1,19 +1,21 @@
-import type { NobjcObject } from "objc-js";
+import type { _FSProbeResult } from "./FSProbeResult.js";
 import type { _FSResource } from "./FSResource.js";
 import type { _FSTaskOptions } from "./FSTaskOptions.js";
+import type { _FSVolume } from "./FSVolume.js";
+import type { _NSError } from "../Foundation/NSError.js";
 export interface _FSUnaryFileSystemOperations {
     /**
      * Requests that the file system probe the specified resource. Implement this method to indicate whether the resource is recognizable and usable. - Parameters: - resource: The ``FSResource`` to probe. - reply: A block or closure that your implementation invokes when it finishes the probe or encounters an error. Pass an instance of ``FSProbeResult`` with probe results as the first parameter if your probe operation succeeds. If probing fails, pass an error as the second parameter.
      */
-    probeResource$replyHandler$?(resource: _FSResource, reply: NobjcObject | null): void;
+    probeResource$replyHandler$?(resource: _FSResource, reply: ((result: _FSProbeResult, error: _NSError) => void) | null): void;
     /**
      * Requests that the file system load a resource and present it as a volume. Implement this method by inspecting the provided resource and verifying it uses a supported format. If the resource does use a supported format, create a subclass of `FSVolume`, clear the container error state, and invoke the `reply` callback, passing your volume as a parameter. If loading can't proceed, invoke `reply` and send an appropriate error as the second parameter. - Parameters: - resource: An ``FSResource`` to load. - options: An ``FSTaskOptions`` object specifying options to apply when loading the resource. An ``FSUnaryFileSystem`` supports two options: `-f` for "force" and `--rdonly` for read-only. The file system must remember if the read-only option is present. - reply: A block or closure that your implementation invokes when it finishes setting up or encounters an error. Pass a subclass of `FSVolume` as the first parameter if loading succeeds. If loading fails, pass an error as the second parameter.
      */
-    loadResource$options$replyHandler$?(resource: _FSResource, options: _FSTaskOptions, reply: NobjcObject | null): void;
+    loadResource$options$replyHandler$?(resource: _FSResource, options: _FSTaskOptions, reply: ((volume: _FSVolume, err: _NSError) => void) | null): void;
     /**
      * Requests that the file system unload the specified resource. - Parameters: - resource: An ``FSResource`` to unload. - options: An ``FSTaskOptions`` object specifying options to apply when unloading the resource. - reply: A block or closure that your implementation invokes when it finishes unloading or encounters an error. If unloading fails, pass an error as the parameter to describe the problem. Otherwise, pass `nil`.
      */
-    unloadResource$options$replyHandler$?(resource: _FSResource, options: _FSTaskOptions, reply: NobjcObject | null): void;
+    unloadResource$options$replyHandler$?(resource: _FSResource, options: _FSTaskOptions, reply: ((err: _NSError) => void) | null): void;
     /**
      * Notifies you that the system finished loading your file system extension. The system performs this callback after the main run loop starts and before receiving the first message from the FSKit daemon. Implement this method if you want to perform any setup prior to receiving FSKit callbacks.
      */

package/dist/FSKit/FSVolumeAccessCheckOperations.d.ts

@@ -1,11 +1,11 @@
-import type { NobjcObject } from "objc-js";
 import type { _FSItem } from "./FSItem.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { FSAccessMask } from "./FSAccessMask.js";
 export interface _FSVolumeAccessCheckOperations {
     /**
      * Checks whether the file system allows access to the given item. - Parameters: - theItem: The item for which to check access. - access: A mask indicating a set of access types for which to check. - reply: A block or closure to indicate success or failure. If the access check succeeds, pass a Boolean value to indicate whether the file system grants access, followed by a `nil` error. If the access check fails, pass the relevant error as the second parameter; FSKit ignores the Boolean parameter in this case. For an `async` Swift implementation, there's no reply handler; simply return the `Bool` or throw an error.
      */
-    checkAccessToItem$requestedAccess$replyHandler$?(theItem: _FSItem, access: FSAccessMask, reply: NobjcObject | null): void;
+    checkAccessToItem$requestedAccess$replyHandler$?(theItem: _FSItem, access: FSAccessMask, reply: ((shouldAllowAccess: boolean, error: _NSError) => void) | null): void;
     /**
      * A Boolean value that instructs FSKit not to call this protocol's methods, even if the volume conforms to it. FSKit reads this value after the file system replies to the `loadResource` message. Changing the returned value during the runtime of the volume has no effect.
      */

package/dist/FSKit/FSVolumeItemDeactivation.d.ts

@@ -1,11 +1,11 @@
-import type { NobjcObject } from "objc-js";
 import type { _FSItem } from "./FSItem.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { FSItemDeactivationOptions } from "./FSItemDeactivationOptions.js";
 export interface _FSVolumeItemDeactivation {
     /**
      * Notifies the file system that the kernel is no longer making immediate use of the given item. This method gives a file system a chance to release resources associated wtih an item. However, this method prescribes no specific action; it's acceptable to defer all reclamation until ``FSVolume/Operations/reclaimItem(_:replyHandler:)``. This method is the equivalent of VFS's `VNOP_INACTIVE`. FSKit restricts calls to this method based on the current value of ``FSVolume/ItemDeactivation/itemDeactivationPolicy``. - Parameters: - item: The item to deactivate. - reply: A block or closure to indicate success or failure. If deactivation fails, pass an error as the one parameter to the reply handler. If deactivation succeeds, pass `nil`. For an `async` Swift implementation, there's no reply handler; simply throw an error or return normally.
      */
-    deactivateItem$replyHandler$?(item: _FSItem, reply: NobjcObject | null): void;
+    deactivateItem$replyHandler$?(item: _FSItem, reply: ((error: _NSError) => void) | null): void;
     /**
      * A property that tells FSKit to which types of items the deactivation applies, if any. FSKit reads this value after the file system replies to the `loadResource` message. Changing the returned value during the runtime of the volume has no effect.
      */

package/dist/FSKit/FSVolumeKernelOffloadedIOOperations.d.ts

@@ -6,26 +6,27 @@ import type { _FSItemSetAttributesRequest } from "./FSItemSetAttributesRequest.j
 import type { _NSError } from "../Foundation/NSError.js";
 import type { FSBlockmapFlags } from "./FSBlockmapFlags.js";
 import type { FSCompleteIOFlags } from "./FSCompleteIOFlags.js";
+import type { FSOperationID } from "./FSOperationID.js";
 import type { FSPreallocateFlags } from "./FSPreallocateFlags.js";
 export interface _FSVolumeKernelOffloadedIOOperations {
     /**
      * Maps a file's disk space into extents, allowing the kernel to perform I/O with that space. FSKit calls this method when the kernel needs to get a mapping of logical-to-physical offsets of the file's data. This call may occur as part of an I/O operation on the file, or just to get the mapping as part of a `fcntl(F_LOG2PHYS)` system call. In the case of an I/O operation on the file, `operationID` has a nonzero value; a future call to ``completeIO(for:offset:length:status:flags:operationID:replyHandler:)`` uses the same `operationID` to indicate which operation it completes. In the case of a `fcntl(F_LOG2PHYS)` system call, the `operationID` parameter is `0` (Objective-C) or ``FSOperationID/unspecified`` (Swift). In both cases the kernel retains the mapping, and it may perform I/O to this range (or a part of it) at any time. If satisfying a blockmap request requires more extents than `packer` can handle, FSKit makes additional calls to this method with the same operation ID to collect the remainder. - Parameters: - file: The file for which to map disk space. - offset: The starting logical offset of the range to be mapped (in bytes). - length: The length of the range to be mapped (in bytes). - flags: Flags that affect the behavior of the blockmap operation. - operationID: A unique identifier of the blockmap call. Any value other than `0` (Objective-C) or ``FSOperationID/unspecified`` (Swift) indicates the beginning of an I/O operation. A value of `0` or ``FSOperationID/unspecified`` indicates the kernel maps the file without performing I/O. In this case, FSKit doesn't perform a corresponding call to ``completeIO(for:offset:length:status:flags:operationID:replyHandler:)``. - packer: An extent packer you use to pack the requested range of the file's allocated disk space. FSKit sends all of the packed extents to the kernel when it invokes `reply`. - reply: A block or closure to indicate success or failure. If mapping fails, pass an error as the one parameter to the reply handler. If mapping succeeds, pass `nil`. For an `async` Swift implementation, there's no reply handler; simply throw an error or return normally.
      */
-    blockmapFile$offset$length$flags$operationID$packer$replyHandler$?(file: _FSItem, offset: NobjcObject, length: number, flags: FSBlockmapFlags, operationID: number, packer: _FSExtentPacker, reply: NobjcObject | null): void;
+    blockmapFile$offset$length$flags$operationID$packer$replyHandler$?(file: _FSItem, offset: NobjcObject, length: number, flags: FSBlockmapFlags, operationID: FSOperationID, packer: _FSExtentPacker, reply: ((error: _NSError) => void) | null): void;
     /**
      * Completes an I/O operation for a given file. Implement this method by updating a file's metadata, such as its size and modification time. FSKit may call this method without an earlier call to ``blockmapFile(_:offset:length:flags:operationID:packer:replyHandler:)``. In this case, the `operationID` is `0` (Objective-C) or ``FSOperationID/unspecified`` (Swift). - Parameters: - file: The file for which the I/O operation completed. - offset: The starting logical offset at which I/O started. - length: The length of the I/O range (in bytes). - status: Any error that occurred during the operation. If no error occurred, this parameter is `nil`. - flags: Flags that affect the behavior of the complete I/O operation. - operationID: A unique identifier of the blockmap call. Any value other than `0` (Objective-C) or ``FSOperationID/unspecified`` (Swift) corresponds to a previous call to ``blockmapFile(_:offset:length:flags:operationID:packer:replyHandler:)`` with the same `operationID`. - reply: A block or closure to indicate success or failure. If completing I/O fails, pass an error as the one parameter to the reply handler. If completing I/O succeeds, pass `nil`. For an `async` Swift implementation, there's no reply handler; simply throw an error or return normally.
      */
-    completeIOForFile$offset$length$status$flags$operationID$replyHandler$?(file: _FSItem, offset: NobjcObject, length: number, status: _NSError, flags: FSCompleteIOFlags, operationID: number, reply: NobjcObject | null): void;
+    completeIOForFile$offset$length$status$flags$operationID$replyHandler$?(file: _FSItem, offset: NobjcObject, length: number, status: _NSError, flags: FSCompleteIOFlags, operationID: FSOperationID, reply: ((error: _NSError) => void) | null): void;
     /**
      * Creates a new file item and map its disk space. This method allows the module to opportunistically supply extents, avoiding future calls to ``blockmapFile(_:offset:length:flags:operationID:packer:replyHandler:)``. Only perform this technique opportunistically. In particular, don't perform additional I/O to fetch extent data. Packing extents in this method requires that `attributes` defines a size greater than 0. An implementation that doesn't supply the extents can ignore the packer and call the corresponding method in the ``FSVolume/Operations`` protocol, ``FSVolume/Operations/createItem(named:type:inDirectory:attributes:replyHandler:)``. - Parameters: - name: The new file's name. - directory: The directory in which to create the file. - attributes: Attributes to apply to the new file. - packer: An extent packer you use to pack the file's allocated disk space. - reply: A block or closure to indicate success or failure. If creation succeeds, pass the newly created ``FSItem`` and its ``FSFileName``, along with a `nil` error. If creation fails, pass the relevant error as the third parameter; FSKit ignores any ``FSItem`` or ``FSFileName`` in this case. For an `async` Swift implementation, there's no reply handler; instead, return a tuple of the ``FSItem`` and its ``FSFileName`` or throw an error.
      */
-    createFileNamed$inDirectory$attributes$packer$replyHandler$?(name: _FSFileName, directory: _FSItem, attributes: _FSItemSetAttributesRequest, packer: _FSExtentPacker, reply: NobjcObject | null): void;
+    createFileNamed$inDirectory$attributes$packer$replyHandler$?(name: _FSFileName, directory: _FSItem, attributes: _FSItemSetAttributesRequest, packer: _FSExtentPacker, reply: ((newFile: _FSItem, newFileName: _FSFileName, error: _NSError) => void) | null): void;
     /**
      * Looks up an item within a directory and maps its disk space. This method allows the module to opportunistically supply extents, avoiding future calls to ``blockmapFile(_:offset:length:flags:operationID:packer:replyHandler:)``. Only perform this technique opportunistically. In particular, don't perform additional I/O to fetch extent data. - Parameters: - name: The name of the file to look up. - directory: The directory in which to look up the file. - packer: An extent packer you use to pack the file's allocated disk space. - reply: A block or closure to indicate success or failure. If lookup succeeds, pass the found ``FSItem`` and its ``FSFileName``, along with a `nil` error. If lookup fails, pass the relevant error as the third parameter; FSKit ignores any ``FSItem`` or ``FSFileName`` in this case. For an `async` Swift implementation, there's no reply handler; instead, return a tuple of the ``FSItem`` and its ``FSFileName`` or throw an error.
      */
-    lookupItemNamed$inDirectory$packer$replyHandler$?(name: _FSFileName, directory: _FSItem, packer: _FSExtentPacker, reply: NobjcObject | null): void;
+    lookupItemNamed$inDirectory$packer$replyHandler$?(name: _FSFileName, directory: _FSItem, packer: _FSExtentPacker, reply: ((theItem: _FSItem, itemName: _FSFileName, error: _NSError) => void) | null): void;
     /**
      * Preallocates and maps disk space for the given file. This method allows the module to opportunistically supply extents, avoiding future calls to ``blockmapFile(_:offset:length:flags:operationID:packer:replyHandler:)``. > Important: Only implement this method if your file system conforms to ``FSVolume/PreallocateOperations``. - Parameters: - file: The item for which to preallocate space. - offset: The offset from which to allocate. - length: The length of the space in bytes. - flags: Flags that affect the preallocation behavior. - packer: An extent packer you use to pack the file's preallocated disk space. - reply: A block or closure to indicate success or failure. If preallocation succeeds, pass the amount of bytes allocated and a nil error. If preallocation fails, pass the relevant error as the second parameter; FSKit ignores any byte count in this case. For an `async` Swift implementation, there’s no reply handler; simply return the allocated byte count or throw an error.
      */
-    preallocateSpaceForFile$atOffset$length$flags$packer$replyHandler$?(file: _FSItem, offset: NobjcObject, length: number, flags: FSPreallocateFlags, packer: _FSExtentPacker, reply: NobjcObject | null): void;
+    preallocateSpaceForFile$atOffset$length$flags$packer$replyHandler$?(file: _FSItem, offset: NobjcObject, length: number, flags: FSPreallocateFlags, packer: _FSExtentPacker, reply: ((bytesAllocated: number, error: _NSError) => void) | null): void;
 }

package/dist/FSKit/FSVolumeOpenCloseOperations.d.ts

@@ -1,15 +1,15 @@
-import type { NobjcObject } from "objc-js";
 import type { _FSItem } from "./FSItem.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { FSVolumeOpenModes } from "./FSVolumeOpenModes.js";
 export interface _FSVolumeOpenCloseOperations {
     /**
      * Opens a file for access. - Parameters: - item: The item to open. - modes: The set of mode flags to open the item with. - reply: A block or closure to indicate success or failure. If opening fails, pass an error as the one parameter to the reply handler. If opening succeeds, pass `nil`. For an `async` Swift implementation, there's no reply handler; simply throw an error or return normally.
      */
-    openItem$withModes$replyHandler$?(item: _FSItem, modes: FSVolumeOpenModes, reply: NobjcObject | null): void;
+    openItem$withModes$replyHandler$?(item: _FSItem, modes: FSVolumeOpenModes, reply: ((error: _NSError) => void) | null): void;
     /**
      * Closes a file from further access. - Parameters: - item: The item to close. - modes: The set of mode flags to keep after this close. - reply: A block or closure to indicate success or failure. If closing fails, pass an error as the one parameter to the reply handler. If closing succeeds, pass `nil`. For an `async` Swift implementation, there's no reply handler; simply throw an error or return normally.
      */
-    closeItem$keepingModes$replyHandler$?(item: _FSItem, modes: FSVolumeOpenModes, reply: NobjcObject | null): void;
+    closeItem$keepingModes$replyHandler$?(item: _FSItem, modes: FSVolumeOpenModes, reply: ((error: _NSError) => void) | null): void;
     /**
      * A Boolean value that instructs FSKit not to call this protocol's methods, even if the volume conforms to it. FSKit reads this value after the file system replies to the `loadResource` message. Changing the returned value during the runtime of the volume has no effect.
      */

package/dist/FSKit/FSVolumeOperations.d.ts

@@ -1,13 +1,14 @@
-import type { NobjcObject } from "objc-js";
 import type { _FSDirectoryEntryPacker } from "./FSDirectoryEntryPacker.js";
 import type { _FSFileName } from "./FSFileName.js";
 import type { _FSItem } from "./FSItem.js";
+import type { _FSItemAttributes } from "./FSItemAttributes.js";
 import type { _FSItemGetAttributesRequest } from "./FSItemGetAttributesRequest.js";
 import type { _FSItemSetAttributesRequest } from "./FSItemSetAttributesRequest.js";
 import type { _FSStatFSResult } from "./FSStatFSResult.js";
 import type { _FSTaskOptions } from "./FSTaskOptions.js";
 import type { _FSVolumePathConfOperations } from "./FSVolumePathConfOperations.js";
 import type { _FSVolumeSupportedCapabilities } from "./FSVolumeSupportedCapabilities.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { FSDeactivateOptions } from "./FSDeactivateOptions.js";
 import type { FSItemType } from "./FSItemType.js";
 import type { FSSyncFlags } from "./FSSyncFlags.js";
@@ -15,67 +16,67 @@ export interface _FSVolumeOperations extends _FSVolumePathConfOperations {
     /**
      * Mounts this volume, using the specified options. FSKit calls this method as a signal that some process is trying to mount this volume. Your file system receives a call to ``activate(options:replyHandler:)`` prior to receiving any mount calls. - Parameters: - options: Options to apply to the mount. These can include security-scoped file paths. There are no defined options currently. - reply: A block or closure to indicate success or failure. If mounting fails, pass an error as the one parameter to the reply handler. If mounting succeeds, pass `nil`. For an `async` Swift implementation, there's no reply handler; simply return normally.
      */
-    mountWithOptions$replyHandler$?(options: _FSTaskOptions, reply: NobjcObject | null): void;
+    mountWithOptions$replyHandler$?(options: _FSTaskOptions, reply: ((error: _NSError) => void) | null): void;
     /**
      * Unmounts this volume. Clear and flush all cached state in your implementation of this method. - Parameters: - reply: A block or closure to indicate success or failure. If unmounting fails, pass an error as the one parameter to the reply handler. If unmounting succeeds, pass `nil`. For an `async` Swift implementation, there's no reply handler; simply return normally.
      */
-    unmountWithReplyHandler$?(reply: NobjcObject): void;
+    unmountWithReplyHandler$?(reply: () => void): void;
     /**
      * Synchronizes the volume with its underlying resource. After calling this method, FSKit assumes that the volume has sent all pending I/O or metadata to its resource. - Parameters: - flags: Timing flags, as defined in `mount.h.` These flags let the file system know whether to run the operation in a blocking or nonblocking fashion. - reply: A block or closure to indicate success or failure. If synchronization fails, pass an error as the one parameter to the reply handler. If synchronization succeeds, pass `nil`. For an `async` Swift implementation, there's no reply handler; simply throw an error or return normally.
      */
-    synchronizeWithFlags$replyHandler$?(flags: FSSyncFlags, reply: NobjcObject | null): void;
+    synchronizeWithFlags$replyHandler$?(flags: FSSyncFlags, reply: ((error: _NSError) => void) | null): void;
     /**
      * Fetches attributes for the given item. For file systems that don't support hard links, set ``FSItemAttributes/linkCount`` to `1` for regular files and symbolic links. If the item's `bsdFlags` contain the `UF_COMPRESSED` flag, your file system returns the uncompressed size of the file. - Parameters: - desiredAttributes: A requested set of attributes to get. The implementation inspects the request's ``FSItemGetAttributesRequest/wantedAttributes`` to determine which attributes to populate. - item: The item to get attributes for. - reply: A block or closure to indicate success or failure. If getting attributes succeeds, pass an ``FSItemAttributes`` with the requested attributes populated and a `nil` error. If getting attributes fails, pass the relevant error as the second parameter; FSKit ignores any ``FSItemAttributes`` in this case. For an `async` Swift implementation, there's no reply handler; simply return the ``FSItemAttributes`` or throw an error.
      */
-    getAttributes$ofItem$replyHandler$?(desiredAttributes: _FSItemGetAttributesRequest, item: _FSItem, reply: NobjcObject | null): void;
+    getAttributes$ofItem$replyHandler$?(desiredAttributes: _FSItemGetAttributesRequest, item: _FSItem, reply: ((attributes: _FSItemAttributes, error: _NSError) => void) | null): void;
     /**
      * Sets the given attributes on an item. Several attributes are considered "read-only", and an attempt to set these attributes results in an error with the code `EINVAL`. A request may set ``FSItem/Attributes/size`` beyond the end of the file. If the underlying file system doesn't support sparse files, allocate space to fill the new file size. Either fill this space with zeroes, or configure it to read as zeroes. If a request sets the file size below the current end-of-file, truncate the file and return any unused space to the file system as free space. Ignore attempts to set the size of directories or symbolic links; don't produce an error. If the caller attepts to sest an attribute not supported by the on-disk file system format, don't produce an error. The upper layers of the framework will detect this situation. - Parameters: - newAttributes: A request containing the attributes to set. - item: The item on which to set the attributes. - reply: A block or closure to indicate success or failure. If setting attributes succeeds, pass an ``FSItemAttributes`` with the item's updated attributes and a `nil` error. If setting attributes fails, pass the relevant error as the second parameter; FSKit ignores any ``FSItemAttributes`` in this case. For an `async` Swift implementation, there's no reply handler; simply return the ``FSItemAttributes`` or throw an error.
      */
-    setAttributes$onItem$replyHandler$?(newAttributes: _FSItemSetAttributesRequest, item: _FSItem, reply: NobjcObject | null): void;
+    setAttributes$onItem$replyHandler$?(newAttributes: _FSItemSetAttributesRequest, item: _FSItem, reply: ((attributes: _FSItemAttributes, error: _NSError) => void) | null): void;
     /**
      * Looks up an item within a directory. If no item matching `name` exists in the directory indicated by `directory`, complete the request with an error with a domain of <doc://com.apple.documentation/documentation/Foundation/NSPOSIXErrorDomain> and a code of `ENOENT`. > Tip: The ``FSFileName`` sent back to the caller may differ from the `name` parameter. This flexibility allows your implementation to handle case-insensitive and case-sensitive file systems. It might also be the case that `name` uses a composed Unicode string, but the name maintained by the file system and provided to the caller is uncomposed Unicode. - Parameters: - name: The name of the item to look up. - directory: The directory in which to look up the item. - reply: A block or closure to indicate success or failure. If lookup succeeds, pass the found ``FSItem`` and its ``FSFileName`` (as saved within the file system), along with a `nil` error. If lookup fails, pass the relevant error as the third parameter; any ``FSItem`` or ``FSFileName`` are ignored in this case. For an `async` Swift implementation, there's no reply handler; simply return the ``FSItem`` and ``FSFileName`` as a tuple or throw an error.
      */
-    lookupItemNamed$inDirectory$replyHandler$?(name: _FSFileName, directory: _FSItem, reply: NobjcObject | null): void;
+    lookupItemNamed$inDirectory$replyHandler$?(name: _FSFileName, directory: _FSItem, reply: ((theItem: _FSItem, itemName: _FSFileName, error: _NSError) => void) | null): void;
     /**
      * Reclaims an item, releasing any resources allocated for the item. FSKit guarantees that for every ``FSItem`` returned by the volume, a corresponding reclaim operation occurs after the upper layers no longer reference that item. > Note: Block device file systems may assess whether an underyling resource terminates before processing reclaim operations. On unary file systems, for example, the associated volumes unmount when such resources disconnect from the system. The unmount triggers a reclaiming of all items. Some implementations benefit greatly from short-circuiting in such cases. With a terminated resource, all I/O results in an error, making short-circuiting the most efficient response. - Parameters: - item: The item to reclaim. - reply: A block or closure to indicate success or failure. If removal fails, pass an error as the one parameter to the reply handler. If removal succeeds, pass `nil`. For an `async` Swift implementation, there's no reply handler; simply throw an error or return normally.
      */
-    reclaimItem$replyHandler$?(item: _FSItem, reply: NobjcObject | null): void;
+    reclaimItem$replyHandler$?(item: _FSItem, reply: ((error: _NSError) => void) | null): void;
     /**
      * Reads a symbolic link. - Parameters: - item: The symbolic link to read from. FSKit guarantees this item is of type ``FSItem/ItemType/symlink``. - reply: A block or closure to indicate success or failure. If reading succeeds, pass the link's contents as an ``FSFileName`` and a `nil` error. If reading fails, pass the relevant error as the second parameter; FSKit ignores any ``FSFileName`` in this case. For an `async` Swift implementation, there's no reply handler; simply return the ``FSFileName`` or throw an error.
      */
-    readSymbolicLink$replyHandler$?(item: _FSItem, reply: NobjcObject | null): void;
+    readSymbolicLink$replyHandler$?(item: _FSItem, reply: ((contents: _FSFileName, error: _NSError) => void) | null): void;
     /**
      * Creates a new file or directory item. If an item named `name` already exists in the directory indicated by `directory`, complete the request with an error with a domain of <doc://com.apple.documentation/documentation/Foundation/NSPOSIXErrorDomain> and a code of `EEXIST`. - Parameters: - name: The new item's name. - type: The new item's type. Valid values are ``FSItem/ItemType/file`` or ``FSItem/ItemType/directory``. - directory: The directory in which to create the item. - newAttributes: Attributes to apply to the new item. - reply: A block or closure to indicate success or failure. If creation succeeds, pass the newly-created ``FSItem`` and its ``FSFileName``, along with a `nil` error. If creation fails, pass the relevant error as the third parameter; FSKit ignores any ``FSItem`` or ``FSFileName`` in this case. For an `async` Swift implementation, there's no reply handler; simply return a tuple of the ``FSItem`` and its ``FSFileName`` or throw an error.
      */
-    createItemNamed$type$inDirectory$attributes$replyHandler$?(name: _FSFileName, type: FSItemType, directory: _FSItem, newAttributes: _FSItemSetAttributesRequest, reply: NobjcObject | null): void;
+    createItemNamed$type$inDirectory$attributes$replyHandler$?(name: _FSFileName, type: FSItemType, directory: _FSItem, newAttributes: _FSItemSetAttributesRequest, reply: ((newItem: _FSItem, newItemName: _FSFileName, error: _NSError) => void) | null): void;
     /**
      * Creates a new symbolic link. If an item named `name` already exists in the directory indicated by `directory`, complete the request with an error with a domain of <doc://com.apple.documentation/documentation/Foundation/NSPOSIXErrorDomain> and a code of `EEXIST`. - Parameters: - name: The new item's name. - directory: The directory in which to create the item. - newAttributes: Attributes to apply to the new item. - contents: The contents of the new symbolic link. - reply: A block or closure to indicate success or failure. If creation succeeds, pass the newly-created ``FSItem`` and a `nil` error. If creation fails, pass the relevant error as the second parameter; FSKit ignores any ``FSItem`` in this case. For an `async` Swift implementation, there's no reply handler; simply return the ``FSItem`` or throw an error.
      */
-    createSymbolicLinkNamed$inDirectory$attributes$linkContents$replyHandler$?(name: _FSFileName, directory: _FSItem, newAttributes: _FSItemSetAttributesRequest, contents: _FSFileName, reply: NobjcObject | null): void;
+    createSymbolicLinkNamed$inDirectory$attributes$linkContents$replyHandler$?(name: _FSFileName, directory: _FSItem, newAttributes: _FSItemSetAttributesRequest, contents: _FSFileName, reply: ((newItem: _FSItem, newItemName: _FSFileName, error: _NSError) => void) | null): void;
     /**
      * Creates a new hard link. If creating the link fails, complete the request with an error with a domain of <doc://com.apple.documentation/documentation/Foundation/NSPOSIXErrorDomain> and the following error codes: * `EEXIST` if there's already an item named `name` in the directory. * `EMLINK` if creating the link would exceed the maximum number of hard links supported on `item`. * `ENOTSUP` if the file system doesn't support creating hard links to the type of file system object that `item` represents. - Parameters: - item: The existing item to which to link. - name: The name for the new link. - directory: The directory in which to create the link. - reply: A block or closure to indicate success or failure. If creation succeeds, pass an ``FSFileName`` of the newly-created link and a `nil` error. If creation fails, pass the relevant error as the second parameter; FSKit ignores any ``FSFileName`` in this case. For an `async` Swift implementation, there's no reply handler; simply return the ``FSFileName`` or throw an error.
      */
-    createLinkToItem$named$inDirectory$replyHandler$?(item: _FSItem, name: _FSFileName, directory: _FSItem, reply: NobjcObject | null): void;
+    createLinkToItem$named$inDirectory$replyHandler$?(item: _FSItem, name: _FSFileName, directory: _FSItem, reply: ((linkName: _FSFileName, error: _NSError) => void) | null): void;
     /**
      * Removes an existing item from a given directory. Don't actually remove the item object itself in your implementation; instead, only remove the given item name from the given directory. Remove and deallocate the item in ``reclaimItem(_:replyHandler:)``. - Parameters: - item: The item to remove. - name: The name of the item to remove. - directory: The directory from which to remove the item. - reply: A block or closure to indicate success or failure. If removal fails, pass an error as the one parameter to the reply handler. If removal succeeds, pass `nil`. For an `async` Swift implementation, there's no reply handler; simply throw an error or return normally.
      */
-    removeItem$named$fromDirectory$replyHandler$?(item: _FSItem, name: _FSFileName, directory: _FSItem, reply: NobjcObject | null): void;
+    removeItem$named$fromDirectory$replyHandler$?(item: _FSItem, name: _FSFileName, directory: _FSItem, reply: ((error: _NSError) => void) | null): void;
     /**
      * Renames an item from one path in the file system to another. Implement renaming along the lines of this algorithm: - If `item` is a file: - If the destination file exists: - Remove the destination file. - If the source and destination directories are the same: - Rewrite the name in the existing directory. - Else: - Write the new entry in the destination directory. - Clear the old directory entry. - If `item` is a directory: - If the destination directory exists: - If the destination directory isn't empty: - Fail the operation with an error of <doc://com.apple.documentation/documentation/Foundation/NSPOSIXErrorDomain> and a code of `ENOTEMPTY`. - Else: - Remove the destination directory. - If the source and destination directories are the same: - Rewrite the name in the existing directory. - Else: - If the destination is a child of the source directory: - Fail the operation with an error. - Else: - Write the new entry in the destination directory. - Update `"."` and `".."` in the moved directory. - Clear the old directory entry. - Parameters: - item: The file system object being renamed. - sourceDirectory: The directory that currently contains the item to rename. - sourceName: The name of the item within the source directory. - destinationName: The new name of the item as it appears in `destinationDirectory`. - destinationDirectory: The directory to contain the renamed object, which may be the same as `sourceDirectory`. - overItem: The file system object if the destination exists, as discovered in a prior lookup. If this parameter is non-`nil`, mark `overItem` as deleted, so the file system can free its allocated space on the next call to ``reclaimItem(_:replyHandler:)``. After doing so, ensure the operation finishes without errors. - reply: A block or closure to indicate success or failure. If renaming succeeds, pass the ``FSFileName`` as it exists within `destinationDirectory` and a `nil` error. If renaming fails, pass the relevant error as the second parameter; FSKit ignores any ``FSFileName`` in this case. For an `async` Swift implementation, there's no reply handler; simply return the ``FSFileName`` or throw an error.
      */
-    renameItem$inDirectory$named$toNewName$inDirectory$overItem$replyHandler$?(item: _FSItem, sourceDirectory: _FSItem, sourceName: _FSFileName, destinationName: _FSFileName, destinationDirectory: _FSItem, overItem: _FSItem | null, reply: NobjcObject | null): void;
+    renameItem$inDirectory$named$toNewName$inDirectory$overItem$replyHandler$?(item: _FSItem, sourceDirectory: _FSItem, sourceName: _FSFileName, destinationName: _FSFileName, destinationDirectory: _FSItem, overItem: _FSItem | null, reply: ((newName: _FSFileName, error: _NSError) => void) | null): void;
     /**
      * Enumerates the contents of the given directory. This method uses the ``FSDirectoryEntryPacker/packEntry(name:itemType:itemID:nextCookie:attributes:)`` method of the `packer` parameter to deliver the enumerated items to the caller. The general flow of an enumeration implementation follows these steps: 1. Enumeration starts with a call to `enumerateDirectory` using the initial next-cookie and verifier values ``FSDirectoryCookieInitial`` and ``FSDirectoryVerifierInitial``, respectively. 2. The implementation uses `packer` to pack the initial set of directory entries. Packing also sets a `nextCookie` to use on the next call. 3. The implementation replies with a new verifier value, a nonzero value that reflects the directory's current version. 4. On the next call the implementation packs the next set of entries, starting with the item indicated by `cookie`. If `cookie` doesn't resolve to a valid directory entry, complete the request with an error of domain <doc://com.apple.documentation/documentation/Foundation/NSPOSIXErrorDomain> and code ``FSError/Code/invalidDirectoryCookie``. When packing, make sure to use acceptable directory entry names and unambiguous input to all file operations that take names without additional normalization, such as`lookupName`. > Tip: If the `attributes` parameter is `nil`, include at least two entries in a directory: `"."` and `".."`, which represent the current and parent directories, respectively. Both of these items have type ``FSItem/ItemType/directory``. For the root directory, `"."` and `".."` have identical contents. Don't pack `"."` and `".."` if `attributes` isn't `nil`. - Parameters: - directory: The item to enumerate. FSKit guarantees this item is of type ``FSItem/ItemType/directory``. - cookie: A value that indicates the location within the directory from which to enumerate. Your implementation defines the semantics of the cookie values; they're opaque to FSKit. The first call to the enumerate method passes ``FSDirectoryCookieInitial`` for this parameter. Subsequent calls pass whatever cookie value you previously passed to the packer's `nextCookie` parmeter. - verifier: A tool to detect whether the directory contents changed since the last call to `enumerateDirectory`. Your implementation defines the semantics of the verifier values; they're opaque to FSKit. The first call to the enumerate method passes ``FSDirectoryVerifierInitial`` for this parameter. Subsequent calls pass whatever cookie value you previously passed to the packer's `currentVerifier` parmeter. - attributes: The desired attributes to provide, or `nil` if the caller doesn't require attributes. - packer: An object that your implementation uses to enumerate directory items, packing one item per callback to `enumerateDirectory`. - reply: A block or closure to indicate success or failure. If enumeration succeeds, pass the current verifier and a `nil` error. If enumeration fails, pass the relevant error as the second parameter; FSKit ignores any verifier in this case. For an `async` Swift implementation, there's no reply handler; simply return the current verifier or throw an error.
      */
-    enumerateDirectory$startingAtCookie$verifier$providingAttributes$usingPacker$replyHandler$?(directory: _FSItem, cookie: number, verifier: number, attributes: _FSItemGetAttributesRequest | null, packer: _FSDirectoryEntryPacker, reply: NobjcObject | null): void;
+    enumerateDirectory$startingAtCookie$verifier$providingAttributes$usingPacker$replyHandler$?(directory: _FSItem, cookie: number, verifier: number, attributes: _FSItemGetAttributesRequest | null, packer: _FSDirectoryEntryPacker, reply: ((currentVerifier: number, error: _NSError) => void) | null): void;
     /**
      * Activates the volume using the specified options. When FSKit calls this method, allocate any in-memory state required to represent the file system. Also allocate an ``FSItem`` for the root directory of the file system, and pass it to the reply block. FSKit caches this root item for the lifetime of the volume, and uses it as a starting point for all file look-ups. Volume activation occurs prior to any call to mount the volume. - Parameters: - options: Options to apply to the activation. These can include security-scoped file paths. There are no defined options currently. - reply: A block or closure to indicate success or failure. If activation succeeds, pass the root ``FSItem`` and a `nil` error. If activation fails, pass the relevant error as the second parameter; FSKit ignores any ``FSItem`` in this case. In Swift, `reply` takes only the ``FSItem`` as the parameter; you signal any error with a `throw`. For an `async` Swift implementation, there's no reply handler; simply return the ``FSItem`` or throw an error.
      */
-    activateWithOptions$replyHandler$?(options: _FSTaskOptions, reply: NobjcObject | null): void;
+    activateWithOptions$replyHandler$?(options: _FSTaskOptions, reply: ((rootItem: _FSItem, err: _NSError) => void) | null): void;
     /**
      * Tears down a previously initialized volume instance. Set up your implementation to release any resources allocated for the volume instance. By the time you receive this callback, FSKit has already performed a reclaim call to release all other file nodes associated with this file system instance. Avoid performing any I/O in this method. Prior to calling this method, FSKit has already issued a sync call to perform any cleanup-related I/O. FSKit unmounts any mounted volume with a call to ``unmount(replyHandler:)`` prior to the deactivate callback. - Parameters: - options: Options to apply to the deactivation. - reply: A block or closure to indicate success or failure. If activation fails, pass an error as the one parameter to the reply handler. If activation succeeds, pass `nil`. For an `async` Swift implementation, there's no reply handler; simply throw an error or return normally.
      */
-    deactivateWithOptions$replyHandler$?(options: FSDeactivateOptions, reply: NobjcObject | null): void;
+    deactivateWithOptions$replyHandler$?(options: FSDeactivateOptions, reply: ((err: _NSError) => void) | null): void;
     /** A property that provides the supported capabilities of the volume. */
     supportedVolumeCapabilities?(): _FSVolumeSupportedCapabilities;
     /** A property that provides up-to-date statistics of the volume. */

package/dist/FSKit/FSVolumePreallocateOperations.d.ts

@@ -1,11 +1,12 @@
 import type { NobjcObject } from "objc-js";
 import type { _FSItem } from "./FSItem.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { FSPreallocateFlags } from "./FSPreallocateFlags.js";
 export interface _FSVolumePreallocateOperations {
     /**
      * Prealocates disk space for the given item. - Parameters: - item: The item for which to preallocate space. - offset: The offset from which to allocate. - length: The length of the space in bytes. - flags: Flags that affect the preallocation behavior. - reply: A block or closure to indicate success or failure. If preallocation succeeds, pass the amount of bytes allocated and a `nil` error. If preallocation fails, pass the relevant error as the second parameter; FSKit ignores any byte count in this case. For an `async` Swift implementation, there's no reply handler; simply return the allocated byte count or throw an error.
      */
-    preallocateSpaceForItem$atOffset$length$flags$replyHandler$?(item: _FSItem, offset: NobjcObject, length: number, flags: FSPreallocateFlags, reply: NobjcObject | null): void;
+    preallocateSpaceForItem$atOffset$length$flags$replyHandler$?(item: _FSItem, offset: NobjcObject, length: number, flags: FSPreallocateFlags, reply: ((bytesAllocated: number, error: _NSError) => void) | null): void;
     /**
      * A Boolean value that instructs FSKit not to call this protocol's methods, even if the volume conforms to it. FSKit reads this value after the file system replies to the `loadResource` message. Changing the returned value during the runtime of the volume has no effect.
      */

package/dist/FSKit/FSVolumeReadWriteOperations.d.ts

@@ -2,13 +2,14 @@ import type { NobjcObject } from "objc-js";
 import type { _FSItem } from "./FSItem.js";
 import type { _FSMutableFileDataBuffer } from "./FSMutableFileDataBuffer.js";
 import type { _NSData } from "../Foundation/NSData.js";
+import type { _NSError } from "../Foundation/NSError.js";
 export interface _FSVolumeReadWriteOperations {
     /**
      * Reads the contents of the given file item. If the number of bytes requested exceeds the number of bytes available before the end of the file, then the call copies only those bytes to `buffer`. If `offset` points past the last valid byte of the file, don't reply with an error but set `actuallyRead` to `0`. - Parameters: - item: The item from which to read. FSKit guarantees this item will be of type ``FSItem/ItemType/file``. - offset: The offset in the file from which to start reading. - length: The number of bytes to read. - buffer: A buffer to receive the bytes read from the file. - reply: A block or closure to indicate success or failure. If reading succeeds, pass the number of bytes read and a `nil` error. If reading fails, pass the number of bytes read prior to the error along with the relevant error. For an `async` Swift implementation, there's no reply handler; simply return the byte count or throw an error.
      */
-    readFromFile$offset$length$intoBuffer$replyHandler$?(item: _FSItem, offset: NobjcObject, length: number, buffer: _FSMutableFileDataBuffer, reply: NobjcObject | null): void;
+    readFromFile$offset$length$intoBuffer$replyHandler$?(item: _FSItem, offset: NobjcObject, length: number, buffer: _FSMutableFileDataBuffer, reply: ((actuallyRead: number, error: _NSError) => void) | null): void;
     /**
      * Writes contents to the given file item. FSKit expects this routine to allocate space in the file system to extend the file as necessary. If the volume experiences an out-of-space condition, reply with an error of domain <doc://com.apple.documentation/documentation/Foundation/NSPOSIXErrorDomain> and code `ENOSPC`. - Parameters: - contents: A buffer containing the data to write to the file. - item: The item to which to write. FSKit guarantees this item will be of type ``FSItem/ItemType/file``. - offset: The offset in the file from which to start writing. - reply: A block or closure to indicate success or failure. If writing succeeds, pass the number of bytes written and a `nil` error. If writing fails, pass the number of bytes written prior to the error along with the relevant error. For an `async` Swift implementation, there's no reply handler; simply return the byte count or throw an error.
      */
-    writeContents$toFile$atOffset$replyHandler$?(contents: _NSData, item: _FSItem, offset: NobjcObject, reply: NobjcObject | null): void;
+    writeContents$toFile$atOffset$replyHandler$?(contents: _NSData, item: _FSItem, offset: NobjcObject, reply: ((actuallyWritten: number, error: _NSError) => void) | null): void;
 }

package/dist/FSKit/FSVolumeRenameOperations.d.ts

@@ -1,10 +1,10 @@
-import type { NobjcObject } from "objc-js";
 import type { _FSFileName } from "./FSFileName.js";
+import type { _NSError } from "../Foundation/NSError.js";
 export interface _FSVolumeRenameOperations {
     /**
      * Sets a new name for the volume. - Parameters: - name: The new volume name. - reply: A block or closure to indicate success or failure. If renaming succeeds, pass an ``FSFileName`` of the new volume name and a `nil` error. If renaming fails, pass the relevant error as the second parameter; FSKit ignores any ``FSFileName`` in this case. For an `async` Swift implementation, there's no reply handler; simply return the ``FSFileName`` or throw an error.
      */
-    setVolumeName$replyHandler$?(name: _FSFileName, reply: NobjcObject | null): void;
+    setVolumeName$replyHandler$?(name: _FSFileName, reply: ((newName: _FSFileName, error: _NSError) => void) | null): void;
     /**
      * A Boolean value that instructs FSKit not to call this protocol's methods, even if the volume conforms to it. FSKit reads this value after the file system replies to the `loadResource` message. Changing the returned value during the runtime of the volume has no effect.
      */