internxt-crypto 0.0.10-alpha → 0.0.11

package/dist/hash.d.mts

@@ -1,19 +1,20 @@
+//#region src/hash/blake3.d.ts
 /**
  * Hashes the given array of data
  *
  * @param data - The data to hash
  * @returns The resulting hash array
  */
-declare function hashData(data: Uint8Array[]): Uint8Array;
-declare function keyedHashHex(hashKey: Uint8Array, data: Uint8Array[]): string;
-declare function keyedHash(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array;
+declare function hashDataArray(data: Uint8Array[]): Uint8Array;
 /**
  * Hashes the given array of data
  *
  * @param data - The data to hash
  * @returns The resulting hash hex string
  */
-declare function hashDataHex(data: Uint8Array[]): string;
+declare function hashDataArrayHex(data: Uint8Array[]): string;
+declare function hashDataArrayWithKeyHex(hashKey: Uint8Array, data: Uint8Array[]): string;
+declare function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array;
 /**
  * Hashes the given array of data using blake3 algorithm
  *
@@ -21,7 +22,7 @@ declare function hashDataHex(data: Uint8Array[]): string;
  * @param data - The data to hash
  * @returns The resulting hash value
  */
-declare function getBytesFromData(bytes: number, data: Uint8Array[]): Uint8Array;
+declare function getBytesFromDataArray(bytes: number, data: Uint8Array[]): Uint8Array;
 /**
  * Hashes the given array of data using blake3 algorithm
  *
@@ -29,24 +30,25 @@ declare function getBytesFromData(bytes: number, data: Uint8Array[]): Uint8Array
  * @param data - The data to hash
  * @returns The resulting hash value
  */
-declare function getBytesFromDataHex(bytes: number, data: Uint8Array[]): string;
+declare function getBytesFromDataArrayHex(bytes: number, data: Uint8Array[]): string;
 /**
  * Hashes the given string using blake3 algorithm
  *
  * @param bytes - The desired output byte-length
- * @param value - The string to hash
+ * @param data - The data to hash
  * @returns The resulting hash value
  */
-declare function getBytesFromString(bytes: number, value: string): Uint8Array;
+declare function getBytesFromData(bytes: number, data: Uint8Array): Uint8Array;
 /**
- * Hashes the given string using blake3 algorithm
+ * Hashes the given data using blake3 algorithm
  *
  * @param bytes - The desired output byte-length
- * @param value - The string to hash
+ * @param data - The data to hash
  * @returns The resulting hash value
  */
-declare function getBytesFromStrinHex(bytes: number, value: string): string;
-
+declare function getBytesFromDataHex(bytes: number, data: Uint8Array): string;
+//#endregion
+//#region src/hash/mac.d.ts
 /**
  * Computes mac for the given key material and data
  *
@@ -54,6 +56,10 @@ declare function getBytesFromStrinHex(bytes: number, value: string): string;
  * @param data - The data to hash
  * @returns The resulting hash hex string
  */
-declare function computeMac(keyMaterial: string, data: Uint8Array[]): string;
-
-export { computeMac, getBytesFromData, getBytesFromDataHex, getBytesFromStrinHex, getBytesFromString, hashData, hashDataHex, keyedHash, keyedHashHex };
+declare function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string;
+declare namespace index_d_exports {
+  export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
+}
+//#endregion
+export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, index_d_exports as t };
+//# sourceMappingURL=hash.d.mts.map

package/dist/hash.d.ts

@@ -1,19 +1,20 @@
+//#region src/hash/blake3.d.ts
 /**
  * Hashes the given array of data
  *
  * @param data - The data to hash
  * @returns The resulting hash array
  */
-declare function hashData(data: Uint8Array[]): Uint8Array;
-declare function keyedHashHex(hashKey: Uint8Array, data: Uint8Array[]): string;
-declare function keyedHash(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array;
+declare function hashDataArray(data: Uint8Array[]): Uint8Array;
 /**
  * Hashes the given array of data
  *
  * @param data - The data to hash
  * @returns The resulting hash hex string
  */
-declare function hashDataHex(data: Uint8Array[]): string;
+declare function hashDataArrayHex(data: Uint8Array[]): string;
+declare function hashDataArrayWithKeyHex(hashKey: Uint8Array, data: Uint8Array[]): string;
+declare function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array;
 /**
  * Hashes the given array of data using blake3 algorithm
  *
@@ -21,7 +22,7 @@ declare function hashDataHex(data: Uint8Array[]): string;
  * @param data - The data to hash
  * @returns The resulting hash value
  */
-declare function getBytesFromData(bytes: number, data: Uint8Array[]): Uint8Array;
+declare function getBytesFromDataArray(bytes: number, data: Uint8Array[]): Uint8Array;
 /**
  * Hashes the given array of data using blake3 algorithm
  *
@@ -29,24 +30,25 @@ declare function getBytesFromData(bytes: number, data: Uint8Array[]): Uint8Array
  * @param data - The data to hash
  * @returns The resulting hash value
  */
-declare function getBytesFromDataHex(bytes: number, data: Uint8Array[]): string;
+declare function getBytesFromDataArrayHex(bytes: number, data: Uint8Array[]): string;
 /**
  * Hashes the given string using blake3 algorithm
  *
  * @param bytes - The desired output byte-length
- * @param value - The string to hash
+ * @param data - The data to hash
  * @returns The resulting hash value
  */
-declare function getBytesFromString(bytes: number, value: string): Uint8Array;
+declare function getBytesFromData(bytes: number, data: Uint8Array): Uint8Array;
 /**
- * Hashes the given string using blake3 algorithm
+ * Hashes the given data using blake3 algorithm
  *
  * @param bytes - The desired output byte-length
- * @param value - The string to hash
+ * @param data - The data to hash
  * @returns The resulting hash value
  */
-declare function getBytesFromStrinHex(bytes: number, value: string): string;
-
+declare function getBytesFromDataHex(bytes: number, data: Uint8Array): string;
+//#endregion
+//#region src/hash/mac.d.ts
 /**
  * Computes mac for the given key material and data
  *
@@ -54,6 +56,10 @@ declare function getBytesFromStrinHex(bytes: number, value: string): string;
  * @param data - The data to hash
  * @returns The resulting hash hex string
  */
-declare function computeMac(keyMaterial: string, data: Uint8Array[]): string;
-
-export { computeMac, getBytesFromData, getBytesFromDataHex, getBytesFromStrinHex, getBytesFromString, hashData, hashDataHex, keyedHash, keyedHashHex };
+declare function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string;
+declare namespace index_d_exports {
+  export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };
+}
+//#endregion
+export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, index_d_exports as t };
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.js

@@ -1,95 +1,11 @@
-'use strict';
-
-var blake3_js = require('@noble/hashes/blake3.js');
-var utils_js = require('@noble/hashes/utils.js');
-
-// src/hash/blake3.ts
-function hashData(data) {
-  try {
-    const hasher = blake3_js.blake3.create();
-    for (const d of data) {
-      hasher.update(d);
-    }
-    return hasher.digest();
-  } catch (error) {
-    throw new Error("Failed to compute hash", { cause: error });
-  }
-}
-function keyedHashHex(hashKey, data) {
-  try {
-    const hash = keyedHash(hashKey, data);
-    return utils_js.bytesToHex(hash);
-  } catch (error) {
-    throw new Error("Failed to compute hash hex", { cause: error });
-  }
-}
-function keyedHash(hashKey, data) {
-  try {
-    const hasher = blake3_js.blake3.create({ key: hashKey });
-    for (const d of data) {
-      hasher.update(d);
-    }
-    return hasher.digest();
-  } catch (error) {
-    throw new Error("Failed to compute hash", { cause: error });
-  }
-}
-function hashDataHex(data) {
-  try {
-    const hash = hashData(data);
-    return utils_js.bytesToHex(hash);
-  } catch (error) {
-    throw new Error("Failed to compute hash", { cause: error });
-  }
-}
-function getBytesFromData(bytes, data) {
-  try {
-    const hasher = blake3_js.blake3.create({ dkLen: bytes });
-    for (const chunk of data) {
-      hasher.update(chunk);
-    }
-    return hasher.digest();
-  } catch (error) {
-    throw new Error("Failed to get bytes from data", { cause: error });
-  }
-}
-function getBytesFromDataHex(bytes, data) {
-  try {
-    const hash = getBytesFromData(bytes, data);
-    return utils_js.bytesToHex(hash);
-  } catch (error) {
-    throw new Error("Failed to get bytes from data", { cause: error });
-  }
-}
-function getBytesFromString(bytes, value) {
-  return blake3_js.blake3(utils_js.utf8ToBytes(value), { dkLen: bytes });
-}
-function getBytesFromStrinHex(bytes, value) {
-  return utils_js.bytesToHex(getBytesFromString(bytes, value));
-}
-
-// src/constants.ts
-var AES_KEY_BIT_LENGTH = 256;
-
-// src/hash/mac.ts
-function computeMac(keyMaterial, data) {
-  try {
-    const key = getBytesFromString(AES_KEY_BIT_LENGTH / 8, keyMaterial);
-    const hash = keyedHash(key, data);
-    return utils_js.bytesToHex(hash);
-  } catch (error) {
-    throw new Error("Failed to compute mac", { cause: error });
-  }
-}
-
-exports.computeMac = computeMac;
-exports.getBytesFromData = getBytesFromData;
-exports.getBytesFromDataHex = getBytesFromDataHex;
-exports.getBytesFromStrinHex = getBytesFromStrinHex;
-exports.getBytesFromString = getBytesFromString;
-exports.hashData = hashData;
-exports.hashDataHex = hashDataHex;
-exports.keyedHash = keyedHash;
-exports.keyedHashHex = keyedHashHex;
-//# sourceMappingURL=hash.js.map
-//# sourceMappingURL=hash.js.map
+const require_hash = require('./hash-BoqwNkcd.js');
+
+exports.computeMac = require_hash.computeMac;
+exports.getBytesFromData = require_hash.getBytesFromData;
+exports.getBytesFromDataArray = require_hash.getBytesFromDataArray;
+exports.getBytesFromDataArrayHex = require_hash.getBytesFromDataArrayHex;
+exports.getBytesFromDataHex = require_hash.getBytesFromDataHex;
+exports.hashDataArray = require_hash.hashDataArray;
+exports.hashDataArrayHex = require_hash.hashDataArrayHex;
+exports.hashDataArrayWithKey = require_hash.hashDataArrayWithKey;
+exports.hashDataArrayWithKeyHex = require_hash.hashDataArrayWithKeyHex;

package/dist/hash.mjs

@@ -1,85 +1,3 @@
-import { blake3 } from '@noble/hashes/blake3.js';
-import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';
+import { a as getBytesFromDataArrayHex, c as hashDataArrayHex, i as getBytesFromDataArray, l as hashDataArrayWithKey, n as computeMac, o as getBytesFromDataHex, r as getBytesFromData, s as hashDataArray, u as hashDataArrayWithKeyHex } from "./hash-CXeGAwai.mjs";
 
-// src/hash/blake3.ts
-function hashData(data) {
-  try {
-    const hasher = blake3.create();
-    for (const d of data) {
-      hasher.update(d);
-    }
-    return hasher.digest();
-  } catch (error) {
-    throw new Error("Failed to compute hash", { cause: error });
-  }
-}
-function keyedHashHex(hashKey, data) {
-  try {
-    const hash = keyedHash(hashKey, data);
-    return bytesToHex(hash);
-  } catch (error) {
-    throw new Error("Failed to compute hash hex", { cause: error });
-  }
-}
-function keyedHash(hashKey, data) {
-  try {
-    const hasher = blake3.create({ key: hashKey });
-    for (const d of data) {
-      hasher.update(d);
-    }
-    return hasher.digest();
-  } catch (error) {
-    throw new Error("Failed to compute hash", { cause: error });
-  }
-}
-function hashDataHex(data) {
-  try {
-    const hash = hashData(data);
-    return bytesToHex(hash);
-  } catch (error) {
-    throw new Error("Failed to compute hash", { cause: error });
-  }
-}
-function getBytesFromData(bytes, data) {
-  try {
-    const hasher = blake3.create({ dkLen: bytes });
-    for (const chunk of data) {
-      hasher.update(chunk);
-    }
-    return hasher.digest();
-  } catch (error) {
-    throw new Error("Failed to get bytes from data", { cause: error });
-  }
-}
-function getBytesFromDataHex(bytes, data) {
-  try {
-    const hash = getBytesFromData(bytes, data);
-    return bytesToHex(hash);
-  } catch (error) {
-    throw new Error("Failed to get bytes from data", { cause: error });
-  }
-}
-function getBytesFromString(bytes, value) {
-  return blake3(utf8ToBytes(value), { dkLen: bytes });
-}
-function getBytesFromStrinHex(bytes, value) {
-  return bytesToHex(getBytesFromString(bytes, value));
-}
-
-// src/constants.ts
-var AES_KEY_BIT_LENGTH = 256;
-
-// src/hash/mac.ts
-function computeMac(keyMaterial, data) {
-  try {
-    const key = getBytesFromString(AES_KEY_BIT_LENGTH / 8, keyMaterial);
-    const hash = keyedHash(key, data);
-    return bytesToHex(hash);
-  } catch (error) {
-    throw new Error("Failed to compute mac", { cause: error });
-  }
-}
-
-export { computeMac, getBytesFromData, getBytesFromDataHex, getBytesFromStrinHex, getBytesFromString, hashData, hashDataHex, keyedHash, keyedHashHex };
-//# sourceMappingURL=hash.mjs.map
-//# sourceMappingURL=hash.mjs.map
+export { computeMac, getBytesFromData, getBytesFromDataArray, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex };

package/dist/index-CQqgKsbX.d.ts

@@ -0,0 +1,50 @@
+declare namespace localStorageService_d_exports {
+  export { LocalStorageService, localStorageService as default };
+}
+declare function get$1(key: string): string | null;
+declare function set$1(key: string, value: string): void;
+declare function removeItem$1(key: string): void;
+declare function exists$1(key: string): boolean;
+declare function clear$1(): void;
+declare const localStorageService: {
+  set: typeof set$1;
+  get: typeof get$1;
+  removeItem: typeof removeItem$1;
+  exists: typeof exists$1;
+  clear: typeof clear$1;
+};
+interface LocalStorageService {
+  set: (key: string, value: string) => void;
+  get: (key: string) => string | null;
+  removeItem: (key: string) => void;
+  exists: (key: string) => boolean;
+  clear: () => void;
+}
+declare namespace sessionStorageService_d_exports {
+  export { SessionStorageService, sessionStorageService as default };
+}
+declare function get(key: string): string | null;
+declare function set(key: string, value: string): void;
+declare function removeItem(key: string): void;
+declare function exists(key: string): boolean;
+declare function clear(): void;
+declare const sessionStorageService: {
+  set: typeof set;
+  get: typeof get;
+  removeItem: typeof removeItem;
+  exists: typeof exists;
+  clear: typeof clear;
+};
+interface SessionStorageService {
+  set: (key: string, value: string) => void;
+  get: (key: string) => string | null;
+  removeItem: (key: string) => void;
+  exists: (key: string) => boolean;
+  clear: () => void;
+}
+declare namespace index_d_exports {
+  export { localStorageService_d_exports as localStorageService, sessionStorageService_d_exports as sessionStorageService };
+}
+//#endregion
+export { sessionStorageService_d_exports as n, localStorageService_d_exports as r, index_d_exports as t };
+//# sourceMappingURL=index-CQqgKsbX.d.ts.map

package/dist/index-CintVUbp.d.ts

@@ -0,0 +1,97 @@
+//#region src/post-quantum-crypto/kyber768.d.ts
+/**
+ * Generates public and secret Kyber keys
+ *
+ * @param seed - The optional seed
+ * @returns The generated Kyber key pair.
+ */
+declare function generateKyberKeys$2(seed?: Uint8Array): {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+};
+/**
+ * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+ *
+ * @param publicKey - The public Kyber key
+ * @returns The resulting encapsulation and the generated shared secret.
+ */
+declare function encapsulateKyber$2(publicKey: Uint8Array): {
+  cipherText: Uint8Array;
+  sharedSecret: Uint8Array;
+};
+/**
+ * Decapsulates the encapsulated shared secret using Kyber algorithms
+ *
+ * @param cipherText - The encapsulated key
+ * @param secretKey - The private Kyber key
+ * @returns The resulting decapsulated shared secret.
+ */
+declare function decapsulateKyber$2(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+declare namespace kyber512_d_exports {
+  export { decapsulateKyber$1 as decapsulateKyber, encapsulateKyber$1 as encapsulateKyber, generateKyberKeys$1 as generateKyberKeys };
+}
+/**
+ * Generates public and secret Kyber keys
+ *
+ * @param seed - The optional seed
+ * @returns The generated Kyber key pair.
+ */
+declare function generateKyberKeys$1(seed?: Uint8Array): {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+};
+/**
+ * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+ *
+ * @param publicKey - The public Kyber key
+ * @returns The resulting encapsulation and the generated shared secret.
+ */
+declare function encapsulateKyber$1(publicKey: Uint8Array): {
+  cipherText: Uint8Array;
+  sharedSecret: Uint8Array;
+};
+/**
+ * Decapsulates the encapsulated shared secret using Kyber algorithms
+ *
+ * @param cipherText - The encapsulated key
+ * @param secretKey - The private Kyber key
+ * @returns The resulting decapsulated shared secret.
+ */
+declare function decapsulateKyber$1(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+declare namespace kyber1024_d_exports {
+  export { decapsulateKyber, encapsulateKyber, generateKyberKeys };
+}
+/**
+ * Generates public and secret Kyber keys
+ *
+ * @param seed - The optional seed
+ * @returns The generated Kyber key pair.
+ */
+declare function generateKyberKeys(seed?: Uint8Array): {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+};
+/**
+ * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+ *
+ * @param publicKey - The public Kyber key
+ * @returns The resulting encapsulation and the generated shared secret.
+ */
+declare function encapsulateKyber(publicKey: Uint8Array): {
+  cipherText: Uint8Array;
+  sharedSecret: Uint8Array;
+};
+/**
+ * Decapsulates the encapsulated shared secret using Kyber algorithms
+ *
+ * @param cipherText - The encapsulated key
+ * @param secretKey - The private Kyber key
+ * @returns The resulting decapsulated shared secret.
+ */
+declare function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+declare namespace index_d_exports {
+  export { decapsulateKyber$2 as decapsulateKyber, encapsulateKyber$2 as encapsulateKyber, generateKyberKeys$2 as generateKyberKeys, kyber1024_d_exports as kyber1024, kyber512_d_exports as kyber512 };
+}
+//#endregion
+export { encapsulateKyber$2 as a, decapsulateKyber$2 as i, kyber1024_d_exports as n, generateKyberKeys$2 as o, kyber512_d_exports as r, index_d_exports as t };
+//# sourceMappingURL=index-CintVUbp.d.ts.map

package/dist/index-D5pBU_A5.d.mts

@@ -0,0 +1,50 @@
+declare namespace localStorageService_d_exports {
+  export { LocalStorageService, localStorageService as default };
+}
+declare function get$1(key: string): string | null;
+declare function set$1(key: string, value: string): void;
+declare function removeItem$1(key: string): void;
+declare function exists$1(key: string): boolean;
+declare function clear$1(): void;
+declare const localStorageService: {
+  set: typeof set$1;
+  get: typeof get$1;
+  removeItem: typeof removeItem$1;
+  exists: typeof exists$1;
+  clear: typeof clear$1;
+};
+interface LocalStorageService {
+  set: (key: string, value: string) => void;
+  get: (key: string) => string | null;
+  removeItem: (key: string) => void;
+  exists: (key: string) => boolean;
+  clear: () => void;
+}
+declare namespace sessionStorageService_d_exports {
+  export { SessionStorageService, sessionStorageService as default };
+}
+declare function get(key: string): string | null;
+declare function set(key: string, value: string): void;
+declare function removeItem(key: string): void;
+declare function exists(key: string): boolean;
+declare function clear(): void;
+declare const sessionStorageService: {
+  set: typeof set;
+  get: typeof get;
+  removeItem: typeof removeItem;
+  exists: typeof exists;
+  clear: typeof clear;
+};
+interface SessionStorageService {
+  set: (key: string, value: string) => void;
+  get: (key: string) => string | null;
+  removeItem: (key: string) => void;
+  exists: (key: string) => boolean;
+  clear: () => void;
+}
+declare namespace index_d_exports {
+  export { localStorageService_d_exports as localStorageService, sessionStorageService_d_exports as sessionStorageService };
+}
+//#endregion
+export { sessionStorageService_d_exports as n, localStorageService_d_exports as r, index_d_exports as t };
+//# sourceMappingURL=index-D5pBU_A5.d.mts.map

package/dist/index-MaOov-ag.d.mts

@@ -0,0 +1,97 @@
+//#region src/post-quantum-crypto/kyber768.d.ts
+/**
+ * Generates public and secret Kyber keys
+ *
+ * @param seed - The optional seed
+ * @returns The generated Kyber key pair.
+ */
+declare function generateKyberKeys$2(seed?: Uint8Array): {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+};
+/**
+ * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+ *
+ * @param publicKey - The public Kyber key
+ * @returns The resulting encapsulation and the generated shared secret.
+ */
+declare function encapsulateKyber$2(publicKey: Uint8Array): {
+  cipherText: Uint8Array;
+  sharedSecret: Uint8Array;
+};
+/**
+ * Decapsulates the encapsulated shared secret using Kyber algorithms
+ *
+ * @param cipherText - The encapsulated key
+ * @param secretKey - The private Kyber key
+ * @returns The resulting decapsulated shared secret.
+ */
+declare function decapsulateKyber$2(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+declare namespace kyber512_d_exports {
+  export { decapsulateKyber$1 as decapsulateKyber, encapsulateKyber$1 as encapsulateKyber, generateKyberKeys$1 as generateKyberKeys };
+}
+/**
+ * Generates public and secret Kyber keys
+ *
+ * @param seed - The optional seed
+ * @returns The generated Kyber key pair.
+ */
+declare function generateKyberKeys$1(seed?: Uint8Array): {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+};
+/**
+ * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+ *
+ * @param publicKey - The public Kyber key
+ * @returns The resulting encapsulation and the generated shared secret.
+ */
+declare function encapsulateKyber$1(publicKey: Uint8Array): {
+  cipherText: Uint8Array;
+  sharedSecret: Uint8Array;
+};
+/**
+ * Decapsulates the encapsulated shared secret using Kyber algorithms
+ *
+ * @param cipherText - The encapsulated key
+ * @param secretKey - The private Kyber key
+ * @returns The resulting decapsulated shared secret.
+ */
+declare function decapsulateKyber$1(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+declare namespace kyber1024_d_exports {
+  export { decapsulateKyber, encapsulateKyber, generateKyberKeys };
+}
+/**
+ * Generates public and secret Kyber keys
+ *
+ * @param seed - The optional seed
+ * @returns The generated Kyber key pair.
+ */
+declare function generateKyberKeys(seed?: Uint8Array): {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+};
+/**
+ * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+ *
+ * @param publicKey - The public Kyber key
+ * @returns The resulting encapsulation and the generated shared secret.
+ */
+declare function encapsulateKyber(publicKey: Uint8Array): {
+  cipherText: Uint8Array;
+  sharedSecret: Uint8Array;
+};
+/**
+ * Decapsulates the encapsulated shared secret using Kyber algorithms
+ *
+ * @param cipherText - The encapsulated key
+ * @param secretKey - The private Kyber key
+ * @returns The resulting decapsulated shared secret.
+ */
+declare function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+declare namespace index_d_exports {
+  export { decapsulateKyber$2 as decapsulateKyber, encapsulateKyber$2 as encapsulateKyber, generateKyberKeys$2 as generateKyberKeys, kyber1024_d_exports as kyber1024, kyber512_d_exports as kyber512 };
+}
+//#endregion
+export { encapsulateKyber$2 as a, decapsulateKyber$2 as i, kyber1024_d_exports as n, generateKyberKeys$2 as o, kyber512_d_exports as r, index_d_exports as t };
+//# sourceMappingURL=index-MaOov-ag.d.mts.map