objcjs-types 0.4.0 → 0.5.1

package/dist/CoreTelephony/CTCellularPlanProvisioning.d.ts

@@ -1,14 +1,15 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _CTCellularPlanProperties } from "./CTCellularPlanProperties.js";
 import type { _CTCellularPlanProvisioningRequest } from "./CTCellularPlanProvisioningRequest.js";
+import type { CTCellularPlanProvisioningAddPlanResult } from "./CTCellularPlanProvisioningAddPlanResult.js";
 export declare class _CTCellularPlanProvisioning extends _NSObject {
     static alloc(): _CTCellularPlanProvisioning;
     static new(): _CTCellularPlanProvisioning;
     init(): _CTCellularPlanProvisioning;
     supportsCellularPlan(): boolean;
-    addPlanWith$completionHandler$(request: _CTCellularPlanProvisioningRequest, completionHandler: NobjcObject): void;
-    addPlanWithRequest$properties$completionHandler$(request: _CTCellularPlanProvisioningRequest, properties: _CTCellularPlanProperties | null, completionHandler: NobjcObject): void;
-    updateCellularPlanProperties$completionHandler$(properties: _CTCellularPlanProperties, completionHandler: NobjcObject | null): void;
+    addPlanWith$completionHandler$(request: _CTCellularPlanProvisioningRequest, completionHandler: (result: CTCellularPlanProvisioningAddPlanResult) => void): void;
+    addPlanWithRequest$properties$completionHandler$(request: _CTCellularPlanProvisioningRequest, properties: _CTCellularPlanProperties | null, completionHandler: (result: CTCellularPlanProvisioningAddPlanResult) => void): void;
+    updateCellularPlanProperties$completionHandler$(properties: _CTCellularPlanProperties, completionHandler: ((error: _NSError) => void) | null): void;
     supportsEmbeddedSIM(): boolean;
 }

package/dist/CoreTelephony/CTCellularPlanStatus.d.ts

@@ -1,10 +1,10 @@
-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";
 export declare class _CTCellularPlanStatus extends _NSObject {
     static alloc(): _CTCellularPlanStatus;
     static new(): _CTCellularPlanStatus;
     init(): _CTCellularPlanStatus;
-    static getTokenWithCompletion$(completionHandler: NobjcObject | null): void;
-    static checkValidityOfToken$completionHandler$(token: _NSString, completionHandler: NobjcObject | null): void;
+    static getTokenWithCompletion$(completionHandler: ((token: _NSString, error: _NSError) => void) | null): void;
+    static checkValidityOfToken$completionHandler$(token: _NSString, completionHandler: ((isValid: boolean, error: _NSError) => void) | null): void;
 }

package/dist/CoreTelephony/CTTelephonyNetworkInfo.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -28,14 +27,14 @@ export declare class _CTTelephonyNetworkInfo extends _NSObject {
      * serviceSubscriberCellularProvidersDidUpdateNotifier Discussion: A block that will be dispatched on the default priority global dispatch queue when the subscriber's cellular provider information updates for any service. Set this property to a block that is defined in your application to receive the newly updated information. The NSString will contain the service identifier of the service whose information has changed. This can be used as the key into serviceSubscriberCellularProvider to obtain the new information.
      * @deprecated Deprecated with no replacement
      */
-    serviceSubscriberCellularProvidersDidUpdateNotifier(): NobjcObject | null;
-    setServiceSubscriberCellularProvidersDidUpdateNotifier$(value: NobjcObject | null): void;
+    serviceSubscriberCellularProvidersDidUpdateNotifier(): ((arg0: _NSString) => void) | null;
+    setServiceSubscriberCellularProvidersDidUpdateNotifier$(value: ((arg0: _NSString) => void) | null): void;
     /**
      * subscriberCellularProviderDidUpdateNotifier Discussion: A block that will be dispatched on the default priority global dispatch queue when the subscriber's cellular provider information updates for the service. Set this property to a block that is defined in your application to receive the newly updated information.
      * @deprecated serviceSubscriberCellularProvidersDidUpdateNotifier
      */
-    subscriberCellularProviderDidUpdateNotifier(): NobjcObject;
-    setSubscriberCellularProviderDidUpdateNotifier$(value: NobjcObject): void;
+    subscriberCellularProviderDidUpdateNotifier(): (arg0: _CTCarrier) => void;
+    setSubscriberCellularProviderDidUpdateNotifier$(value: (arg0: _CTCarrier) => void): void;
     /**
      * serviceCurrentRadioAccessTechnology Discussion: A dictionary containing the current radio access technology each service is registered. The key to the dictionary is an NSString representing the service. An entry may be nil if the service is not registered on any network.
      */

package/dist/CoreText/functions.d.ts

@@ -66,7 +66,7 @@ export declare function CTFontDescriptorCreateMatchingFontDescriptors(descriptor
 export declare function CTFontDescriptorCreateWithAttributes(attributes: NobjcObject): NobjcObject;
 export declare function CTFontDescriptorCreateWithNameAndSize(name: Uint8Array, size: number): NobjcObject;
 export declare function CTFontDescriptorGetTypeID(): number;
-export declare function CTFontDescriptorMatchFontDescriptorsWithProgressHandler(descriptors: NobjcObject, mandatoryAttributes: NobjcObject | null, progressBlock: NobjcObject): boolean;
+export declare function CTFontDescriptorMatchFontDescriptorsWithProgressHandler(descriptors: NobjcObject, mandatoryAttributes: NobjcObject | null, progressBlock: (arg0: NobjcObject, arg1: NobjcObject) => boolean): boolean;
 export declare function CTFontDrawGlyphs(font: NobjcObject, glyphs: NobjcObject, positions: NobjcObject, count: number, context: Uint8Array): void;
 export declare function CTFontDrawImageFromAdaptiveImageProviderAtPoint(font: NobjcObject, provider: _CTAdaptiveImageProviding, point: CGPoint, context: Uint8Array): void;
 export declare function CTFontGetAdvancesForGlyphs(font: NobjcObject, orientation: NobjcObject, glyphs: NobjcObject, advances: NobjcObject | null, count: number): number;
@@ -103,23 +103,23 @@ export declare function CTFontManagerCopyRegisteredFontDescriptors(scope: NobjcO
 export declare function CTFontManagerCreateFontDescriptorFromData(data: NobjcObject): NobjcObject | null;
 export declare function CTFontManagerCreateFontDescriptorsFromData(data: NobjcObject): NobjcObject;
 export declare function CTFontManagerCreateFontDescriptorsFromURL(fileURL: NobjcObject): NobjcObject | null;
-export declare function CTFontManagerCreateFontRequestRunLoopSource(sourceOrder: number, createMatchesCallback: NobjcObject): NobjcObject | null;
+export declare function CTFontManagerCreateFontRequestRunLoopSource(sourceOrder: number, createMatchesCallback: (arg0: NobjcObject, arg1: NobjcObject) => NobjcObject): NobjcObject | null;
 export declare function CTFontManagerEnableFontDescriptors(descriptors: NobjcObject, enable: boolean): void;
 export declare function CTFontManagerGetAutoActivationSetting(bundleIdentifier: Uint8Array | null): NobjcObject;
 export declare function CTFontManagerGetScopeForURL(fontURL: NobjcObject): NobjcObject;
 export declare function CTFontManagerIsSupportedFont(fontURL: NobjcObject): boolean;
-export declare function CTFontManagerRegisterFontDescriptors(fontDescriptors: NobjcObject, scope: NobjcObject, enabled: boolean, registrationHandler: NobjcObject | null): void;
+export declare function CTFontManagerRegisterFontDescriptors(fontDescriptors: NobjcObject, scope: NobjcObject, enabled: boolean, registrationHandler: ((arg0: NobjcObject, arg1: boolean) => boolean) | null): void;
 export declare function CTFontManagerRegisterFontsForURL(fontURL: NobjcObject, scope: NobjcObject, error: NobjcObject | null): boolean;
 export declare function CTFontManagerRegisterFontsForURLs(fontURLs: NobjcObject, scope: NobjcObject, errors: NobjcObject | null): boolean;
-export declare function CTFontManagerRegisterFontsWithAssetNames(fontAssetNames: NobjcObject, bundle: NobjcObject | null, scope: NobjcObject, enabled: boolean, registrationHandler: NobjcObject | null): void;
-export declare function CTFontManagerRegisterFontURLs(fontURLs: NobjcObject, scope: NobjcObject, enabled: boolean, registrationHandler: NobjcObject | null): void;
+export declare function CTFontManagerRegisterFontsWithAssetNames(fontAssetNames: NobjcObject, bundle: NobjcObject | null, scope: NobjcObject, enabled: boolean, registrationHandler: ((arg0: NobjcObject, arg1: boolean) => boolean) | null): void;
+export declare function CTFontManagerRegisterFontURLs(fontURLs: NobjcObject, scope: NobjcObject, enabled: boolean, registrationHandler: ((arg0: NobjcObject, arg1: boolean) => boolean) | null): void;
 export declare function CTFontManagerRegisterGraphicsFont(font: NobjcObject, error: NobjcObject | null): boolean;
-export declare function CTFontManagerRequestFonts(fontDescriptors: NobjcObject, completionHandler: NobjcObject): void;
+export declare function CTFontManagerRequestFonts(fontDescriptors: NobjcObject, completionHandler: (arg0: NobjcObject) => void): void;
 export declare function CTFontManagerSetAutoActivationSetting(bundleIdentifier: Uint8Array | null, setting: NobjcObject): void;
-export declare function CTFontManagerUnregisterFontDescriptors(fontDescriptors: NobjcObject, scope: NobjcObject, registrationHandler: NobjcObject | null): void;
+export declare function CTFontManagerUnregisterFontDescriptors(fontDescriptors: NobjcObject, scope: NobjcObject, registrationHandler: ((arg0: NobjcObject, arg1: boolean) => boolean) | null): void;
 export declare function CTFontManagerUnregisterFontsForURL(fontURL: NobjcObject, scope: NobjcObject, error: NobjcObject | null): boolean;
 export declare function CTFontManagerUnregisterFontsForURLs(fontURLs: NobjcObject, scope: NobjcObject, errors: NobjcObject | null): boolean;
-export declare function CTFontManagerUnregisterFontURLs(fontURLs: NobjcObject, scope: NobjcObject, registrationHandler: NobjcObject | null): void;
+export declare function CTFontManagerUnregisterFontURLs(fontURLs: NobjcObject, scope: NobjcObject, registrationHandler: ((arg0: NobjcObject, arg1: boolean) => boolean) | null): void;
 export declare function CTFontManagerUnregisterGraphicsFont(font: NobjcObject, error: NobjcObject | null): boolean;
 export declare function CTFrameDraw(frame: NobjcObject, context: Uint8Array): void;
 export declare function CTFrameGetFrameAttributes(frame: NobjcObject): NobjcObject | null;
@@ -148,7 +148,7 @@ export declare function CTLineCreateJustifiedLine(line: NobjcObject, justificati
 export declare function CTLineCreateTruncatedLine(line: NobjcObject, width: number, truncationType: NobjcObject, truncationToken: NobjcObject | null): NobjcObject | null;
 export declare function CTLineCreateWithAttributedString(attrString: NobjcObject): NobjcObject;
 export declare function CTLineDraw(line: NobjcObject, context: Uint8Array): void;
-export declare function CTLineEnumerateCaretOffsets(line: NobjcObject, block: NobjcObject): void;
+export declare function CTLineEnumerateCaretOffsets(line: NobjcObject, block: (arg0: number, arg1: number, arg2: boolean, arg3: NobjcObject) => void): void;
 export declare function CTLineGetBoundsWithOptions(line: NobjcObject, options: NobjcObject): CGRect;
 export declare function CTLineGetGlyphCount(line: NobjcObject): number;
 export declare function CTLineGetGlyphRuns(line: NobjcObject): NobjcObject;

package/dist/CoreText/functions.js

@@ -187,7 +187,7 @@ export function CTFontDescriptorGetTypeID() {
     return callFunction("CTFontDescriptorGetTypeID", { returns: "L" });
 }
 export function CTFontDescriptorMatchFontDescriptorsWithProgressHandler(descriptors, mandatoryAttributes, progressBlock) {
-    return callFunction("CTFontDescriptorMatchFontDescriptorsWithProgressHandler", { returns: "B" }, descriptors, mandatoryAttributes, progressBlock);
+    return callFunction("CTFontDescriptorMatchFontDescriptorsWithProgressHandler", { returns: "B", args: ["@", "@", "@?"] }, descriptors, mandatoryAttributes, progressBlock);
 }
 export function CTFontDrawGlyphs(font, glyphs, positions, count, context) {
     callFunction("CTFontDrawGlyphs", { args: ["@", "@", "@", "Q", "^"] }, font, glyphs, positions, count, context);
@@ -298,7 +298,7 @@ export function CTFontManagerCreateFontDescriptorsFromURL(fileURL) {
     return callFunction("CTFontManagerCreateFontDescriptorsFromURL", { returns: "@" }, fileURL);
 }
 export function CTFontManagerCreateFontRequestRunLoopSource(sourceOrder, createMatchesCallback) {
-    return callFunction("CTFontManagerCreateFontRequestRunLoopSource", { returns: "@", args: ["q", "@"] }, sourceOrder, createMatchesCallback);
+    return callFunction("CTFontManagerCreateFontRequestRunLoopSource", { returns: "@", args: ["q", "@?"] }, sourceOrder, createMatchesCallback);
 }
 export function CTFontManagerEnableFontDescriptors(descriptors, enable) {
     callFunction("CTFontManagerEnableFontDescriptors", { args: ["@", "B"] }, descriptors, enable);
@@ -313,7 +313,7 @@ export function CTFontManagerIsSupportedFont(fontURL) {
     return callFunction("CTFontManagerIsSupportedFont", { returns: "B" }, fontURL);
 }
 export function CTFontManagerRegisterFontDescriptors(fontDescriptors, scope, enabled, registrationHandler) {
-    callFunction("CTFontManagerRegisterFontDescriptors", { args: ["@", "@", "B", "@"] }, fontDescriptors, scope, enabled, registrationHandler);
+    callFunction("CTFontManagerRegisterFontDescriptors", { args: ["@", "@", "B", "@?"] }, fontDescriptors, scope, enabled, registrationHandler);
 }
 export function CTFontManagerRegisterFontsForURL(fontURL, scope, error) {
     return callFunction("CTFontManagerRegisterFontsForURL", { returns: "B" }, fontURL, scope, error);
@@ -322,22 +322,22 @@ export function CTFontManagerRegisterFontsForURLs(fontURLs, scope, errors) {
     return callFunction("CTFontManagerRegisterFontsForURLs", { returns: "B" }, fontURLs, scope, errors);
 }
 export function CTFontManagerRegisterFontsWithAssetNames(fontAssetNames, bundle, scope, enabled, registrationHandler) {
-    callFunction("CTFontManagerRegisterFontsWithAssetNames", { args: ["@", "@", "@", "B", "@"] }, fontAssetNames, bundle, scope, enabled, registrationHandler);
+    callFunction("CTFontManagerRegisterFontsWithAssetNames", { args: ["@", "@", "@", "B", "@?"] }, fontAssetNames, bundle, scope, enabled, registrationHandler);
 }
 export function CTFontManagerRegisterFontURLs(fontURLs, scope, enabled, registrationHandler) {
-    callFunction("CTFontManagerRegisterFontURLs", { args: ["@", "@", "B", "@"] }, fontURLs, scope, enabled, registrationHandler);
+    callFunction("CTFontManagerRegisterFontURLs", { args: ["@", "@", "B", "@?"] }, fontURLs, scope, enabled, registrationHandler);
 }
 export function CTFontManagerRegisterGraphicsFont(font, error) {
     return callFunction("CTFontManagerRegisterGraphicsFont", { returns: "B" }, font, error);
 }
 export function CTFontManagerRequestFonts(fontDescriptors, completionHandler) {
-    callFunction("CTFontManagerRequestFonts", undefined, fontDescriptors, completionHandler);
+    callFunction("CTFontManagerRequestFonts", { args: ["@", "@?"] }, fontDescriptors, completionHandler);
 }
 export function CTFontManagerSetAutoActivationSetting(bundleIdentifier, setting) {
     callFunction("CTFontManagerSetAutoActivationSetting", { args: ["^", "@"] }, bundleIdentifier, setting);
 }
 export function CTFontManagerUnregisterFontDescriptors(fontDescriptors, scope, registrationHandler) {
-    callFunction("CTFontManagerUnregisterFontDescriptors", undefined, fontDescriptors, scope, registrationHandler);
+    callFunction("CTFontManagerUnregisterFontDescriptors", { args: ["@", "@", "@?"] }, fontDescriptors, scope, registrationHandler);
 }
 export function CTFontManagerUnregisterFontsForURL(fontURL, scope, error) {
     return callFunction("CTFontManagerUnregisterFontsForURL", { returns: "B" }, fontURL, scope, error);
@@ -346,7 +346,7 @@ export function CTFontManagerUnregisterFontsForURLs(fontURLs, scope, errors) {
     return callFunction("CTFontManagerUnregisterFontsForURLs", { returns: "B" }, fontURLs, scope, errors);
 }
 export function CTFontManagerUnregisterFontURLs(fontURLs, scope, registrationHandler) {
-    callFunction("CTFontManagerUnregisterFontURLs", undefined, fontURLs, scope, registrationHandler);
+    callFunction("CTFontManagerUnregisterFontURLs", { args: ["@", "@", "@?"] }, fontURLs, scope, registrationHandler);
 }
 export function CTFontManagerUnregisterGraphicsFont(font, error) {
     return callFunction("CTFontManagerUnregisterGraphicsFont", { returns: "B" }, font, error);
@@ -433,7 +433,7 @@ export function CTLineDraw(line, context) {
     callFunction("CTLineDraw", { args: ["@", "^"] }, line, context);
 }
 export function CTLineEnumerateCaretOffsets(line, block) {
-    callFunction("CTLineEnumerateCaretOffsets", undefined, line, block);
+    callFunction("CTLineEnumerateCaretOffsets", { args: ["@", "@?"] }, line, block);
 }
 export function CTLineGetBoundsWithOptions(line, options) {
     return callFunction("CTLineGetBoundsWithOptions", { returns: "{CGRect}" }, line, options);

package/dist/CryptoTokenKit/TKErrorCode.d.ts

@@ -0,0 +1,15 @@
+export declare const TKErrorCode: {
+    readonly NotImplemented: -1;
+    readonly CommunicationError: -2;
+    readonly CorruptedData: -3;
+    readonly CanceledByUser: -4;
+    readonly AuthenticationFailed: -5;
+    readonly ObjectNotFound: -6;
+    readonly TokenNotFound: -7;
+    readonly BadParameter: -8;
+    readonly AuthenticationNeeded: -9;
+    readonly TKErrorAuthenticationFailed: -5;
+    readonly TKErrorObjectNotFound: -6;
+    readonly TKErrorTokenNotFound: -7;
+};
+export type TKErrorCode = typeof TKErrorCode[keyof typeof TKErrorCode];

package/dist/CryptoTokenKit/TKErrorCode.js

@@ -0,0 +1,15 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const TKErrorCode = {
+    NotImplemented: -1,
+    CommunicationError: -2,
+    CorruptedData: -3,
+    CanceledByUser: -4,
+    AuthenticationFailed: -5,
+    ObjectNotFound: -6,
+    TokenNotFound: -7,
+    BadParameter: -8,
+    AuthenticationNeeded: -9,
+    TKErrorAuthenticationFailed: -5,
+    TKErrorObjectNotFound: -6,
+    TKErrorTokenNotFound: -7,
+};

package/dist/CryptoTokenKit/TKSmartCard.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 { _TKSmartCardPINFormat } from "./TKSmartCardPINFormat.js";
@@ -14,11 +15,11 @@ export declare class _TKSmartCard extends _NSObject {
     /**
      * Begins session with the card. @discussion When session exists, other requests for sessions from other card objects to the same card are blocked. Session is reference-counted, the same amount of 'end' calls must be done to really terminate the session. Note that finishing session does not automatically mean that the card is disconnected; it only happens when another session from different card object is requested. @param success Signals whether session was successfully started. @param error More information about error preventing the transaction to start
      */
-    beginSessionWithReply$(reply: NobjcObject | null): void;
+    beginSessionWithReply$(reply: ((success: boolean, error: _NSError) => void) | null): void;
     /**
      * Transmits raw command to the card. This call is allowed only inside session. @param request Request part of APDU @param reponse Response part of APDU, or nil if communication with the card failed @param error Error details when communication with the card failed
      */
-    transmitRequest$reply$(request: _NSData, reply: NobjcObject | null): void;
+    transmitRequest$reply$(request: _NSData, reply: ((response: _NSData, error: _NSError) => void) | null): void;
     /**
      * Terminates the transaction. If no transaction is pending any more, the connection will be closed if there is another session in the system waiting for the transaction.
      */
@@ -34,11 +35,11 @@ export declare class _TKSmartCard extends _NSObject {
     /**
      * Transmits APDU to the card and returns response. @discussion Asynchronous high level variant of command for transmitting APDU to the card. Handles all ISO7816-4 APDU cases translation to proper sequences according to used protocol. Consults useExtendedAPDU and useCommandChaining properties and uses these modes whenever appropriate and beneficial for sending requested APDU request. @param ins INS code of the APDU @param p1 P1 code of the APDU @param p2 P2 code of the APDU @param requestData Data field of the APDU, or nil if no input data field should be present (i.e case1 or case2 APDUs). Length of the data serves as Lc field of the APDU. @param le Expected number of bytes to be returned, or nil if no output data are expected (i.e. case1 or case3 APDUs). To get as much bytes as card provides, pass @0. @param replyData Block of returned data without SW1SW2 bytes, or nil if an error occured. @param sw SW1SW2 result code, first two bytes of returned card's reply. @param error Contains error details when nil is returned. Specific error is also filled in if there was no communication error, but card returned other SW code than 0x9000.
      */
-    sendIns$p1$p2$data$le$reply$(ins: NobjcObject, p1: NobjcObject, p2: NobjcObject, requestData: _NSData | null, le: _NSNumber | null, reply: NobjcObject | null): void;
+    sendIns$p1$p2$data$le$reply$(ins: NobjcObject, p1: NobjcObject, p2: NobjcObject, requestData: _NSData | null, le: _NSNumber | null, reply: ((replyData: _NSData, sw: number, error: _NSError) => void) | null): void;
     /**
      * Synchronous variant of session creation. Begins the session, executes given block and ends session. @param error Error receiving more information when transaction failed to start or block failed for some reason. @param block Block to be executed when the session was successfully begun. @return Returns YES if the session was successfully begun and block returned YES, otherwise NO.
      */
-    inSessionWithError$executeBlock$(error: NobjcObject | null, block: NobjcObject | null): boolean;
+    inSessionWithError$executeBlock$(error: NobjcObject | null, block: ((error: NobjcObject) => boolean) | null): boolean;
     /**
      * Transmits APDU to the card and returns response. @discussion Synchronous high level variant of command for transmitting APDU to the card. Handles all ISO7816-4 APDU cases translation to proper sequences according to used protocol. Should be used in block passed to -[TKSmartCard inSessionWithError:executeBlock:] method. @param ins INS code of the APDU @param p1 P1 code of the APDU @param p2 P2 code of the APDU @param data Data field of the APDU. Length of the data serves as Lc field of the APDU @param le Expected number of bytes to be returned, or nil if no output data are expected (i.e. case1 or case3 APDUs). To get as much bytes as card provides, pass @0. @param sw On output, filled with SW1SW2 result code @param error Contains error details when nil is returned. Specific error is also filled in if there was no communication error, but card returned other SW code than 0x9000. @return Returned data field, excluding SW status bytes. If an error occured, returns nil.
      */

package/dist/CryptoTokenKit/TKSmartCardATR.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSData } from "../Foundation/NSData.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
@@ -15,7 +14,7 @@ export declare class _TKSmartCardATR extends _NSObject {
     /**
      * Parses ATR from stream. @param source Provides one byte of ATR from the stream or -1 in case of an error @return Parsed ATR instance, or nil when #source method failed or an invalid ATR is detected
      */
-    initWithSource$(source: NobjcObject): _TKSmartCardATR | null;
+    initWithSource$(source: () => number): _TKSmartCardATR | null;
     /**
      * Retrieves interface group with specified index. @param index Index of the requested interface group. Indexing conforms to ISO7816-3, i.e. starts from 1. @return Interface group with given index, or nil of no such group was present.
      */

package/dist/CryptoTokenKit/TKSmartCardSlotManager.d.ts

@@ -1,8 +1,9 @@
-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 { _NSString } from "../Foundation/NSString.js";
 import type { _TKSmartCardSlot } from "./TKSmartCardSlot.js";
+import type { _TKSmartCardSlotNFCSession } from "./TKSmartCardSlotNFCSession.js";
 export declare class _TKSmartCardSlotManager extends _NSObject {
     static alloc(): _TKSmartCardSlotManager;
     static new(): _TKSmartCardSlotManager;
@@ -14,7 +15,7 @@ export declare class _TKSmartCardSlotManager extends _NSObject {
     /**
      * Instantiates smartcard reader slot of specified name. If specified name is not registered, reports nil.
      */
-    getSlotWithName$reply$(name: _NSString, reply: NobjcObject | null): void;
+    getSlotWithName$reply$(name: _NSString, reply: ((slot: _TKSmartCardSlot) => void) | null): void;
     /**
      * Gets SmartCard reader slot with specified name. If reader slot with this name does not exist, returns nil.
      */
@@ -22,7 +23,7 @@ export declare class _TKSmartCardSlotManager extends _NSObject {
     /**
      * Creates an NFC smart card slot using the device's hardware and presents a system UI. @param message Message shown in the system-presented UI @param completion Completion handler which returns the NFC session of the created slot or an error on failure. If an NFC slot already exists and current caller is not the initial creator `TKErrorCodeObjectNotFound` error is returned. @discussion To finish the NFC session and dismiss the system-presented UI use `TKSmartCardSlotNFCSession.endSession`. @warning Caller requires `com.apple.developer.nfc.readersession.iso7816.select-identifiers` Info.plist record which specifies application identifiers of the NFC cards @link https://developer.apple.com/documentation/bundleresources/information-property-list/com.apple.developer.nfc.readersession.iso7816.select-identifiers
      */
-    createNFCSlotWithMessage$completion$(message: _NSString | null, completion: NobjcObject | null): void;
+    createNFCSlotWithMessage$completion$(message: _NSString | null, completion: ((session: _TKSmartCardSlotNFCSession, error: _NSError) => void) | null): void;
     /**
      * Determines whether NFC (Near Field Communication) is supported on this device. @return `YES` if NFC is supported and available for use, NO otherwise.
      */

package/dist/CryptoTokenKit/TKSmartCardUserInteraction.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 { _TKSmartCardUserInteractionDelegate } from "./TKSmartCardUserInteractionDelegate.js";
 export declare class _TKSmartCardUserInteraction extends _NSObject {
@@ -6,7 +6,7 @@ export declare class _TKSmartCardUserInteraction extends _NSObject {
     static new(): _TKSmartCardUserInteraction;
     init(): _TKSmartCardUserInteraction;
     /** Runs the interaction. */
-    runWithReply$(reply: NobjcObject | null): void;
+    runWithReply$(reply: ((success: boolean, error: _NSError) => void) | null): void;
     /**
      * Attempts to cancel a running interaction. Note that for some interactions, this functionality might not be available. @return Returns NO if the operation is not running, or cancelling is not supported.
      */

package/dist/CryptoTokenKit/TKTokenWatcher.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";
@@ -12,15 +11,15 @@ export declare class _TKTokenWatcher extends _NSObject {
      * Init watcher with insertion handler init watcher with insertion handler which is called when a new token arrives called when a new token is inserted
      * @deprecated setInsertionHandler
      */
-    initWithInsertionHandler$(insertionHandler: NobjcObject): _TKTokenWatcher;
+    initWithInsertionHandler$(insertionHandler: (tokenID: _NSString) => void): _TKTokenWatcher;
     /**
      * Set insertion handler when an insertion handler is set the TokenWatcher will call this handler when new token appears in the system. TokenWatcher will call the handler also for tokens which was registered in the system before the handler was set. called when a new token is inserted
      */
-    setInsertionHandler$(insertionHandler: NobjcObject): void;
+    setInsertionHandler$(insertionHandler: (tokenID: _NSString) => void): void;
     /**
      * Add removal watcher for specific tokenID after removalHandler for a specific tokenID is called the reference to this handler is removed. For one tokenID just one handler can be added, so next call to addRemovalHandler will replace previous handler called when a token is removed specified tokenID, if tokenID does not exist removal handler is called imediately
      */
-    addRemovalHandler$forTokenID$(removalHandler: NobjcObject, tokenID: _NSString): void;
+    addRemovalHandler$forTokenID$(removalHandler: (tokenID: _NSString) => void, tokenID: _NSString): void;
     /**
      * Return TokenInfo for specific tokenID specified tokenID A TokenInfo object, or nil if tokenID does not exist
      */

package/dist/CryptoTokenKit/index.d.ts

@@ -115,6 +115,7 @@ import type { _TKTokenDriverDelegate } from "./TKTokenDriverDelegate.js";
 export type { _TKTokenDriverDelegate };
 import type { _TKTokenSessionDelegate } from "./TKTokenSessionDelegate.js";
 export type { _TKTokenSessionDelegate };
+export { TKErrorCode } from "./TKErrorCode.js";
 export { TKSmartCardPINCharset } from "./TKSmartCardPINCharset.js";
 export { TKSmartCardPINCompletion } from "./TKSmartCardPINCompletion.js";
 export { TKSmartCardPINConfirmation } from "./TKSmartCardPINConfirmation.js";

package/dist/CryptoTokenKit/index.js

@@ -37,6 +37,7 @@ export const TKTokenSession = _bindClass(CryptoTokenKit, "TKTokenSession");
 export const TKTokenSmartCardPINAuthOperation = _bindClass(CryptoTokenKit, "TKTokenSmartCardPINAuthOperation");
 export const TKTokenWatcher = _bindClass(CryptoTokenKit, "TKTokenWatcher");
 export const TKTokenWatcherTokenInfo = _bindClass(CryptoTokenKit, "TKTokenWatcherTokenInfo");
+export { TKErrorCode } from "./TKErrorCode.js";
 export { TKSmartCardPINCharset } from "./TKSmartCardPINCharset.js";
 export { TKSmartCardPINCompletion } from "./TKSmartCardPINCompletion.js";
 export { TKSmartCardPINConfirmation } from "./TKSmartCardPINConfirmation.js";

package/dist/DeviceCheck/DCAppAttestService.d.ts

@@ -1,5 +1,5 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSData } from "../Foundation/NSData.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 export declare class _DCAppAttestService extends _NSObject {
@@ -13,15 +13,15 @@ export declare class _DCAppAttestService extends _NSObject {
     /**
      * Creates a new cryptographic key for use with the App Attest service. > 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 generateKey() async throws -> String > ``` > For example: > ```swift > let keyIdentifier = try await generateKey() > ``` > For information about concurrency and asynchronous code in Swift, see <doc://com.apple.documentation/documentation/swift/calling-objective-c-apis-asynchronously>. Call this method to request the creation of a secure, unattested key pair on a device for a specific user. On success, the method provides your app with an identifier that represents the key pair stored in the Secure Enclave. Because there’s no way to use or retrieve the key without the identifier, you’ll want to either record it in your app or on your server right away. If key generation fails, the closure provides a ``DeviceCheck/DCError-swift.struct`` that indicates the reason for the failure. Create a unique key for each user account on a device. Otherwise it’s hard to detect an attack that uses a single compromised device to serve multiple remote users running a compromised version of your app. For more information, see <doc:assessing-fraud-risk>. After you get the identifier, you call the ``DeviceCheck/DCAppAttestService/attestKey:clientDataHash:completionHandler:`` method with the key identifier to ask Apple to attest to the validity of the associated key. Later, you call the ``DeviceCheck/DCAppAttestService/generateAssertion:clientDataHash:completionHandler:`` method with the key identifier to answer a challenge from your server, and establish the legitimacy of this instance of your app. - Parameters: - completionHandler: A closure that the method calls upon completion with the following parameters: - `keyId`: An identifier that you use to refer to the key. The framework securely stores the key in the Secure Enclave. - `error`: A ``DeviceCheck/DCError-swift.struct`` instance that indicates the reason for failure, or `nil` on success.
      */
-    generateKeyWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    generateKeyWithCompletionHandler$(completionHandler: ((keyId: _NSString, error: _NSError) => void) | null): void;
     /**
      * Asks Apple to attest to the validity of a generated cryptographic key. > 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 attestKey(_ keyId: String, clientDataHash: Data) async throws -> Data > ``` > > For information about concurrency and asynchronous code in Swift, see <doc://com.apple.documentation/documentation/swift/calling-objective-c-apis-asynchronously>. This method asks Apple to attest to the validity of a key that you previously generated with a call to the ``DeviceCheck/DCAppAttestService/generateKeyWithCompletionHandler:`` method. Provide the method with both the key identifier and a computed hash of a data block that includes a one-time challenge from your server to prevent replay attacks. For example, you can use CryptoKit to create a <doc://com.apple.documentation/documentation/cryptokit/sha256> hash of challenge data: ```swift import CryptoKit let hash = Data(SHA256.hash(data: challenge)) // A challenge from your server. ``` The attest method calls its completion handler to return an attestation object to you, which you must send to your server for verification. A compromised version of your app could falsify the verification result, thus circumventing App Attest. If you successfully verify the attestation object on your server, as described in <doc:validating-apps-that-connect-to-your-server>, then you can associate the key identifier with the user on the device for future reference. You’ll need the identifier to generate assertions with calls to ``DeviceCheck/DCAppAttestService/generateAssertion:clientDataHash:completionHandler:``. If your server fails to verify the attestation object, discard the key identifier. If the method’s completion handler returns the ``DeviceCheck/DCError-swift.struct/serverUnavailable`` error — typically due to network connectivity issues — it means that the framework failed to reach the App Attest service to complete the attestation. In this case, retry attestation again using the same key and client data hash later to avoid unnecessarily generating new keys. Retrying with the same inputs helps to preserve the risk metric for a given device. - Parameters: - keyId: The identifier you received when generating a cryptographic key by calling the ``DeviceCheck/DCAppAttestService/generateKeyWithCompletionHandler:`` method. - clientDataHash: A SHA256 hash of a unique, single-use data block that embeds a challenge from your server. Should be at least 16 bytes in length. - completionHandler: A closure that the method calls upon completion with the following parameters: - `attestationObject`: A statement from Apple about the validity of the key associated with `keyId`. Send this to your server for processing. - `error`: A ``DeviceCheck/DCError-swift.struct`` instance that indicates the reason for failure, or `nil` on success.
      */
-    attestKey$clientDataHash$completionHandler$(keyId: _NSString, clientDataHash: _NSData, completionHandler: NobjcObject | null): void;
+    attestKey$clientDataHash$completionHandler$(keyId: _NSString, clientDataHash: _NSData, completionHandler: ((attestationObject: _NSData, error: _NSError) => void) | null): void;
     /**
      * Creates a block of data that demonstrates the legitimacy of an instance of your app running on a device. > 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 generateAssertion(_ keyId: String, clientDataHash: Data) async throws -> Data > ``` > > For information about concurrency and asynchronous code in Swift, see <doc://com.apple.documentation/documentation/swift/calling-objective-c-apis-asynchronously>. After generating a key with the ``DeviceCheck/DCAppAttestService/generateKeyWithCompletionHandler:`` method and validating it with the ``DeviceCheck/DCAppAttestService/attestKey:clientDataHash:completionHandler:`` method, you can use the key at critical moments in your app’s life cycle — like when a user tries to access premium content — to reaffirm the legitimacy of a given instance of your app. Do this by using the ``DeviceCheck/DCAppAttestService/generateAssertion:clientDataHash:completionHandler:`` method to sign server requests with your attested key. You provide the key identifier and a hash of the request that includes a challenge from your server to prevent replay attacks, where an attacker reuses captured network traffic to pose as someone else. The method returns an assertion object in its completion handler that you send to your server for verification, as described in <doc:establishing-your-app-s-integrity>. - Parameters: - keyId: The identifier you received when generating a cryptographic key by calling the ``DeviceCheck/DCAppAttestService/generateKeyWithCompletionHandler:`` method. - clientDataHash: A SHA256 hash of a unique, single-use data block that represents the client data to be signed with the attested private key. Should be at least 16 bytes in length. - completionHandler: A closure that the method calls upon completion with the following parameters: - `assertionObject`: A data structure that you send to your server for processing. - `error` : A ``DeviceCheck/DCError-swift.struct`` instance that indicates the reason for failure, or `nil` on success.
      */
-    generateAssertion$clientDataHash$completionHandler$(keyId: _NSString, clientDataHash: _NSData, completionHandler: NobjcObject | null): void;
+    generateAssertion$clientDataHash$completionHandler$(keyId: _NSString, clientDataHash: _NSData, completionHandler: ((assertionObject: _NSData, error: _NSError) => void) | null): void;
     /**
      * A Boolean value that indicates whether a particular device provides the App Attest service. > Important: Not all device types support the App Attest service, so check > for support before using the service. > > If you read ``DeviceCheck/DCAppAttestService/supported`` from an app running > on a Mac device, the value is > <doc://com.apple.documentation/documentation/swift/false>. This includes > Mac Catalyst apps, and iOS or iPadOS apps running on Apple silicon. If you read ``DeviceCheck/DCAppAttestService/supported`` from within an app extension, the value might be <doc://com.apple.documentation/documentation/swift/true> or <doc://com.apple.documentation/documentation/swift/false>, depending on the extension type. However, most extensions don’t support App Attest. The ``DeviceCheck/DCAppAttestService/generateKeyWithCompletionHandler:`` method fails when you call it from an app extension, regardless of the value of ``DeviceCheck/DCAppAttestService/supported``. The only app extensions that support App Attest are watchOS extensions in watchOS 9 or later. For these extensions, you can use the results from ``DeviceCheck/DCAppAttestService/supported`` to indicate whether your WatchKit extension bypasses attestation.
      */

package/dist/DeviceCheck/DCDevice.d.ts

@@ -1,4 +1,5 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSData } from "../Foundation/NSData.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 export declare class _DCDevice extends _NSObject {
     static alloc(): _DCDevice;
@@ -11,7 +12,7 @@ export declare class _DCDevice extends _NSObject {
     /**
      * Generates a token that identifies the current device. > 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 generateToken() async throws -> Data > ``` > For example: > ```swift > let token = try await generateToken() > ``` > For information about concurrency and asynchronous code in Swift, see <doc://com.apple.documentation/documentation/swift/calling-objective-c-apis-asynchronously>. Your server uses the generated token in its requests to get or set the persistent bits for the current device. You should treat the token you receive in the completion block as single-use. Although the token remains valid long enough for your server to retry a specific request if necessary, you should not use a token multiple times. Instead, use this method to generate a new token. - Note: The app you use to generate the token must be associated with your developer account; otherwise, the generation request fails. - Parameters: - completion: A completion block that includes the following parameters: - `token`: An ephemeral token that identifies the current device. - `error`: The error that occurred, if any.
      */
-    generateTokenWithCompletionHandler$(completion: NobjcObject | null): void;
+    generateTokenWithCompletionHandler$(completion: ((token: _NSData, error: _NSError) => void) | null): void;
     /** A Boolean value that indicates whether the device supports the DeviceCheck API. */
     supported(): boolean;
 }

package/dist/DeviceCheck/DCError.d.ts

@@ -0,0 +1,8 @@
+export declare const DCError: {
+    readonly UnknownSystemFailure: 0;
+    readonly FeatureUnsupported: 1;
+    readonly InvalidInput: 2;
+    readonly InvalidKey: 3;
+    readonly ServerUnavailable: 4;
+};
+export type DCError = typeof DCError[keyof typeof DCError];

package/dist/DeviceCheck/DCError.js

@@ -0,0 +1,8 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const DCError = {
+    UnknownSystemFailure: 0,
+    FeatureUnsupported: 1,
+    InvalidInput: 2,
+    InvalidKey: 3,
+    ServerUnavailable: 4,
+};

package/dist/DeviceCheck/index.d.ts

@@ -6,3 +6,4 @@ export type { _DCAppAttestService };
 import type { _DCDevice } from "./DCDevice.js";
 export declare const DCDevice: typeof _DCDevice;
 export type { _DCDevice };
+export { DCError } from "./DCError.js";

package/dist/DeviceCheck/index.js

@@ -4,3 +4,4 @@ import { _bindClass } from "../bind.js";
 export const DeviceCheck = new NobjcLibrary("/System/Library/Frameworks/DeviceCheck.framework/DeviceCheck");
 export const DCAppAttestService = _bindClass(DeviceCheck, "DCAppAttestService");
 export const DCDevice = _bindClass(DeviceCheck, "DCDevice");
+export { DCError } from "./DCError.js";

package/dist/DeviceDiscoveryExtension/DDErrorCode.d.ts

@@ -0,0 +1,12 @@
+export declare const DDErrorCode: {
+    readonly Success: 0;
+    readonly Unknown: 350000;
+    readonly BadParameter: 350001;
+    readonly Unsupported: 350002;
+    readonly Timeout: 350003;
+    readonly Internal: 350004;
+    readonly MissingEntitlement: 350005;
+    readonly Permission: 350006;
+    readonly Next: 350007;
+};
+export type DDErrorCode = typeof DDErrorCode[keyof typeof DDErrorCode];

package/dist/DeviceDiscoveryExtension/DDErrorCode.js

@@ -0,0 +1,12 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+export const DDErrorCode = {
+    Success: 0,
+    Unknown: 350000,
+    BadParameter: 350001,
+    Unsupported: 350002,
+    Timeout: 350003,
+    Internal: 350004,
+    MissingEntitlement: 350005,
+    Permission: 350006,
+    Next: 350007,
+};

package/dist/DeviceDiscoveryExtension/index.d.ts

@@ -15,5 +15,6 @@ export { DDDeviceProtocol } from "./DDDeviceProtocol.js";
 export { DDDeviceState } from "./DDDeviceState.js";
 export { DDDeviceSupports } from "./DDDeviceSupports.js";
 export { DDDeviceWiFiAwareServiceRole } from "./DDDeviceWiFiAwareServiceRole.js";
+export { DDErrorCode } from "./DDErrorCode.js";
 export { DDEventType } from "./DDEventType.js";
 export { DDDeviceProtocolString } from "./DDDeviceProtocolString.js";

package/dist/DeviceDiscoveryExtension/index.js

@@ -11,5 +11,6 @@ export { DDDeviceProtocol } from "./DDDeviceProtocol.js";
 export { DDDeviceState } from "./DDDeviceState.js";
 export { DDDeviceSupports } from "./DDDeviceSupports.js";
 export { DDDeviceWiFiAwareServiceRole } from "./DDDeviceWiFiAwareServiceRole.js";
+export { DDErrorCode } from "./DDErrorCode.js";
 export { DDEventType } from "./DDEventType.js";
 export { DDDeviceProtocolString } from "./DDDeviceProtocolString.js";

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/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.
      */