@openwallet-foundation/askar-react-native 0.7.0-alpha-20261028112522 → 0.7.0-alpha-20261028113056

package/build/index.d.mts

@@ -0,0 +1 @@
+export * from "@openwallet-foundation/askar-shared";

package/build/index.mjs

@@ -0,0 +1,619 @@
+import { AeadParams, ArcHandle, AskarError, EncryptedBuffer, EntryListHandle, Jwk, Key, KeyEntryListHandle, LocalKeyHandle, NativeAskar, ScanHandle, SessionHandle, StoreHandle, handleInvalidNullResponse } from "@openwallet-foundation/askar-shared";
+import { NativeModules } from "react-native";
+export * from "@openwallet-foundation/askar-shared";
+// src/serialize.ts
+const serialize = (arg) => {
+	switch (typeof arg) {
+		case "undefined": return arg;
+		case "string": return arg;
+		case "boolean": return Number(arg);
+		case "number": return arg;
+		case "function": return arg;
+		case "object":
+			if (arg instanceof Date) return arg.valueOf();
+			if (arg instanceof Uint8Array) return arg.buffer;
+			if (arg instanceof Jwk) return arg.toUint8Array().buffer;
+			if (arg instanceof Key) return arg.handle.handle;
+			if (arg instanceof StoreHandle || arg instanceof SessionHandle || arg instanceof ScanHandle || arg instanceof ArcHandle) return arg.handle;
+			return JSON.stringify(arg);
+		default: throw new Error(`Could not serialize value ${arg}`);
+	}
+};
+const serializeArguments = (args) => {
+	const retVal = {};
+	for (const [key, value] of Object.entries(args)) retVal[key] = serialize(value);
+	return retVal;
+};
+// src/ReactNativeAskar.ts
+var ReactNativeAskar = class {
+	constructor(bindings) {
+		this.askar = bindings;
+	}
+	/**
+	* Fetch the error from the native library and return it as a JS error
+	*
+	* NOTE:
+	* Checks whether the error code of the returned error matches the error code that was passed to the function.
+	* If it doesn't, we throw an error with the original errorCode, and a custom message explaining we weren't able
+	* to retrieve the error message from the native library. This should however not break functionality as long as
+	* error codes are used rather than error messages for error handling.
+	*
+	*/
+	getAskarError(errorCode) {
+		const error = this.getCurrentError();
+		if (error.code !== errorCode) return new AskarError({
+			code: errorCode,
+			message: "Error details have already been overwritten on the native side, unable to retrieve error message for the error"
+		});
+		return new AskarError(error);
+	}
+	handleError({ errorCode, value }) {
+		if (errorCode === 0) return value;
+		throw this.getAskarError(errorCode);
+	}
+	promisify(method) {
+		return new Promise((resolve, reject) => {
+			const _cb = ({ errorCode }) => {
+				try {
+					this.handleError({ errorCode });
+					resolve();
+				} catch (e) {
+					reject(e);
+				}
+			};
+			method(_cb);
+		});
+	}
+	promisifyWithResponse(method) {
+		return new Promise((resolve, reject) => {
+			const _cb = ({ errorCode, value }) => {
+				if (errorCode !== 0) reject(this.getAskarError(errorCode));
+				else if (value === void 0) reject(AskarError.customError({ message: "error code was 0 but no value found. This should not occur." }));
+				else resolve(value);
+			};
+			method(_cb);
+		});
+	}
+	version() {
+		return handleInvalidNullResponse(this.askar.version({}));
+	}
+	getCurrentError() {
+		const serializedError = handleInvalidNullResponse(this.askar.getCurrentError({}));
+		return JSON.parse(serializedError);
+	}
+	clearCustomLogger() {
+		throw new Error("Method not implemented. clearCustomLogger");
+	}
+	setCustomLogger() {
+		throw new Error("Method not implemented. setCustomLogger");
+	}
+	setDefaultLogger() {
+		this.askar.setDefaultLogger({});
+	}
+	setMaxLogLevel() {
+		throw new Error("Method not implemented. setMaxLogLevel");
+	}
+	argon2DerivePassword(options) {
+		const { config, ...rest } = options;
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.argon2DerivePassword({
+			...serializeArguments(rest),
+			...config && { config }
+		})));
+		return new Uint8Array(buf);
+	}
+	entryListCount(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.entryListCount(serializedOptions)));
+	}
+	entryListFree(options) {
+		const serializedOptions = serializeArguments(options);
+		this.handleError(this.askar.entryListFree(serializedOptions));
+	}
+	entryListGetCategory(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.entryListGetCategory(serializedOptions)));
+	}
+	entryListGetName(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.entryListGetName(serializedOptions)));
+	}
+	entryListGetTags(options) {
+		const serializedOptions = serializeArguments(options);
+		return this.handleError(this.askar.entryListGetTags(serializedOptions));
+	}
+	entryListGetValue(options) {
+		const serializedOptions = serializeArguments(options);
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.entryListGetValue(serializedOptions)));
+		return new Uint8Array(buf);
+	}
+	keyAeadDecrypt(options) {
+		const serializedOptions = serializeArguments(options);
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.keyAeadDecrypt(serializedOptions)));
+		return new Uint8Array(buf);
+	}
+	keyAeadEncrypt(options) {
+		const serializedOptions = serializeArguments(options);
+		const ret = this.handleError(this.askar.keyAeadEncrypt(serializedOptions));
+		const { buffer, noncePos, tagPos } = handleInvalidNullResponse(ret);
+		return new EncryptedBuffer({
+			tagPos,
+			noncePos,
+			buffer: new Uint8Array(buffer)
+		});
+	}
+	keyAeadGetPadding(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.keyAeadGetPadding(serializedOptions)));
+	}
+	keyAeadGetParams(options) {
+		const serializedOptions = serializeArguments(options);
+		const ret = this.handleError(this.askar.keyAeadGetParams(serializedOptions));
+		const { tagLength, nonceLength } = handleInvalidNullResponse(ret);
+		return new AeadParams({
+			nonceLength,
+			tagLength
+		});
+	}
+	keyAeadRandomNonce(options) {
+		const serializedOptions = serializeArguments(options);
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.keyAeadRandomNonce(serializedOptions)));
+		return new Uint8Array(buf);
+	}
+	keyConvert(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = handleInvalidNullResponse(this.handleError(this.askar.keyConvert(serializedOptions)));
+		return new LocalKeyHandle(handle);
+	}
+	keyCryptoBox(options) {
+		const serializedOptions = serializeArguments(options);
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.keyCryptoBox(serializedOptions)));
+		return new Uint8Array(buf);
+	}
+	keyCryptoBoxOpen(options) {
+		const serializedOptions = serializeArguments(options);
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.keyCryptoBoxOpen(serializedOptions)));
+		return new Uint8Array(buf);
+	}
+	keyCryptoBoxRandomNonce() {
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.keyCryptoBoxRandomNonce({})));
+		return new Uint8Array(buf);
+	}
+	keyCryptoBoxSeal(options) {
+		const serializedOptions = serializeArguments(options);
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.keyCryptoBoxSeal(serializedOptions)));
+		return new Uint8Array(buf);
+	}
+	keyCryptoBoxSealOpen(options) {
+		const serializedOptions = serializeArguments(options);
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.keyCryptoBoxSealOpen(serializedOptions)));
+		return new Uint8Array(buf);
+	}
+	keyDeriveEcdh1pu(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = handleInvalidNullResponse(this.handleError(this.askar.keyDeriveEcdh1pu(serializedOptions)));
+		return new LocalKeyHandle(handle);
+	}
+	keyDeriveEcdhEs(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = handleInvalidNullResponse(this.handleError(this.askar.keyDeriveEcdhEs(serializedOptions)));
+		return new LocalKeyHandle(handle);
+	}
+	keyEntryListCount(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.keyEntryListCount(serializedOptions)));
+	}
+	keyEntryListFree(options) {
+		const serializedOptions = serializeArguments(options);
+		this.handleError(this.askar.keyEntryListFree(serializedOptions));
+	}
+	keyEntryListGetAlgorithm(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.keyEntryListGetAlgorithm(serializedOptions)));
+	}
+	keyEntryListGetMetadata(options) {
+		const serializedOptions = serializeArguments(options);
+		return this.handleError(this.askar.keyEntryListGetMetadata(serializedOptions));
+	}
+	keyEntryListGetName(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.keyEntryListGetName(serializedOptions)));
+	}
+	keyEntryListGetTags(options) {
+		const serializedOptions = serializeArguments(options);
+		return this.handleError(this.askar.keyEntryListGetTags(serializedOptions));
+	}
+	keyEntryListLoadLocal(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = handleInvalidNullResponse(this.handleError(this.askar.keyEntryListLoadLocal(serializedOptions)));
+		return new LocalKeyHandle(handle);
+	}
+	keyFree(options) {
+		const serializedOptions = serializeArguments(options);
+		this.handleError(this.askar.keyFree(serializedOptions));
+	}
+	keyFromJwk(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = handleInvalidNullResponse(this.handleError(this.askar.keyFromJwk(serializedOptions)));
+		return new LocalKeyHandle(handle);
+	}
+	keyFromKeyExchange(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = handleInvalidNullResponse(this.handleError(this.askar.keyFromKeyExchange(serializedOptions)));
+		return new LocalKeyHandle(handle);
+	}
+	keyFromPublicBytes(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = handleInvalidNullResponse(this.handleError(this.askar.keyFromPublicBytes(serializedOptions)));
+		return new LocalKeyHandle(handle);
+	}
+	keyFromSecretBytes(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = handleInvalidNullResponse(this.handleError(this.askar.keyFromSecretBytes(serializedOptions)));
+		return new LocalKeyHandle(handle);
+	}
+	keyFromSeed(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = handleInvalidNullResponse(this.handleError(this.askar.keyFromSeed(serializedOptions)));
+		return new LocalKeyHandle(handle);
+	}
+	keyGenerate(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = handleInvalidNullResponse(this.handleError(this.askar.keyGenerate(serializedOptions)));
+		return new LocalKeyHandle(handleInvalidNullResponse(handle));
+	}
+	keyGetAlgorithm(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.keyGetAlgorithm(serializedOptions)));
+	}
+	keyGetEphemeral(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.keyGetEphemeral(serializedOptions)));
+	}
+	keyGetJwkPublic(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.keyGetJwkPublic(serializedOptions)));
+	}
+	keyGetJwkSecret(options) {
+		const serializedOptions = serializeArguments(options);
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.keyGetJwkSecret(serializedOptions)));
+		return new Uint8Array(buf);
+	}
+	keyGetJwkThumbprint(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.keyGetJwkThumbprint(serializedOptions)));
+	}
+	keyGetPublicBytes(options) {
+		const serializedOptions = serializeArguments(options);
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.keyGetPublicBytes(serializedOptions)));
+		return new Uint8Array(buf);
+	}
+	keyGetSupportedBackends() {
+		const stringListHandle = handleInvalidNullResponse(this.handleError(this.askar.keyGetSupportedBackends({})));
+		return this.stringListToArray(stringListHandle);
+	}
+	keyGetSecretBytes(options) {
+		const serializedOptions = serializeArguments(options);
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.keyGetSecretBytes(serializedOptions)));
+		return new Uint8Array(buf);
+	}
+	keySignMessage(options) {
+		const serializedOptions = serializeArguments(options);
+		const buf = handleInvalidNullResponse(this.handleError(this.askar.keySignMessage(serializedOptions)));
+		return new Uint8Array(buf);
+	}
+	keyUnwrapKey(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = handleInvalidNullResponse(this.handleError(this.askar.keyUnwrapKey(serializedOptions)));
+		return new LocalKeyHandle(handle);
+	}
+	keyVerifySignature(options) {
+		const serializedOptions = serializeArguments(options);
+		return !!this.handleError(this.askar.keyVerifySignature(serializedOptions));
+	}
+	keyWrapKey(options) {
+		const serializedOptions = serializeArguments(options);
+		const ret = this.handleError(this.askar.keyWrapKey(serializedOptions));
+		const { buffer, noncePos, tagPos } = handleInvalidNullResponse(ret);
+		return new EncryptedBuffer({
+			tagPos,
+			noncePos,
+			buffer: new Uint8Array(buffer)
+		});
+	}
+	scanFree(options) {
+		const serializedOptions = serializeArguments(options);
+		this.handleError(this.askar.scanFree(serializedOptions));
+	}
+	async scanNext(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = await this.promisifyWithResponse((cb) => this.handleError(this.askar.scanNext({
+			cb,
+			...serializedOptions
+		})));
+		return EntryListHandle.fromHandle(handle);
+	}
+	async scanStart(options) {
+		const { category, storeHandle, limit, offset, profile, tagFilter, orderBy, descending } = serializeArguments(options);
+		const handle = await this.promisifyWithResponse((cb) => this.handleError(this.askar.scanStart({
+			cb,
+			category,
+			storeHandle,
+			offset: offset || 0,
+			limit: limit || -1,
+			orderBy,
+			descending,
+			profile,
+			tagFilter
+		})));
+		return ScanHandle.fromHandle(handle);
+	}
+	sessionClose(options) {
+		const serializedOptions = serializeArguments(options);
+		return this.promisify((cb) => this.handleError(this.askar.sessionClose({
+			cb,
+			...serializedOptions
+		})));
+	}
+	async sessionCount(options) {
+		const serializedOptions = serializeArguments(options);
+		const response = await this.promisifyWithResponse((cb) => this.handleError(this.askar.sessionCount({
+			cb,
+			...serializedOptions
+		})));
+		return handleInvalidNullResponse(response);
+	}
+	async sessionFetch(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = await this.promisifyWithResponse((cb) => this.handleError(this.askar.sessionFetch({
+			cb,
+			...serializedOptions
+		})));
+		return EntryListHandle.fromHandle(handle);
+	}
+	async sessionFetchAll(options) {
+		const { category, sessionHandle, forUpdate, limit, tagFilter, descending, orderBy } = serializeArguments(options);
+		const handle = await this.promisifyWithResponse((cb) => this.handleError(this.askar.sessionFetchAll({
+			cb,
+			category,
+			sessionHandle,
+			forUpdate,
+			limit: limit || -1,
+			tagFilter,
+			orderBy,
+			descending
+		})));
+		return EntryListHandle.fromHandle(handle);
+	}
+	async sessionFetchAllKeys(options) {
+		const { sessionHandle, algorithm, forUpdate, limit, thumbprint, tagFilter } = serializeArguments(options);
+		const handle = await this.promisifyWithResponse((cb) => this.handleError(this.askar.sessionFetchAllKeys({
+			cb,
+			sessionHandle,
+			algorithm,
+			forUpdate: forUpdate || -1,
+			limit: limit || -1,
+			thumbprint,
+			tagFilter
+		})));
+		return KeyEntryListHandle.fromHandle(handle);
+	}
+	async sessionFetchKey(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = await this.promisifyWithResponse((cb) => this.handleError(this.askar.sessionFetchKey({
+			cb,
+			...serializedOptions
+		})));
+		return KeyEntryListHandle.fromHandle(handle);
+	}
+	sessionInsertKey(options) {
+		const { sessionHandle, name, localKeyHandle, expiryMs, metadata, tags } = serializeArguments(options);
+		return this.promisify((cb) => this.handleError(this.askar.sessionInsertKey({
+			cb,
+			sessionHandle,
+			name,
+			localKeyHandle,
+			expiryMs: expiryMs || -1,
+			metadata,
+			tags
+		})));
+	}
+	async sessionRemoveAll(options) {
+		const serializedOptions = serializeArguments(options);
+		const response = await this.promisifyWithResponse((cb) => this.handleError(this.askar.sessionRemoveAll({
+			cb,
+			...serializedOptions
+		})));
+		return handleInvalidNullResponse(response);
+	}
+	sessionRemoveKey(options) {
+		const serializedOptions = serializeArguments(options);
+		return this.promisify((cb) => this.handleError(this.askar.sessionRemoveKey({
+			cb,
+			...serializedOptions
+		})));
+	}
+	async sessionStart(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = await this.promisifyWithResponse((cb) => this.handleError(this.askar.sessionStart({
+			cb,
+			...serializedOptions
+		})));
+		return SessionHandle.fromHandle(handle);
+	}
+	sessionUpdate(options) {
+		const { category, name, operation, sessionHandle, expiryMs, tags, value } = serializeArguments(options);
+		return this.promisify((cb) => this.handleError(this.askar.sessionUpdate({
+			cb,
+			category,
+			name,
+			operation,
+			sessionHandle,
+			expiryMs: expiryMs || -1,
+			tags,
+			value
+		})));
+	}
+	sessionUpdateKey(options) {
+		const serializedOptions = serializeArguments({
+			...options,
+			expiryMs: options.expiryMs ?? -1
+		});
+		return this.promisify((cb) => this.handleError(this.askar.sessionUpdateKey({
+			cb,
+			...serializedOptions
+		})));
+	}
+	storeClose(options) {
+		const serializedOptions = serializeArguments(options);
+		return this.promisify((cb) => this.handleError(this.askar.storeClose({
+			cb,
+			...serializedOptions
+		})));
+	}
+	async storeCopyTo(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = await this.promisifyWithResponse((cb) => {
+			this.handleError(this.askar.storeCopy({
+				cb,
+				...serializedOptions
+			}));
+		});
+		return StoreHandle.fromHandle(handle);
+	}
+	async storeCreateProfile(options) {
+		const serializedOptions = serializeArguments(options);
+		const response = await this.promisifyWithResponse((cb) => this.handleError(this.askar.storeCreateProfile({
+			cb,
+			...serializedOptions
+		})));
+		return handleInvalidNullResponse(response);
+	}
+	storeGenerateRawKey(options) {
+		const serializedOptions = serializeArguments(options);
+		return handleInvalidNullResponse(this.handleError(this.askar.storeGenerateRawKey(serializedOptions)));
+	}
+	async storeGetProfileName(options) {
+		const serializedOptions = serializeArguments(options);
+		const response = await this.promisifyWithResponse((cb) => this.handleError(this.askar.storeGetProfileName({
+			cb,
+			...serializedOptions
+		})));
+		return handleInvalidNullResponse(response);
+	}
+	async storeGetDefaultProfile(options) {
+		const serializedOptions = serializeArguments(options);
+		const response = await this.promisifyWithResponse((cb) => this.handleError(this.askar.storeGetDefaultProfile({
+			cb,
+			...serializedOptions
+		})));
+		return handleInvalidNullResponse(response);
+	}
+	async storeListProfiles(options) {
+		const serializedOptions = serializeArguments(options);
+		const stringListHandle = handleInvalidNullResponse(await this.promisifyWithResponse((cb) => this.handleError(this.askar.storeListProfiles({
+			cb,
+			...serializedOptions
+		}))));
+		return this.stringListToArray(stringListHandle);
+	}
+	async storeListScans(options) {
+		const serializedOptions = serializeArguments(options);
+		const handles = await this.promisifyWithResponse((cb) => this.handleError(this.askar.storeListScans({
+			cb,
+			...serializedOptions
+		})));
+		return handleInvalidNullResponse(handles).map((handle) => ScanHandle.fromHandle(handle));
+	}
+	async storeListSessions(options) {
+		const serializedOptions = serializeArguments(options);
+		const handles = await this.promisifyWithResponse((cb) => this.handleError(this.askar.storeListSessions({
+			cb,
+			...serializedOptions
+		})));
+		return handleInvalidNullResponse(handles).map((handle) => SessionHandle.fromHandle(handle));
+	}
+	stringListToArray(stringListHandle) {
+		const items = [];
+		const count = this.handleError(this.askar.stringListCount({ stringListHandle }));
+		for (let index = 0; index < count; index++) items.push(this.handleError(this.askar.stringListGetItem({
+			stringListHandle,
+			index
+		})));
+		this.handleError(this.askar.stringListFree({ stringListHandle }));
+		return items;
+	}
+	async storeOpen(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = await this.promisifyWithResponse((cb) => this.handleError(this.askar.storeOpen({
+			cb,
+			...serializedOptions
+		})));
+		return StoreHandle.fromHandle(handle);
+	}
+	async storeProvision(options) {
+		const serializedOptions = serializeArguments(options);
+		const handle = await this.promisifyWithResponse((cb) => this.handleError(this.askar.storeProvision({
+			cb,
+			...serializedOptions
+		})));
+		return StoreHandle.fromHandle(handle);
+	}
+	storeRekey(options) {
+		const serializedOptions = serializeArguments(options);
+		return this.promisify((cb) => this.handleError(this.askar.storeRekey({
+			cb,
+			...serializedOptions
+		})));
+	}
+	async storeRemove(options) {
+		const serializedOptions = serializeArguments(options);
+		const response = await this.promisifyWithResponse((cb) => this.handleError(this.askar.storeRemove({
+			cb,
+			...serializedOptions
+		})));
+		return handleInvalidNullResponse(response);
+	}
+	async storeRemoveProfile(options) {
+		const serializedOptions = serializeArguments(options);
+		const response = await this.promisifyWithResponse((cb) => this.handleError(this.askar.storeRemoveProfile({
+			cb,
+			...serializedOptions
+		})));
+		return handleInvalidNullResponse(response);
+	}
+	async storeRenameProfile(options) {
+		const serializedOptions = serializeArguments(options);
+		const response = await this.promisifyWithResponse((cb) => this.handleError(this.askar.storeRenameProfile({
+			cb,
+			...serializedOptions
+		})));
+		return handleInvalidNullResponse(response);
+	}
+	async storeCopyProfile(options) {
+		const serializedOptions = serializeArguments(options);
+		return this.promisify((cb) => this.handleError(this.askar.storeCopyProfile({
+			cb,
+			...serializedOptions
+		})));
+	}
+	async storeSetDefaultProfile(options) {
+		const serializedOptions = serializeArguments(options);
+		return this.promisify((cb) => this.handleError(this.askar.storeSetDefaultProfile({
+			cb,
+			...serializedOptions
+		})));
+	}
+	async migrateIndySdk(options) {
+		const serializedOptions = serializeArguments(options);
+		return this.promisify((cb) => this.handleError(this.askar.migrateIndySdk({
+			cb,
+			...serializedOptions
+		})));
+	}
+};
+// src/index.ts
+if (!NativeModules.Askar.install()) throw Error("Unable to install the turboModule: askar");
+if (!_askar) throw Error("_askar has not been exposed on global. Something went wrong while installing the turboModule");
+NativeAskar.register(new ReactNativeAskar(_askar));
+
+//# sourceMappingURL=index.mjs.map