objcjs-types 0.1.0 → 0.2.0

package/dist/CryptoTokenKit/TKTokenConfiguration.d.ts

@@ -2,6 +2,7 @@ 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";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { _TKTokenKeychainCertificate } from "./TKTokenKeychainCertificate.js";
 import type { _TKTokenKeychainKey } from "./TKTokenKeychainKey.js";
 export declare class _TKTokenConfiguration extends _NSObject {
@@ -11,15 +12,15 @@ export declare class _TKTokenConfiguration extends _NSObject {
     /**
      * Returns keychain item key with specified objectID. Fills error with TKTokenErrorCodeObjectNotFound if no such key exists.
      */
-    keyForObjectID$error$(objectID: NobjcObject, error: NobjcObject): _TKTokenKeychainKey | null;
+    keyForObjectID$error$(objectID: NobjcObject, error: NobjcObject | null): _TKTokenKeychainKey | null;
     /**
      * Returns certificate with specified objectID. Fills error with TKTokenErrorCodeObjectNotFound if no such certificate exists.
      */
-    certificateForObjectID$error$(objectID: NobjcObject, error: NobjcObject): _TKTokenKeychainCertificate | null;
+    certificateForObjectID$error$(objectID: NobjcObject, error: NobjcObject | null): _TKTokenKeychainCertificate | null;
     /**
      * Unique, persistent identifier of this token, always created by specific token implementation. Typically implemented by some kind of serial number of the target hardware, for example SmartCard serial number.
      */
-    instanceID(): NobjcObject;
+    instanceID(): _NSString;
     /**
      * Additional configuration available for token instance. Token implementation and its hosting application can use this data for specifying any additional configuration for the token. System does not interpret this data in any way. For example, network-based HSM can store here (using Codable or other serialization mechanisms) target network address, access credentials and the list of identities accessible in the HSM.
      */

package/dist/CryptoTokenKit/TKTokenDelegate.d.ts

@@ -5,7 +5,7 @@ export interface _TKTokenDelegate {
     /**
      * @abstract Create new session instance @discussion All operations with objects on the token are performed inside TKTokenSession which represent authentication context. This method is called whenever new authentication context is needed (typically when client application wants to perform token operation using keychain object which has associated LocalAuthentication LAContext which was not yet seen by this token instance). @param token Related token instance.
      */
-    token$createSessionWithError$?(token: _TKToken, error: NobjcObject): _TKTokenSession | null;
+    token$createSessionWithError$?(token: _TKToken, error: NobjcObject | null): _TKTokenSession | null;
     /**
      * @abstract Terminates previously created session, implementation should free all associated resources. @param token Related token instance.
      */

package/dist/CryptoTokenKit/TKTokenDriverConfiguration.d.ts

@@ -1,6 +1,6 @@
-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";
 import type { _TKTokenConfiguration } from "./TKTokenConfiguration.js";
 export declare class _TKTokenDriverConfiguration extends _NSObject {
     static alloc(): _TKTokenDriverConfiguration;
@@ -13,15 +13,15 @@ export declare class _TKTokenDriverConfiguration extends _NSObject {
     /**
      * Creates new configuration object for token with specified instanceID and adds it into tokenConfigurations dictionary. If configuration with specified instanceID already exists, it is replaced with new empty configuration.
      */
-    addTokenConfigurationForTokenInstanceID$(instanceID: NobjcObject): _TKTokenConfiguration;
+    addTokenConfigurationForTokenInstanceID$(instanceID: _NSString): _TKTokenConfiguration;
     /**
      * Removes configuration with specified tokenID. Does nothing if no such token configuration exists.
      */
-    removeTokenConfigurationForTokenInstanceID$(instanceID: NobjcObject): void;
+    removeTokenConfigurationForTokenInstanceID$(instanceID: _NSString): void;
     /**
      * ClassID of the token configuration. ClassID is taken from @p com.apple.ctk.class-id token extension attribute.
      */
-    classID(): NobjcObject;
+    classID(): _NSString;
     /**
      * Dictionary of all currently configured tokens for this token class, keyed by instanceID.
      */

package/dist/CryptoTokenKit/TKTokenDriverDelegate.d.ts

@@ -6,7 +6,7 @@ export interface _TKTokenDriverDelegate {
     /**
      * @discussion Creates new token for specified configuration. SmartCard token drivers should not implement this method.
      */
-    tokenDriver$tokenForConfiguration$error$?(driver: _TKTokenDriver, configuration: _TKTokenConfiguration, error: NobjcObject): _TKToken | null;
+    tokenDriver$tokenForConfiguration$error$?(driver: _TKTokenDriver, configuration: _TKTokenConfiguration, error: NobjcObject | null): _TKToken | null;
     /**
      * @discussion Terminates previously created token, should release all resources associated with it.
      */

package/dist/CryptoTokenKit/TKTokenKeychainContents.d.ts

@@ -14,11 +14,11 @@ export declare class _TKTokenKeychainContents extends _NSObject {
     /**
      * @discussion Returns key with specified objectID. Fills error with TKTokenErrorCodeObjectNotFound if no such key exists.
      */
-    keyForObjectID$error$(objectID: NobjcObject, error: NobjcObject): _TKTokenKeychainKey | null;
+    keyForObjectID$error$(objectID: NobjcObject, error: NobjcObject | null): _TKTokenKeychainKey | null;
     /**
      * @discussion Returns certificate with specified objectID. Fills error with TKTokenErrorCodeObjectNotFound if no such certificate exists.
      */
-    certificateForObjectID$error$(objectID: NobjcObject, error: NobjcObject): _TKTokenKeychainCertificate | null;
+    certificateForObjectID$error$(objectID: NobjcObject, error: NobjcObject | null): _TKTokenKeychainCertificate | null;
     /** @brief All items related to this token in the keychain. */
     items(): _NSArray;
 }

package/dist/CryptoTokenKit/TKTokenKeychainKey.d.ts

@@ -9,7 +9,7 @@ export declare class _TKTokenKeychainKey extends _TKTokenKeychainItem {
     /**
      * @discussion Initialize TKTokenKeychainKey with informations from SecCertificateRef associated with the key. Use SecCertificateCreateWithData to obtain SecCertificateRef. If NULL is passed instead of certificate, all properties of created instance must be initialized manually.
      */
-    initWithCertificate$objectID$(certificateRef: NobjcObject, objectID: NobjcObject): _TKTokenKeychainKey | null;
+    initWithCertificate$objectID$(certificateRef: NobjcObject | null, objectID: NobjcObject): _TKTokenKeychainKey | null;
     /**
      * @discussion Type of the key, currently kSecAttrKeyTypeRSA and kSecAttrKeyTypeECSECPrimeRandom is supported). The property is an equivalent to kSecAttrKeyType in SecItem.h
      */

package/dist/CryptoTokenKit/TKTokenSessionDelegate.d.ts

@@ -9,7 +9,7 @@ export interface _TKTokenSessionDelegate {
     /**
      * @discussion Establishes a context for the requested authentication operation. @param session Related TKTokenSession instance. @param operation Identifier of the operation. @param constraint Constraint to be satisfied by this authentication operation. @param error Error details (see TKError.h). @return authOperation Resulting context of the operation, which will be eventually finalized by receiving 'finishWithError:'. The resulting 'authOperation' can be of any type based on TKTokenAuthOperation. For known types (e.g. TKTokenPasswordAuthOperation) the system will first fill in the context-specific properties (e.g. 'password') before triggering 'finishWithError:'. When no authentication is actually needed (typically because the session is already authenticated for requested constraint), return instance of TKTokenAuthOperation class instead of any specific subclass.
      */
-    tokenSession$beginAuthForOperation$constraint$error$?(session: _TKTokenSession, operation: TKTokenOperation, constraint: NobjcObject, error: NobjcObject): _TKTokenAuthOperation | null;
+    tokenSession$beginAuthForOperation$constraint$error$?(session: _TKTokenSession, operation: TKTokenOperation, constraint: NobjcObject, error: NobjcObject | null): _TKTokenAuthOperation | null;
     /**
      * @discussion Checks whether specified operation and algorithm is supported on specified key. @param session Related TKTokenSession instance. @param operation Type of cryptographic operation for which the list of supported algorithms should be retrieved. @param keyObjectID Identifier of the private key object. @param algorithm Algorithm with which the oepration should be performed. @return YES if the operation is supported, NO otherwise.
      */
@@ -17,13 +17,13 @@ export interface _TKTokenSessionDelegate {
     /**
      * @discussion Performs cryptographic signature operation. @param session Related TKTokenSession instance. @param dataToSign Input data for the signature operation. @param keyObjectID Identifier of the private key object. @param algorithm Requested signature algorithm to be used. @param error Error details (see TKError.h). If authentication is required (by invoking beginAuthForOperation:), @c TKErrorCodeAuthenticationNeeded should be used. @return Resulting signature, or nil if an error happened.
      */
-    tokenSession$signData$usingKey$algorithm$error$?(session: _TKTokenSession, dataToSign: _NSData, keyObjectID: NobjcObject, algorithm: _TKTokenKeyAlgorithm, error: NobjcObject): _NSData | null;
+    tokenSession$signData$usingKey$algorithm$error$?(session: _TKTokenSession, dataToSign: _NSData, keyObjectID: NobjcObject, algorithm: _TKTokenKeyAlgorithm, error: NobjcObject | null): _NSData | null;
     /**
      * @discussion Decrypts ciphertext using private key. @param session Related TKTokenSession instance. @param ciphertext Encrypted data to decrypt. @param keyObjectID Identifier of the private key object. @param algorithm Requested encryption/decryption algorithm to be used. @param error Error details (see TKError.h). If authentication is required (by invoking beginAuthForOperation:), @c TKErrorCodeAuthenticationNeeded should be used. @return Resulting decrypted plaintext, or nil if an error happened.
      */
-    tokenSession$decryptData$usingKey$algorithm$error$?(session: _TKTokenSession, ciphertext: _NSData, keyObjectID: NobjcObject, algorithm: _TKTokenKeyAlgorithm, error: NobjcObject): _NSData | null;
+    tokenSession$decryptData$usingKey$algorithm$error$?(session: _TKTokenSession, ciphertext: _NSData, keyObjectID: NobjcObject, algorithm: _TKTokenKeyAlgorithm, error: NobjcObject | null): _NSData | null;
     /**
      * @discussion Performs Diffie-Hellman style key exchange operation. @param session Related TKTokenSession instance. @param otherPartyPublicKeyData Raw public data of other party public key. @param objectID Identifier of the private key object. @param algorithm Requested key exchange algorithm to be used. @param parameters Additional parameters for key exchange operation. Chosen algorithm dictates meaning of parameters. @param error Error details (see TKError.h). If authentication is required (by invoking beginAuthForOperation:), @c TKErrorCodeAuthenticationNeeded should be used. @return Result of key exchange operation, or nil if the operation failed.
      */
-    tokenSession$performKeyExchangeWithPublicKey$usingKey$algorithm$parameters$error$?(session: _TKTokenSession, otherPartyPublicKeyData: _NSData, objectID: NobjcObject, algorithm: _TKTokenKeyAlgorithm, parameters: _TKTokenKeyExchangeParameters, error: NobjcObject): _NSData | null;
+    tokenSession$performKeyExchangeWithPublicKey$usingKey$algorithm$parameters$error$?(session: _TKTokenSession, otherPartyPublicKeyData: _NSData, objectID: NobjcObject, algorithm: _TKTokenKeyAlgorithm, parameters: _TKTokenKeyExchangeParameters, error: NobjcObject | null): _NSData | null;
 }

package/dist/CryptoTokenKit/index.js

@@ -1,41 +1,42 @@
 // AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
 import { NobjcLibrary } from "objc-js";
+import { _bindClass } from "../bind.js";
 export const CryptoTokenKit = new NobjcLibrary("/System/Library/Frameworks/CryptoTokenKit.framework/CryptoTokenKit");
-export const TKBERTLVRecord = CryptoTokenKit["TKBERTLVRecord"];
-export const TKCompactTLVRecord = CryptoTokenKit["TKCompactTLVRecord"];
-export const TKSimpleTLVRecord = CryptoTokenKit["TKSimpleTLVRecord"];
-export const TKSmartCard = CryptoTokenKit["TKSmartCard"];
-export const TKSmartCardATR = CryptoTokenKit["TKSmartCardATR"];
-export const TKSmartCardATRInterfaceGroup = CryptoTokenKit["TKSmartCardATRInterfaceGroup"];
-export const TKSmartCardPINFormat = CryptoTokenKit["TKSmartCardPINFormat"];
-export const TKSmartCardSlot = CryptoTokenKit["TKSmartCardSlot"];
-export const TKSmartCardSlotManager = CryptoTokenKit["TKSmartCardSlotManager"];
-export const TKSmartCardSlotNFCSession = CryptoTokenKit["TKSmartCardSlotNFCSession"];
-export const TKSmartCardToken = CryptoTokenKit["TKSmartCardToken"];
-export const TKSmartCardTokenDriver = CryptoTokenKit["TKSmartCardTokenDriver"];
-export const TKSmartCardTokenRegistrationManager = CryptoTokenKit["TKSmartCardTokenRegistrationManager"];
-export const TKSmartCardTokenSession = CryptoTokenKit["TKSmartCardTokenSession"];
-export const TKSmartCardUserInteraction = CryptoTokenKit["TKSmartCardUserInteraction"];
-export const TKSmartCardUserInteractionForPINOperation = CryptoTokenKit["TKSmartCardUserInteractionForPINOperation"];
-export const TKSmartCardUserInteractionForSecurePINChange = CryptoTokenKit["TKSmartCardUserInteractionForSecurePINChange"];
-export const TKSmartCardUserInteractionForSecurePINVerification = CryptoTokenKit["TKSmartCardUserInteractionForSecurePINVerification"];
-export const TKTLVRecord = CryptoTokenKit["TKTLVRecord"];
-export const TKToken = CryptoTokenKit["TKToken"];
-export const TKTokenAuthOperation = CryptoTokenKit["TKTokenAuthOperation"];
-export const TKTokenConfiguration = CryptoTokenKit["TKTokenConfiguration"];
-export const TKTokenDriver = CryptoTokenKit["TKTokenDriver"];
-export const TKTokenDriverConfiguration = CryptoTokenKit["TKTokenDriverConfiguration"];
-export const TKTokenKeyAlgorithm = CryptoTokenKit["TKTokenKeyAlgorithm"];
-export const TKTokenKeyExchangeParameters = CryptoTokenKit["TKTokenKeyExchangeParameters"];
-export const TKTokenKeychainCertificate = CryptoTokenKit["TKTokenKeychainCertificate"];
-export const TKTokenKeychainContents = CryptoTokenKit["TKTokenKeychainContents"];
-export const TKTokenKeychainItem = CryptoTokenKit["TKTokenKeychainItem"];
-export const TKTokenKeychainKey = CryptoTokenKit["TKTokenKeychainKey"];
-export const TKTokenPasswordAuthOperation = CryptoTokenKit["TKTokenPasswordAuthOperation"];
-export const TKTokenSession = CryptoTokenKit["TKTokenSession"];
-export const TKTokenSmartCardPINAuthOperation = CryptoTokenKit["TKTokenSmartCardPINAuthOperation"];
-export const TKTokenWatcher = CryptoTokenKit["TKTokenWatcher"];
-export const TKTokenWatcherTokenInfo = CryptoTokenKit["TKTokenWatcherTokenInfo"];
+export const TKBERTLVRecord = _bindClass(CryptoTokenKit, "TKBERTLVRecord");
+export const TKCompactTLVRecord = _bindClass(CryptoTokenKit, "TKCompactTLVRecord");
+export const TKSimpleTLVRecord = _bindClass(CryptoTokenKit, "TKSimpleTLVRecord");
+export const TKSmartCard = _bindClass(CryptoTokenKit, "TKSmartCard");
+export const TKSmartCardATR = _bindClass(CryptoTokenKit, "TKSmartCardATR");
+export const TKSmartCardATRInterfaceGroup = _bindClass(CryptoTokenKit, "TKSmartCardATRInterfaceGroup");
+export const TKSmartCardPINFormat = _bindClass(CryptoTokenKit, "TKSmartCardPINFormat");
+export const TKSmartCardSlot = _bindClass(CryptoTokenKit, "TKSmartCardSlot");
+export const TKSmartCardSlotManager = _bindClass(CryptoTokenKit, "TKSmartCardSlotManager");
+export const TKSmartCardSlotNFCSession = _bindClass(CryptoTokenKit, "TKSmartCardSlotNFCSession");
+export const TKSmartCardToken = _bindClass(CryptoTokenKit, "TKSmartCardToken");
+export const TKSmartCardTokenDriver = _bindClass(CryptoTokenKit, "TKSmartCardTokenDriver");
+export const TKSmartCardTokenRegistrationManager = _bindClass(CryptoTokenKit, "TKSmartCardTokenRegistrationManager");
+export const TKSmartCardTokenSession = _bindClass(CryptoTokenKit, "TKSmartCardTokenSession");
+export const TKSmartCardUserInteraction = _bindClass(CryptoTokenKit, "TKSmartCardUserInteraction");
+export const TKSmartCardUserInteractionForPINOperation = _bindClass(CryptoTokenKit, "TKSmartCardUserInteractionForPINOperation");
+export const TKSmartCardUserInteractionForSecurePINChange = _bindClass(CryptoTokenKit, "TKSmartCardUserInteractionForSecurePINChange");
+export const TKSmartCardUserInteractionForSecurePINVerification = _bindClass(CryptoTokenKit, "TKSmartCardUserInteractionForSecurePINVerification");
+export const TKTLVRecord = _bindClass(CryptoTokenKit, "TKTLVRecord");
+export const TKToken = _bindClass(CryptoTokenKit, "TKToken");
+export const TKTokenAuthOperation = _bindClass(CryptoTokenKit, "TKTokenAuthOperation");
+export const TKTokenConfiguration = _bindClass(CryptoTokenKit, "TKTokenConfiguration");
+export const TKTokenDriver = _bindClass(CryptoTokenKit, "TKTokenDriver");
+export const TKTokenDriverConfiguration = _bindClass(CryptoTokenKit, "TKTokenDriverConfiguration");
+export const TKTokenKeyAlgorithm = _bindClass(CryptoTokenKit, "TKTokenKeyAlgorithm");
+export const TKTokenKeyExchangeParameters = _bindClass(CryptoTokenKit, "TKTokenKeyExchangeParameters");
+export const TKTokenKeychainCertificate = _bindClass(CryptoTokenKit, "TKTokenKeychainCertificate");
+export const TKTokenKeychainContents = _bindClass(CryptoTokenKit, "TKTokenKeychainContents");
+export const TKTokenKeychainItem = _bindClass(CryptoTokenKit, "TKTokenKeychainItem");
+export const TKTokenKeychainKey = _bindClass(CryptoTokenKit, "TKTokenKeychainKey");
+export const TKTokenPasswordAuthOperation = _bindClass(CryptoTokenKit, "TKTokenPasswordAuthOperation");
+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 { TKSmartCardPINCharset } from "./TKSmartCardPINCharset.js";
 export { TKSmartCardPINCompletion } from "./TKSmartCardPINCompletion.js";
 export { TKSmartCardPINConfirmation } from "./TKSmartCardPINConfirmation.js";

package/dist/DataDetection/index.js

@@ -1,12 +1,13 @@
 // AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
 import { NobjcLibrary } from "objc-js";
+import { _bindClass } from "../bind.js";
 export const DataDetection = new NobjcLibrary("/System/Library/Frameworks/DataDetection.framework/DataDetection");
-export const DDMatch = DataDetection["DDMatch"];
-export const DDMatchCalendarEvent = DataDetection["DDMatchCalendarEvent"];
-export const DDMatchEmailAddress = DataDetection["DDMatchEmailAddress"];
-export const DDMatchFlightNumber = DataDetection["DDMatchFlightNumber"];
-export const DDMatchLink = DataDetection["DDMatchLink"];
-export const DDMatchMoneyAmount = DataDetection["DDMatchMoneyAmount"];
-export const DDMatchPhoneNumber = DataDetection["DDMatchPhoneNumber"];
-export const DDMatchPostalAddress = DataDetection["DDMatchPostalAddress"];
-export const DDMatchShipmentTrackingNumber = DataDetection["DDMatchShipmentTrackingNumber"];
+export const DDMatch = _bindClass(DataDetection, "DDMatch");
+export const DDMatchCalendarEvent = _bindClass(DataDetection, "DDMatchCalendarEvent");
+export const DDMatchEmailAddress = _bindClass(DataDetection, "DDMatchEmailAddress");
+export const DDMatchFlightNumber = _bindClass(DataDetection, "DDMatchFlightNumber");
+export const DDMatchLink = _bindClass(DataDetection, "DDMatchLink");
+export const DDMatchMoneyAmount = _bindClass(DataDetection, "DDMatchMoneyAmount");
+export const DDMatchPhoneNumber = _bindClass(DataDetection, "DDMatchPhoneNumber");
+export const DDMatchPostalAddress = _bindClass(DataDetection, "DDMatchPostalAddress");
+export const DDMatchShipmentTrackingNumber = _bindClass(DataDetection, "DDMatchShipmentTrackingNumber");

package/dist/DeviceCheck/DCAppAttestService.d.ts

@@ -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): void;
+    generateKeyWithCompletionHandler$(completionHandler: NobjcObject | 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): void;
+    attestKey$clientDataHash$completionHandler$(keyId: _NSString, clientDataHash: _NSData, completionHandler: NobjcObject | 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): void;
+    generateAssertion$clientDataHash$completionHandler$(keyId: _NSString, clientDataHash: _NSData, completionHandler: NobjcObject | 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

@@ -11,7 +11,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): void;
+    generateTokenWithCompletionHandler$(completion: NobjcObject | null): void;
     /** A Boolean value that indicates whether the device supports the DeviceCheck API. */
     supported(): boolean;
 }

package/dist/DeviceCheck/index.js

@@ -1,5 +1,6 @@
 // AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
 import { NobjcLibrary } from "objc-js";
+import { _bindClass } from "../bind.js";
 export const DeviceCheck = new NobjcLibrary("/System/Library/Frameworks/DeviceCheck.framework/DeviceCheck");
-export const DCAppAttestService = DeviceCheck["DCAppAttestService"];
-export const DCDevice = DeviceCheck["DCDevice"];
+export const DCAppAttestService = _bindClass(DeviceCheck, "DCAppAttestService");
+export const DCDevice = _bindClass(DeviceCheck, "DCDevice");

package/dist/DeviceDiscoveryExtension/DDDevice.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSData } from "../Foundation/NSData.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -49,8 +48,8 @@ export declare class _DDDevice extends _NSObject {
     mediaContentSubtitle(): _NSString | null;
     setMediaContentSubtitle$(value: _NSString | null): void;
     /** Endpoint to communicate with the device via networking. */
-    networkEndpoint(): NobjcObject;
-    setNetworkEndpoint$(value: NobjcObject): void;
+    networkEndpoint(): _NSObject;
+    setNetworkEndpoint$(value: _NSObject): void;
     /** Protocol of the device. */
     protocol(): DDDeviceProtocol;
     setProtocol$(value: DDDeviceProtocol): void;

package/dist/DeviceDiscoveryExtension/index.js

@@ -1,9 +1,10 @@
 // AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
 import { NobjcLibrary } from "objc-js";
+import { _bindClass } from "../bind.js";
 export const DeviceDiscoveryExtension = new NobjcLibrary("/System/Library/Frameworks/DeviceDiscoveryExtension.framework/DeviceDiscoveryExtension");
-export const DDDevice = DeviceDiscoveryExtension["DDDevice"];
-export const DDDeviceEvent = DeviceDiscoveryExtension["DDDeviceEvent"];
-export const DDDiscoverySession = DeviceDiscoveryExtension["DDDiscoverySession"];
+export const DDDevice = _bindClass(DeviceDiscoveryExtension, "DDDevice");
+export const DDDeviceEvent = _bindClass(DeviceDiscoveryExtension, "DDDeviceEvent");
+export const DDDiscoverySession = _bindClass(DeviceDiscoveryExtension, "DDDiscoverySession");
 export { DDDeviceCategory } from "./DDDeviceCategory.js";
 export { DDDeviceMediaPlaybackState } from "./DDDeviceMediaPlaybackState.js";
 export { DDDeviceProtocol } from "./DDDeviceProtocol.js";

package/dist/DiscRecording/DRFSObject.d.ts

@@ -70,13 +70,13 @@ export declare class _DRFSObject extends _NSObject {
     /**
      * @method explicitFilesystemMask @abstract Returns the explicit filesystem mask set for the reciever. @discussion The explicit mask is one that has been explicitly set by a client through the @link //apple_ref/occ/instm/DRFSObject/setExplicitFilesystemMask: setExplicitFilesystemMask: @/link method. @result A filesystem mask
      */
-    explicitFilesystemMask(): NobjcObject;
+    explicitFilesystemMask(): number;
     /**
      * @method setExplicitFilesystemMask: @abstract Sets the filesystems the receiver will be included on. @discussion The effective mask for an item cannot be more inclusive than the effective mask of it's parent. If the mask set for a child is more inclusive than its parent's mask, those filesystems not allowed by the parent will be stripped from the resulting effective mask of the child. @param mask A filesystem mask
      */
-    setExplicitFilesystemMask$(mask: NobjcObject): void;
+    setExplicitFilesystemMask$(mask: number): void;
     /**
      * @method effectiveFilesystemMask @abstract Returns the effective filesystem mask set for the reciever. @discussion The parent filesystem mask is taken into account for the receiver. @result A filesystem mask
      */
-    effectiveFilesystemMask(): NobjcObject;
+    effectiveFilesystemMask(): number;
 }

package/dist/DiscRecording/DRFileDataProduction.d.ts

@@ -1,10 +1,9 @@
-import type { NobjcObject } from "objc-js";
 import type { _DRFile } from "./DRFile.js";
 export interface _DRFileDataProduction {
     /**
      * Calculates the size of the specified fork of a file. This method may be sent at any time after the file object has been instantiated. Requests that the recevier calculate the byte size of a file's fork (for instance, data fork or resource fork). If estimate is YES , you are being asked for an estimate of the final fork size, perhaps to provide an estimate of the track size, and do not have to be exact. Estimates should err on the high side; it's better to overestimate than underestimate. An estimate call may be made at any time. If estimate is NO , you are being asked for the actual fork size, to be used in the burn. This call is only made in the burn phase. The file object. The fork of the file whose size is to be calculated. If the file size should be estimated or exact. The length of the file's fork.
      */
-    calculateSizeOfFile$fork$estimating$?(file: _DRFile, fork: NobjcObject, estimate: boolean): number;
+    calculateSizeOfFile$fork$estimating$?(file: _DRFile, fork: number, estimate: boolean): number;
     /**
      * Prepare the file object for burning. Sent to the recevier before the burn begins. This would be an appropriate method to open files, or do any other prep work needed. The disc's entire hierarchy is completely in place and can be queried if needed. After this call, the burn's content is locked down, and you should be able to respond to the messages with exact values. The file object. YES if the burn should proceed.
      */
@@ -12,7 +11,7 @@ export interface _DRFileDataProduction {
     /**
      * Produces the specified fork contents for burning. Sent during the burn (after the message) requesting that the receiver produce the specified fork contents. The recevier should fill up the buffer passed in as full as possible and then return control to the caller. While burning keeping the drive's buffer full is of utmost importance, so you should not perform lengthy operations or block for data in this method. This method should return the number of bytes actually in the buffer or 0 to indicate that there was an error producing the data. You may be asked to produce twice, once during the actual burn and once during verification depending on the verification type of the track. The file object. The fork of the file to produce. The buffer to produce data into. The length of the buffer to produce data into The byte address in the file that the burn engine is requesting The size of the track blocks The number of bytes produced.
      */
-    produceFile$fork$intoBuffer$length$atAddress$blockSize$?(file: _DRFile, fork: NobjcObject, buffer: string, bufferLength: number, address: number, blockSize: number): number;
+    produceFile$fork$intoBuffer$length$atAddress$blockSize$?(file: _DRFile, fork: number, buffer: string, bufferLength: number, address: number, blockSize: number): number;
     /**
      * Prepare the file object for verification. Sent during the burn (after production and before the message) to indicate that verification is about to begin. Now would be a good time to rewind to the start of the file, reset state machines, or do whatever else is needed to prepare to produce again. The file object. YES to indicate that the verification should proceed and NO to indicate a failure occurred.
      */

package/dist/DiscRecording/index.js

@@ -1,14 +1,15 @@
 // AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
 import { NobjcLibrary } from "objc-js";
+import { _bindClass } from "../bind.js";
 export const DiscRecording = new NobjcLibrary("/System/Library/Frameworks/DiscRecording.framework/DiscRecording");
-export const DRBurn = DiscRecording["DRBurn"];
-export const DRCDTextBlock = DiscRecording["DRCDTextBlock"];
-export const DRDevice = DiscRecording["DRDevice"];
-export const DRErase = DiscRecording["DRErase"];
-export const DRFSObject = DiscRecording["DRFSObject"];
-export const DRFile = DiscRecording["DRFile"];
-export const DRFolder = DiscRecording["DRFolder"];
-export const DRMSF = DiscRecording["DRMSF"];
-export const DRMSFFormatter = DiscRecording["DRMSFFormatter"];
-export const DRNotificationCenter = DiscRecording["DRNotificationCenter"];
-export const DRTrack = DiscRecording["DRTrack"];
+export const DRBurn = _bindClass(DiscRecording, "DRBurn");
+export const DRCDTextBlock = _bindClass(DiscRecording, "DRCDTextBlock");
+export const DRDevice = _bindClass(DiscRecording, "DRDevice");
+export const DRErase = _bindClass(DiscRecording, "DRErase");
+export const DRFSObject = _bindClass(DiscRecording, "DRFSObject");
+export const DRFile = _bindClass(DiscRecording, "DRFile");
+export const DRFolder = _bindClass(DiscRecording, "DRFolder");
+export const DRMSF = _bindClass(DiscRecording, "DRMSF");
+export const DRMSFFormatter = _bindClass(DiscRecording, "DRMSFFormatter");
+export const DRNotificationCenter = _bindClass(DiscRecording, "DRNotificationCenter");
+export const DRTrack = _bindClass(DiscRecording, "DRTrack");

package/dist/DiscRecordingUI/index.js

@@ -1,8 +1,9 @@
 // AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
 import { NobjcLibrary } from "objc-js";
+import { _bindClass } from "../bind.js";
 export const DiscRecordingUI = new NobjcLibrary("/System/Library/Frameworks/DiscRecordingUI.framework/DiscRecordingUI");
-export const DRBurnProgressPanel = DiscRecordingUI["DRBurnProgressPanel"];
-export const DRBurnSetupPanel = DiscRecordingUI["DRBurnSetupPanel"];
-export const DREraseProgressPanel = DiscRecordingUI["DREraseProgressPanel"];
-export const DREraseSetupPanel = DiscRecordingUI["DREraseSetupPanel"];
-export const DRSetupPanel = DiscRecordingUI["DRSetupPanel"];
+export const DRBurnProgressPanel = _bindClass(DiscRecordingUI, "DRBurnProgressPanel");
+export const DRBurnSetupPanel = _bindClass(DiscRecordingUI, "DRBurnSetupPanel");
+export const DREraseProgressPanel = _bindClass(DiscRecordingUI, "DREraseProgressPanel");
+export const DREraseSetupPanel = _bindClass(DiscRecordingUI, "DREraseSetupPanel");
+export const DRSetupPanel = _bindClass(DiscRecordingUI, "DRSetupPanel");

package/dist/EventKit/EKEventStore.d.ts

@@ -61,11 +61,11 @@ export declare class _EKEventStore extends _NSObject {
     /**
      * @method saveCalendar:commit:error: @abstract Saves changes to a calendar, or adds a new calendar to the database. @discussion This method attempts to save the given calendar to the calendar database. It returns YES if successful and NO otherwise. Passing a calendar fetched from another EKEventStore instance into this function will raise an exception. On WatchOS, saving changes is not supported. @param calendar The calendar to save. @param commit Pass YES to cause the database to save. You can pass NO to save multiple calendars and then call commit: to save them all at once. @param error If an error occurs, this will contain a valid NSError object on exit.
      */
-    saveCalendar$commit$error$(calendar: _EKCalendar, commit: boolean, error: NobjcObject): boolean;
+    saveCalendar$commit$error$(calendar: _EKCalendar, commit: boolean, error: NobjcObject | null): boolean;
     /**
      * @method removeCalendar:commit:error: @abstract Removes a calendar from the database. @discussion This method attempts to delete the given calendar from the calendar database. It returns YES if successful and NO otherwise. Passing a calendar fetched from another EKEventStore instance into this function will raise an exception. If the calendar supports multiple entity types (allowedEntityTypes), but the user has not granted you access to all those entity types, then we will delete all of the entity types for which you have access and remove that entity type from the allowedEntityTypes. For example: If a calendar supports both events and reminders, but you only have access to reminders, we will delete all the reminders and make the calendar only support events. If you have access to all of its allowedEntityTypes, then it will delete the calendar and all of the events and reminders in the calendar. On WatchOS, modifying the database is not supported. @param calendar The calendar to delete. @param commit Pass YES to cause the database to save. You can pass NO to batch multiple changes and then call commit: to save them all at once. @param error If an error occurs, this will contain a valid NSError object on exit.
      */
-    removeCalendar$commit$error$(calendar: _EKCalendar, commit: boolean, error: NobjcObject): boolean;
+    removeCalendar$commit$error$(calendar: _EKCalendar, commit: boolean, error: NobjcObject | null): boolean;
     /**
      * @method calendarItemWithIdentifier: @abstract Returns either a reminder or the first occurrence of an event.
      */
@@ -77,16 +77,16 @@ export declare class _EKEventStore extends _NSObject {
     /**
      * @method saveEvent:span:error: @abstract Saves changes to an event permanently. @discussion This method attempts to save the event to the calendar database. It returns YES if successful and NO otherwise. It's possible for this method to return NO, and error will be set to nil. This occurs if the event wasn't dirty and didn't need saving. This means the correct way to detect failure is a result of NO and a non-nil error parameter. Passing an event fetched from another EKEventStore instance into this function will raise an exception. After an event is successfully saved, it is also put into sync with the database, meaning that all fields you did not change will be updated to the latest values. If you save the event, but it was deleted by a different store/process, you will effectively recreate the event as a new event. On WatchOS, saving changes is not supported. @param event The event to save. @param span The span to use (this event, or this and future events). @param error If an error occurs, this will contain a valid NSError object on exit.
      */
-    saveEvent$span$error$(event: _EKEvent, span: EKSpan, error: NobjcObject): boolean;
+    saveEvent$span$error$(event: _EKEvent, span: EKSpan, error: NobjcObject | null): boolean;
     /**
      * @method removeEvent:span:error: @abstract Removes an event from the calendar store. @discussion This method attempts to remove the event from the calendar database. It returns YES if successful and NO otherwise. It's possible for this method to return NO, and error will be set to nil. This occurs if the event wasn't ever added and didn't need removing. This means the correct way to detect failure is a result of NO and a non-nil error parameter. Passing an event from another CalendarStore into this function will raise an exception. After an event is removed, it is no longer tied to this calendar store, and all data in the event is cleared except for the eventIdentifier. On WatchOS, modifying the database is not supported. @param event The event to save. @param span The span to use (this event, or this and future events). @param error If an error occurs, this will contain a valid NSError object on exit.
      */
-    removeEvent$span$error$(event: _EKEvent, span: EKSpan, error: NobjcObject): boolean;
+    removeEvent$span$error$(event: _EKEvent, span: EKSpan, error: NobjcObject | null): boolean;
     /**
      * These variants of the above allow you to batch changes by passing NO to commit. You can commit all changes later with [EKEventStore commit:]
      */
-    saveEvent$span$commit$error$(event: _EKEvent, span: EKSpan, commit: boolean, error: NobjcObject): boolean;
-    removeEvent$span$commit$error$(event: _EKEvent, span: EKSpan, commit: boolean, error: NobjcObject): boolean;
+    saveEvent$span$commit$error$(event: _EKEvent, span: EKSpan, commit: boolean, error: NobjcObject | null): boolean;
+    removeEvent$span$commit$error$(event: _EKEvent, span: EKSpan, commit: boolean, error: NobjcObject | null): boolean;
     /**
      * @method eventWithIdentifier: @abstract Returns the first occurrence of an event matching the given event identifier. @param identifier The eventIdentifier to search for. @result An EKEvent object, or nil if not found.
      */
@@ -106,15 +106,15 @@ export declare class _EKEventStore extends _NSObject {
     /**
      * @method saveReminder:commit:error: @abstract Saves changes to a reminder. @discussion This method attempts to save the reminder to the event store database. It returns YES if successful and NO otherwise. Passing a reminder fetched from another EKEventStore instance into this function will raise an exception. After a reminder is successfully saved, its fields are updated to the latest values in the database. On WatchOS, saving changes is not supported. @param reminder The reminder to save. @param commit Whether to save to the database or not. Pass NO to batch changes together and commit with [EKEventStore commit:]. @param error If an error occurs, this will contain a valid NSError object on exit.
      */
-    saveReminder$commit$error$(reminder: _EKReminder, commit: boolean, error: NobjcObject): boolean;
+    saveReminder$commit$error$(reminder: _EKReminder, commit: boolean, error: NobjcObject | null): boolean;
     /**
      * @method removeReminder:commit:error: @abstract Removes a reminder from the event store. @discussion This method attempts to remove the reminder from the event store database. It returns YES if successful and NO otherwise. Passing a reminder from another EKEventStore into this function will raise an exception. After a reminder is removed, it is no longer tied to this event store. On WatchOS, modifying the database is not supported. @param reminder The reminder to save. @param commit Whether to save to the database or not. Pass NO to batch changes together and commit with [EKEventStore commit:]. @param error If an error occurs, this will contain a valid NSError object on exit.
      */
-    removeReminder$commit$error$(reminder: _EKReminder, commit: boolean, error: NobjcObject): boolean;
+    removeReminder$commit$error$(reminder: _EKReminder, commit: boolean, error: NobjcObject | null): boolean;
     /**
      * @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): NobjcObject;
+    fetchRemindersMatchingPredicate$completion$(predicate: _NSPredicate, completion: NobjcObject | 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.
      */
@@ -134,7 +134,7 @@ export declare class _EKEventStore extends _NSObject {
     /**
      * @method commit: @abstract Commits pending changes to the database. @discussion If you use saveCalendar/saveEvent/removeCalendar/removeEvent, etc. and you pass NO to their parameter, you are batching changes for a later commit. This method does that commit. This allows you to save the database only once for many additions or changes. If you pass YES to methods' commit parameter, then you don't need to call this method. This method will return YES as long as nothing went awry, even if nothing was actually committed. If it returns NO, error should contain the reason it became unhappy. On WatchOS, modifying the database is not supported.
      */
-    commit$(error: NobjcObject): boolean;
+    commit$(error: NobjcObject | null): boolean;
     /**
      * @method reset @abstract Resets the event store. @discussion You can use this method to forget ALL changes made to the event store (all additions, all fetched objects, etc.). It essentially is as if you released the store and then created a new one. It brings it back to its initial state. All objects ever created/fetched, etc. using this store are no longer connected to it and are considered invalid.
      */

package/dist/EventKit/EKParticipant.d.ts

@@ -1,9 +1,9 @@
 import type { _EKObject } from "./EKObject.js";
-import type { _ABAddressBook } from "../AddressBook/ABAddressBook.js";
-import type { _ABPerson } from "../AddressBook/ABPerson.js";
 import type { _NSPredicate } from "../Foundation/NSPredicate.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
+import type { _ABAddressBook } from "../AddressBook/ABAddressBook.js";
+import type { _ABPerson } from "../AddressBook/ABPerson.js";
 import type { EKParticipantRole } from "./EKParticipantRole.js";
 import type { EKParticipantStatus } from "./EKParticipantStatus.js";
 import type { EKParticipantType } from "./EKParticipantType.js";

package/dist/EventKit/EKRecurrenceDayOfWeek.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { EKWeekday } from "./EKWeekday.js";
 export declare class _EKRecurrenceDayOfWeek extends _NSObject {
     static alloc(): _EKRecurrenceDayOfWeek;
@@ -22,3 +23,5 @@ export declare class _EKRecurrenceDayOfWeek extends _NSObject {
     /** @property weekNumber @abstract The week number. */
     weekNumber(): number;
 }
+export interface _EKRecurrenceDayOfWeek extends _NSSecureCoding {
+}

package/dist/EventKit/EKRecurrenceEnd.d.ts

@@ -1,5 +1,6 @@
 import type { _NSDate } from "../Foundation/NSDate.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 export declare class _EKRecurrenceEnd extends _NSObject {
     static alloc(): _EKRecurrenceEnd;
     static new(): _EKRecurrenceEnd;
@@ -21,3 +22,5 @@ export declare class _EKRecurrenceEnd extends _NSObject {
      */
     occurrenceCount(): number;
 }
+export interface _EKRecurrenceEnd extends _NSSecureCoding {
+}

package/dist/EventKit/EKStructuredLocation.d.ts

@@ -10,8 +10,8 @@ export declare class _EKStructuredLocation extends _EKObject {
     static locationWithMapItem$(mapItem: _MKMapItem): _EKStructuredLocation;
     title(): _NSString | null;
     setTitle$(value: _NSString | null): void;
-    geoLocation(): NobjcObject;
-    setGeoLocation$(value: NobjcObject): void;
+    geoLocation(): NobjcObject | null;
+    setGeoLocation$(value: NobjcObject | null): void;
     /** 0 = use default, unit is meters */
     radius(): number;
     setRadius$(value: number): void;

package/dist/EventKit/EKVirtualConferenceProvider.d.ts

@@ -1,5 +1,7 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSExtensionRequestHandling } from "../Foundation/NSExtensionRequestHandling.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSString } from "../Foundation/NSString.js";
 export declare class _EKVirtualConferenceProvider extends _NSObject {
     static alloc(): _EKVirtualConferenceProvider;
     static new(): _EKVirtualConferenceProvider;
@@ -7,9 +9,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): void;
+    fetchAvailableRoomTypesWithCompletionHandler$(completionHandler: NobjcObject | 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: NobjcObject, completionHandler: NobjcObject): void;
+    fetchVirtualConferenceForIdentifier$completionHandler$(identifier: _NSString, completionHandler: NobjcObject | null): void;
+}
+export interface _EKVirtualConferenceProvider extends _NSExtensionRequestHandling {
 }

package/dist/EventKit/EKVirtualConferenceRoomTypeDescriptor.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 export declare class _EKVirtualConferenceRoomTypeDescriptor extends _NSObject {
@@ -8,7 +7,7 @@ export declare class _EKVirtualConferenceRoomTypeDescriptor extends _NSObject {
     /**
      * @method initWithTitle:identifier: @abstract Initializes an instance of EKVirtualConferenceRoomTypeDescriptor. @param title A user-readable title describing this room type. This string will be displayed in UI. @param identifier An EKVirtualConferenceRoomTypeIdentifier that your extension can use to distinguish this room type from the other room types that your extension provides. This is chosen by your extension and is passed back to your extension if the user chooses to create a virtual conference of the associated room type.
      */
-    initWithTitle$identifier$(title: _NSString, identifier: NobjcObject): _EKVirtualConferenceRoomTypeDescriptor;
+    initWithTitle$identifier$(title: _NSString, identifier: _NSString): _EKVirtualConferenceRoomTypeDescriptor;
     title(): _NSString;
-    identifier(): NobjcObject;
+    identifier(): _NSString;
 }