@credo-ts/core 0.6.1-pr-2091-20241119140918 → 0.6.1

package/build/modules/kms/jwk/kty/ec/ecSignature.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecSignature.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/ecSignature.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAcA;;;AAA8F,iBAA9E,mBAAA,CAA8E,YAAA,EAA5C,aAA4C,EAAA,GAAA,EAAxB,cAAwB,CAAA,KAAA,CAAA,CAAA,EAAA,gBAAA;;AAkC9F;;;;;;iBAAgB,mBAAA,eAAkC,oBAAoB,wBAAwB"}

package/build/modules/kms/jwk/kty/ec/ecSignature.mjs

@@ -0,0 +1,94 @@
+
+
+import { KeyManagementError } from "../../../error/KeyManagementError.mjs";
+import { ecCrvToCurveParams } from "./ecPublicKey.mjs";
+import { ECDSASigValue } from "@peculiar/asn1-ecc";
+import { AsnConvert } from "@peculiar/asn1-schema";
+
+//#region src/modules/kms/jwk/kty/ec/ecSignature.ts
+/**
+* Converts a RAW EC signature to DER format
+*
+* @param rawSignature - Raw signature as r || s concatenated values
+* @param crv - The EC crv of the key used for the signature
+* @returns DER encoded signature
+*/
+function rawEcSignatureToDer(rawSignature, crv) {
+	const pointBitLength = ecCrvToCurveParams[crv].pointBitLength;
+	const pointByteLength = Math.ceil(pointBitLength / 8);
+	if (rawSignature.length !== pointByteLength * 2) throw new KeyManagementError(`Invalid raw signature length for EC signature conversion. Expected ${pointByteLength * 2} bytes for crv ${crv}`);
+	const r = rawSignature.slice(0, pointByteLength);
+	const s = rawSignature.slice(pointByteLength);
+	const rValue = removeLeadingZeros(r);
+	const sValue = removeLeadingZeros(s);
+	const signature = new ECDSASigValue();
+	signature.r = new Uint8Array(ensurePositive(rValue)).buffer;
+	signature.s = new Uint8Array(ensurePositive(sValue)).buffer;
+	return new Uint8Array(AsnConvert.serialize(signature));
+}
+/**
+* Converts a DER encoded EC signature to RAW format
+*
+* @param derSignature - DER encoded signature
+* @param crv - The EC crv of the key used for the signature
+* @returns Raw signature as r || s concatenated values
+*/
+function derEcSignatureToRaw(derSignature, crv) {
+	const asn = AsnConvert.parse(derSignature, ECDSASigValue);
+	const pointBitLength = ecCrvToCurveParams[crv].pointBitLength;
+	const pointByteLength = Math.ceil(pointBitLength / 8);
+	const rPadded = padToLength(new Uint8Array(asn.r), pointByteLength);
+	const sPadded = padToLength(new Uint8Array(asn.s), pointByteLength);
+	const rawSignature = new Uint8Array(pointByteLength * 2);
+	rawSignature.set(rPadded, 0);
+	rawSignature.set(sPadded, pointByteLength);
+	return rawSignature;
+}
+/**
+* Helper function to remove unnecessary leading zeros from an integer representation
+*
+* @param data - The integer bytes
+* @returns - Data with leading zeros removed
+*/
+function removeLeadingZeros(data) {
+	let startIndex = 0;
+	while (startIndex < data.length - 1 && data[startIndex] === 0) startIndex++;
+	return data.slice(startIndex);
+}
+/**
+* Ensures an integer value is represented as positive in ASN.1 by
+* adding a leading zero if the high bit is set
+*
+* @param data - The integer bytes
+* @returns Data ensuring positive integer representation
+*/
+function ensurePositive(data) {
+	if (data.length > 0 && (data[0] & 128) !== 0) {
+		const result = new Uint8Array(data.length + 1);
+		result.set(data, 1);
+		return result;
+	}
+	return data;
+}
+/**
+* Pads an integer value to the specified length
+*
+* @param data - The integer bytes
+* @param targetLength - The desired length
+* @returns Padded data
+*/
+function padToLength(data, targetLength) {
+	if (data.length === targetLength) return data;
+	if (data.length > targetLength) {
+		const significantStart = data.length - targetLength;
+		for (let i = 0; i < significantStart; i++) if (data[i] !== 0) throw new KeyManagementError("Value too large for the specified point size");
+		return data.slice(significantStart);
+	}
+	const result = new Uint8Array(targetLength);
+	result.set(data, targetLength - data.length);
+	return result;
+}
+
+//#endregion
+export { derEcSignatureToRaw, rawEcSignatureToDer };
+//# sourceMappingURL=ecSignature.mjs.map

package/build/modules/kms/jwk/kty/ec/ecSignature.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecSignature.mjs","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/ecSignature.ts"],"sourcesContent":["import { ECDSASigValue } from '@peculiar/asn1-ecc'\nimport { AsnConvert } from '@peculiar/asn1-schema'\nimport type { AnyUint8Array, Uint8ArrayBuffer } from '../../../../../types'\nimport { KeyManagementError } from '../../../error/KeyManagementError'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecCrvToCurveParams } from './ecPublicKey'\n\n/**\n * Converts a RAW EC signature to DER format\n *\n * @param rawSignature - Raw signature as r || s concatenated values\n * @param crv - The EC crv of the key used for the signature\n * @returns DER encoded signature\n */\nexport function rawEcSignatureToDer(rawSignature: AnyUint8Array, crv: KmsJwkPublicEc['crv']): Uint8ArrayBuffer {\n  const pointBitLength = ecCrvToCurveParams[crv].pointBitLength\n  const pointByteLength = Math.ceil(pointBitLength / 8)\n\n  if (rawSignature.length !== pointByteLength * 2) {\n    throw new KeyManagementError(\n      `Invalid raw signature length for EC signature conversion. Expected ${pointByteLength * 2} bytes for crv ${crv}`\n    )\n  }\n\n  // Extract r and s values from the raw signature\n  const r = rawSignature.slice(0, pointByteLength)\n  const s = rawSignature.slice(pointByteLength)\n\n  // Remove leading zeros that aren't necessary for ASN.1 encoding\n  const rValue = removeLeadingZeros(r)\n  const sValue = removeLeadingZeros(s)\n\n  // Create the EcDsaSignature object\n  const signature = new ECDSASigValue()\n  signature.r = new Uint8Array(ensurePositive(rValue)).buffer\n  signature.s = new Uint8Array(ensurePositive(sValue)).buffer\n\n  // Convert to DER\n  return new Uint8Array(AsnConvert.serialize(signature))\n}\n\n/**\n * Converts a DER encoded EC signature to RAW format\n *\n * @param derSignature - DER encoded signature\n * @param crv - The EC crv of the key used for the signature\n * @returns Raw signature as r || s concatenated values\n */\nexport function derEcSignatureToRaw(derSignature: AnyUint8Array, crv: KmsJwkPublicEc['crv']): Uint8ArrayBuffer {\n  // Parse DER signature\n  const asn = AsnConvert.parse(derSignature, ECDSASigValue)\n\n  const pointBitLength = ecCrvToCurveParams[crv].pointBitLength\n  const pointByteLength = Math.ceil(pointBitLength / 8)\n\n  // Ensure r and s are padded to the correct point size\n  const rPadded = padToLength(new Uint8Array(asn.r), pointByteLength)\n  const sPadded = padToLength(new Uint8Array(asn.s), pointByteLength)\n\n  // Concatenate to form raw signature\n  const rawSignature = new Uint8Array(pointByteLength * 2)\n  rawSignature.set(rPadded, 0)\n  rawSignature.set(sPadded, pointByteLength)\n\n  return rawSignature\n}\n\n/**\n * Helper function to remove unnecessary leading zeros from an integer representation\n *\n * @param data - The integer bytes\n * @returns - Data with leading zeros removed\n */\nfunction removeLeadingZeros(data: AnyUint8Array): Uint8ArrayBuffer {\n  let startIndex = 0\n  while (startIndex < data.length - 1 && data[startIndex] === 0) {\n    startIndex++\n  }\n\n  return data.slice(startIndex)\n}\n\n/**\n * Ensures an integer value is represented as positive in ASN.1 by\n * adding a leading zero if the high bit is set\n *\n * @param data - The integer bytes\n * @returns Data ensuring positive integer representation\n */\nfunction ensurePositive(data: Uint8ArrayBuffer): Uint8ArrayBuffer {\n  // If high bit is set, prepend a zero byte to ensure it's treated as positive\n  if (data.length > 0 && (data[0] & 0x80) !== 0) {\n    const result = new Uint8Array(data.length + 1)\n    result.set(data, 1)\n    return result\n  }\n  return data\n}\n\n/**\n * Pads an integer value to the specified length\n *\n * @param data - The integer bytes\n * @param targetLength - The desired length\n * @returns Padded data\n */\nfunction padToLength(data: Uint8ArrayBuffer, targetLength: number) {\n  if (data.length === targetLength) {\n    return data\n  }\n\n  if (data.length > targetLength) {\n    // If the value is larger, ensure we're not losing significant bytes\n    const significantStart = data.length - targetLength\n    for (let i = 0; i < significantStart; i++) {\n      if (data[i] !== 0) {\n        throw new KeyManagementError('Value too large for the specified point size')\n      }\n    }\n    return data.slice(significantStart)\n  }\n\n  // Pad with leading zeros\n  const result = new Uint8Array(targetLength)\n  result.set(data, targetLength - data.length)\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;AAcA,SAAgB,oBAAoB,cAA6B,KAA8C;CAC7G,MAAM,iBAAiB,mBAAmB,KAAK;CAC/C,MAAM,kBAAkB,KAAK,KAAK,iBAAiB,EAAE;AAErD,KAAI,aAAa,WAAW,kBAAkB,EAC5C,OAAM,IAAI,mBACR,sEAAsE,kBAAkB,EAAE,iBAAiB,MAC5G;CAIH,MAAM,IAAI,aAAa,MAAM,GAAG,gBAAgB;CAChD,MAAM,IAAI,aAAa,MAAM,gBAAgB;CAG7C,MAAM,SAAS,mBAAmB,EAAE;CACpC,MAAM,SAAS,mBAAmB,EAAE;CAGpC,MAAM,YAAY,IAAI,eAAe;AACrC,WAAU,IAAI,IAAI,WAAW,eAAe,OAAO,CAAC,CAAC;AACrD,WAAU,IAAI,IAAI,WAAW,eAAe,OAAO,CAAC,CAAC;AAGrD,QAAO,IAAI,WAAW,WAAW,UAAU,UAAU,CAAC;;;;;;;;;AAUxD,SAAgB,oBAAoB,cAA6B,KAA8C;CAE7G,MAAM,MAAM,WAAW,MAAM,cAAc,cAAc;CAEzD,MAAM,iBAAiB,mBAAmB,KAAK;CAC/C,MAAM,kBAAkB,KAAK,KAAK,iBAAiB,EAAE;CAGrD,MAAM,UAAU,YAAY,IAAI,WAAW,IAAI,EAAE,EAAE,gBAAgB;CACnE,MAAM,UAAU,YAAY,IAAI,WAAW,IAAI,EAAE,EAAE,gBAAgB;CAGnE,MAAM,eAAe,IAAI,WAAW,kBAAkB,EAAE;AACxD,cAAa,IAAI,SAAS,EAAE;AAC5B,cAAa,IAAI,SAAS,gBAAgB;AAE1C,QAAO;;;;;;;;AAST,SAAS,mBAAmB,MAAuC;CACjE,IAAI,aAAa;AACjB,QAAO,aAAa,KAAK,SAAS,KAAK,KAAK,gBAAgB,EAC1D;AAGF,QAAO,KAAK,MAAM,WAAW;;;;;;;;;AAU/B,SAAS,eAAe,MAA0C;AAEhE,KAAI,KAAK,SAAS,MAAM,KAAK,KAAK,SAAU,GAAG;EAC7C,MAAM,SAAS,IAAI,WAAW,KAAK,SAAS,EAAE;AAC9C,SAAO,IAAI,MAAM,EAAE;AACnB,SAAO;;AAET,QAAO;;;;;;;;;AAUT,SAAS,YAAY,MAAwB,cAAsB;AACjE,KAAI,KAAK,WAAW,aAClB,QAAO;AAGT,KAAI,KAAK,SAAS,cAAc;EAE9B,MAAM,mBAAmB,KAAK,SAAS;AACvC,OAAK,IAAI,IAAI,GAAG,IAAI,kBAAkB,IACpC,KAAI,KAAK,OAAO,EACd,OAAM,IAAI,mBAAmB,+CAA+C;AAGhF,SAAO,KAAK,MAAM,iBAAiB;;CAIrC,MAAM,SAAS,IAAI,WAAW,aAAa;AAC3C,QAAO,IAAI,MAAM,eAAe,KAAK,OAAO;AAC5C,QAAO"}

package/build/modules/kms/jwk/kty/index.d.mts

@@ -0,0 +1,15 @@
+import { KmsJwkPrivateEc, KmsJwkPublicEc, zKmsJwkPrivateEc, zKmsJwkPublicEc } from "./ec/ecJwk.mjs";
+import { KmsJwkPrivateOct, KmsJwkPublicOct, zKmsJwkPrivateOct, zKmsJwkPublicOct } from "./oct/octJwk.mjs";
+import { KmsJwkPrivateOkp, KmsJwkPublicOkp, zKmsJwkPrivateOkp, zKmsJwkPublicOkp } from "./okp/okpJwk.mjs";
+import { KmsJwkPrivateRsa, KmsJwkPublicRsa, zKmsJwkPrivateRsa, zKmsJwkPublicRsa } from "./rsa/rsaJwk.mjs";
+import "./ec/ecPublicKey.mjs";
+import { derEcSignatureToRaw, rawEcSignatureToDer } from "./ec/ecSignature.mjs";
+import { P256PublicJwk } from "./ec/P256PublicJwk.mjs";
+import { P384PublicJwk } from "./ec/P384PublicJwk.mjs";
+import { P521PublicJwk } from "./ec/P521PublicJwk.mjs";
+import { Secp256k1PublicJwk } from "./ec/Secp256k1PublicJwk.mjs";
+import { Ed25519PublicJwk } from "./okp/Ed25519PublicJwk.mjs";
+import "./okp/okpPublicKey.mjs";
+import { X25519PublicJwk } from "./okp/X25519PublicJwk.mjs";
+import { RsaPublicJwk } from "./rsa/RsaPublicJwk.mjs";
+import "./rsa/rsaPublicKey.mjs";

package/build/modules/kms/jwk/kty/index.mjs

@@ -0,0 +1,17 @@
+
+
+import { zKmsJwkPrivateEc, zKmsJwkPrivateToPublicEc, zKmsJwkPublicEc } from "./ec/ecJwk.mjs";
+import { zKmsJwkPrivateOct, zKmsJwkPrivateToPublicOct, zKmsJwkPublicOct } from "./oct/octJwk.mjs";
+import { zKmsJwkPrivateOkp, zKmsJwkPrivateToPublicOkp, zKmsJwkPublicOkp } from "./okp/okpJwk.mjs";
+import { zKmsJwkPrivateRsa, zKmsJwkPrivateToPublicRsa, zKmsJwkPublicRsa } from "./rsa/rsaJwk.mjs";
+import { ecPublicJwkToPublicKey } from "./ec/ecPublicKey.mjs";
+import { derEcSignatureToRaw, rawEcSignatureToDer } from "./ec/ecSignature.mjs";
+import { P256PublicJwk } from "./ec/P256PublicJwk.mjs";
+import { P384PublicJwk } from "./ec/P384PublicJwk.mjs";
+import { P521PublicJwk } from "./ec/P521PublicJwk.mjs";
+import { Secp256k1PublicJwk } from "./ec/Secp256k1PublicJwk.mjs";
+import { okpPublicJwkToPublicKey } from "./okp/okpPublicKey.mjs";
+import { X25519PublicJwk } from "./okp/X25519PublicJwk.mjs";
+import { Ed25519PublicJwk } from "./okp/Ed25519PublicJwk.mjs";
+import { rsaPublicJwkToPublicKey } from "./rsa/rsaPublicKey.mjs";
+import { RsaPublicJwk } from "./rsa/RsaPublicJwk.mjs";

package/build/modules/kms/jwk/kty/oct/octJwk.d.mts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+
+//#region src/modules/kms/jwk/kty/oct/octJwk.d.ts
+declare const zKmsJwkPublicOct: z.ZodObject<{
+  kty: z.ZodLiteral<"oct">;
+  k: z.ZodOptional<z.ZodUndefined>;
+  kid: z.ZodOptional<z.ZodString>;
+  alg: z.ZodOptional<z.ZodString>;
+  key_ops: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sign">, z.ZodLiteral<"verify">, z.ZodLiteral<"encrypt">, z.ZodLiteral<"decrypt">, z.ZodLiteral<"wrapKey">, z.ZodLiteral<"unwrapKey">, z.ZodLiteral<"deriveKey">, z.ZodLiteral<"deriveBits">]>, z.ZodString]>>>;
+  use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sig">, z.ZodLiteral<"enc">]>, z.ZodString]>>;
+  ext: z.ZodOptional<z.ZodBoolean>;
+  x5c: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  x5t: z.ZodOptional<z.ZodString>;
+  'x5t#S256': z.ZodOptional<z.ZodString>;
+  x5u: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type KmsJwkPublicOct = z.output<typeof zKmsJwkPublicOct>;
+declare const zKmsJwkPrivateOct: z.ZodObject<{
+  k: z.ZodString;
+  kty: z.ZodLiteral<"oct">;
+  kid: z.ZodOptional<z.ZodString>;
+  alg: z.ZodOptional<z.ZodString>;
+  key_ops: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sign">, z.ZodLiteral<"verify">, z.ZodLiteral<"encrypt">, z.ZodLiteral<"decrypt">, z.ZodLiteral<"wrapKey">, z.ZodLiteral<"unwrapKey">, z.ZodLiteral<"deriveKey">, z.ZodLiteral<"deriveBits">]>, z.ZodString]>>>;
+  use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sig">, z.ZodLiteral<"enc">]>, z.ZodString]>>;
+  ext: z.ZodOptional<z.ZodBoolean>;
+  x5c: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  x5t: z.ZodOptional<z.ZodString>;
+  'x5t#S256': z.ZodOptional<z.ZodString>;
+  x5u: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type KmsJwkPrivateOct = z.output<typeof zKmsJwkPrivateOct>;
+//#endregion
+export { KmsJwkPrivateOct, KmsJwkPublicOct, zKmsJwkPrivateOct, zKmsJwkPublicOct };
+//# sourceMappingURL=octJwk.d.mts.map

package/build/modules/kms/jwk/kty/oct/octJwk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"octJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/oct/octJwk.ts"],"sourcesContent":[],"mappings":";;;cAIa,kBAAgB,CAAA,CAAA;;;;EAAhB,GAAA,eAAA,YAMX,CAAA;;;;;;;;;KACU,eAAA,GAAkB,CAAA,CAAE,cAAc;cAQjC,mBAAiB,CAAA,CAAA;;;;;;;;;;;;;KAMlB,gBAAA,GAAmB,CAAA,CAAE,cAAc"}

package/build/modules/kms/jwk/kty/oct/octJwk.mjs

@@ -0,0 +1,24 @@
+
+
+import { zBase64Url, zOptionalToUndefined } from "../../../../../utils/zod.mjs";
+import { vJwkCommon } from "../../jwk.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/jwk/kty/oct/octJwk.ts
+const zKmsJwkPublicOct = z.object({
+	...vJwkCommon.shape,
+	kty: z.literal("oct"),
+	k: z.optional(z.undefined())
+});
+const zKmsJwkPrivateToPublicOct = z.object({
+	...zKmsJwkPublicOct.shape,
+	k: zOptionalToUndefined(zBase64Url)
+});
+const zKmsJwkPrivateOct = z.object({
+	...zKmsJwkPublicOct.shape,
+	k: zBase64Url
+});
+
+//#endregion
+export { zKmsJwkPrivateOct, zKmsJwkPrivateToPublicOct, zKmsJwkPublicOct };
+//# sourceMappingURL=octJwk.mjs.map

package/build/modules/kms/jwk/kty/oct/octJwk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"octJwk.mjs","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/oct/octJwk.ts"],"sourcesContent":["import { z } from 'zod'\nimport { zBase64Url, zOptionalToUndefined } from '../../../../../utils/zod'\nimport { vJwkCommon } from '../../jwk'\n\nexport const zKmsJwkPublicOct = z.object({\n  ...vJwkCommon.shape,\n  kty: z.literal('oct'),\n\n  // Private\n  k: z.optional(z.undefined()), // Key\n})\nexport type KmsJwkPublicOct = z.output<typeof zKmsJwkPublicOct>\n\nexport const zKmsJwkPrivateToPublicOct = z.object({\n  ...zKmsJwkPublicOct.shape,\n\n  k: zOptionalToUndefined(zBase64Url), // Key\n})\n\nexport const zKmsJwkPrivateOct = z.object({\n  ...zKmsJwkPublicOct.shape,\n\n  // Private\n  k: zBase64Url, // Key\n})\nexport type KmsJwkPrivateOct = z.output<typeof zKmsJwkPrivateOct>\n"],"mappings":";;;;;;;AAIA,MAAa,mBAAmB,EAAE,OAAO;CACvC,GAAG,WAAW;CACd,KAAK,EAAE,QAAQ,MAAM;CAGrB,GAAG,EAAE,SAAS,EAAE,WAAW,CAAC;CAC7B,CAAC;AAGF,MAAa,4BAA4B,EAAE,OAAO;CAChD,GAAG,iBAAiB;CAEpB,GAAG,qBAAqB,WAAW;CACpC,CAAC;AAEF,MAAa,oBAAoB,EAAE,OAAO;CACxC,GAAG,iBAAiB;CAGpB,GAAG;CACJ,CAAC"}

package/build/modules/kms/jwk/kty/okp/Ed25519PublicJwk.d.mts

@@ -0,0 +1,51 @@
+import { KnownJwaKeyAgreementAlgorithm, KnownJwaSignatureAlgorithm } from "../../jwa.mjs";
+import { AnyUint8Array } from "../../../../../types.mjs";
+import { KmsJwkPublicOkp } from "./okpJwk.mjs";
+import { PublicJwkType } from "../PublicJwk.mjs";
+
+//#region src/modules/kms/jwk/kty/okp/Ed25519PublicJwk.d.ts
+type Jwk = KmsJwkPublicOkp & {
+  crv: 'Ed25519';
+};
+declare class Ed25519PublicJwk implements PublicJwkType<Jwk> {
+  readonly jwk: Jwk;
+  static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
+  static supportdEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[];
+  static multicodecPrefix: number;
+  supportdEncryptionKeyAgreementAlgorithms: ("ECDH-ES" | "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW" | "ECDH-HSALSA20")[];
+  supportedSignatureAlgorithms: ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];
+  multicodecPrefix: number;
+  constructor(jwk: Jwk);
+  get publicKey(): {
+    crv: "Ed25519";
+    kty: "OKP";
+    publicKey: AnyUint8Array;
+  };
+  /**
+   * Not supported for Ed25519
+   */
+  get compressedPublicKey(): null;
+  get multicodec(): AnyUint8Array;
+  static fromPublicKey(publicKey: AnyUint8Array): Ed25519PublicJwk;
+  static fromMulticodec(multicodec: AnyUint8Array): Ed25519PublicJwk;
+  toX25519PublicJwk(): {
+    kty: "OKP";
+    crv: "Ed25519" | "X25519";
+    x: string;
+    d?: string | undefined;
+    kid?: string | undefined;
+    alg?: string | undefined;
+    key_ops?: string[] | undefined;
+    use?: string | undefined;
+    ext?: boolean | undefined;
+    x5c?: string[] | undefined;
+    x5t?: string | undefined;
+    'x5t#S256'?: string | undefined;
+    x5u?: string | undefined;
+  } & {
+    crv: "X25519";
+  };
+}
+//#endregion
+export { Ed25519PublicJwk };
+//# sourceMappingURL=Ed25519PublicJwk.d.mts.map

package/build/modules/kms/jwk/kty/okp/Ed25519PublicJwk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ed25519PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/Ed25519PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAYK,GAAA,GAAM;;;cAEE,gBAAA,YAA4B,cAAc;EAFlD,SAAG,GAAA,EAckC,GAdlC;EAEK,OAAA,4BAAiB,EACgB,0BADhB,EAAA;EAAyB,OAAA,wCAAA,EAKG,6BALH,EAAA;EAYb,OAAA,gBAAA,EAAA,MAAA;EAXI,wCAAA,EAAA,CAAA,SAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,eAAA,CAAA,EAAA;EAIY,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;EAOhB,gBAAA,EAAA,MAAA;mBAAA;EAiBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,SAAA;IAAa,GAAA,EAAA,KAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EAtCf;;;;oBA6BlB;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/okp/Ed25519PublicJwk.mjs

@@ -0,0 +1,48 @@
+
+
+import { KnownJwaSignatureAlgorithms } from "../../jwa.mjs";
+import { okpPublicJwkToPublicKey, okpPublicKeyToPublicJwk } from "./okpPublicKey.mjs";
+import { X25519PublicJwk } from "./X25519PublicJwk.mjs";
+import { convertPublicKeyToX25519 } from "@stablelib/ed25519";
+
+//#region src/modules/kms/jwk/kty/okp/Ed25519PublicJwk.ts
+var Ed25519PublicJwk = class Ed25519PublicJwk {
+	constructor(jwk) {
+		this.jwk = jwk;
+		this.supportdEncryptionKeyAgreementAlgorithms = Ed25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedSignatureAlgorithms = Ed25519PublicJwk.supportedSignatureAlgorithms;
+		this.multicodecPrefix = Ed25519PublicJwk.multicodecPrefix;
+	}
+	get publicKey() {
+		return {
+			crv: this.jwk.crv,
+			kty: this.jwk.kty,
+			publicKey: okpPublicJwkToPublicKey(this.jwk)
+		};
+	}
+	/**
+	* Not supported for Ed25519
+	*/
+	get compressedPublicKey() {
+		return null;
+	}
+	get multicodec() {
+		return okpPublicJwkToPublicKey(this.jwk);
+	}
+	static fromPublicKey(publicKey) {
+		return new Ed25519PublicJwk(okpPublicKeyToPublicJwk(publicKey, "Ed25519"));
+	}
+	static fromMulticodec(multicodec) {
+		return new Ed25519PublicJwk(okpPublicKeyToPublicJwk(multicodec, "Ed25519"));
+	}
+	toX25519PublicJwk() {
+		return X25519PublicJwk.fromPublicKey(convertPublicKeyToX25519(this.publicKey.publicKey)).jwk;
+	}
+};
+Ed25519PublicJwk.supportedSignatureAlgorithms = [KnownJwaSignatureAlgorithms.EdDSA, KnownJwaSignatureAlgorithms.Ed25519];
+Ed25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [];
+Ed25519PublicJwk.multicodecPrefix = 237;
+
+//#endregion
+export { Ed25519PublicJwk };
+//# sourceMappingURL=Ed25519PublicJwk.mjs.map

package/build/modules/kms/jwk/kty/okp/Ed25519PublicJwk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ed25519PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/Ed25519PublicJwk.ts"],"sourcesContent":["import { convertPublicKeyToX25519 } from '@stablelib/ed25519'\nimport type { AnyUint8Array, Uint8ArrayBuffer } from '../../../../../types'\nimport {\n  type KnownJwaKeyAgreementAlgorithm,\n  type KnownJwaSignatureAlgorithm,\n  KnownJwaSignatureAlgorithms,\n} from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicOkp } from './okpJwk'\nimport { okpPublicJwkToPublicKey, okpPublicKeyToPublicJwk } from './okpPublicKey'\nimport { X25519PublicJwk } from './X25519PublicJwk'\n\ntype Jwk = KmsJwkPublicOkp & { crv: 'Ed25519' }\n\nexport class Ed25519PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [\n    KnownJwaSignatureAlgorithms.EdDSA,\n    KnownJwaSignatureAlgorithms.Ed25519,\n  ]\n  public static supportdEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[] = []\n  public static multicodecPrefix = 237\n\n  public supportdEncryptionKeyAgreementAlgorithms = Ed25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = Ed25519PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = Ed25519PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: okpPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  /**\n   * Not supported for Ed25519\n   */\n  public get compressedPublicKey() {\n    return null\n  }\n\n  public get multicodec() {\n    return okpPublicJwkToPublicKey(this.jwk)\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(publicKey, 'Ed25519')\n    return new Ed25519PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(multicodec, 'Ed25519')\n    return new Ed25519PublicJwk(jwk)\n  }\n\n  public toX25519PublicJwk() {\n    return X25519PublicJwk.fromPublicKey(convertPublicKeyToX25519(this.publicKey.publicKey) as Uint8ArrayBuffer).jwk\n  }\n}\n"],"mappings":";;;;;;;;AAcA,IAAa,mBAAb,MAAa,iBAA+C;CAY1D,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,2CAA2C,iBAAiB;OAC5D,+BAA+B,iBAAiB;OAChD,mBAAmB,iBAAiB;;CAI3C,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,wBAAwB,KAAK,IAAI;GAC7C;;;;;CAMH,IAAW,sBAAsB;AAC/B,SAAO;;CAGT,IAAW,aAAa;AACtB,SAAO,wBAAwB,KAAK,IAAI;;CAG1C,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,iBADC,wBAAwB,WAAW,UAAU,CACzB;;CAGlC,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,iBADC,wBAAwB,YAAY,UAAU,CAC1B;;CAGlC,AAAO,oBAAoB;AACzB,SAAO,gBAAgB,cAAc,yBAAyB,KAAK,UAAU,UAAU,CAAqB,CAAC;;;iBA3CjG,+BAA6D,CACzE,4BAA4B,OAC5B,4BAA4B,QAC7B;iBACa,2CAA4E,EAAE;iBAC9E,mBAAmB"}

package/build/modules/kms/jwk/kty/okp/X25519PublicJwk.d.mts

@@ -0,0 +1,34 @@
+import { KnownJwaSignatureAlgorithm } from "../../jwa.mjs";
+import { AnyUint8Array } from "../../../../../types.mjs";
+import { KmsJwkPublicOkp } from "./okpJwk.mjs";
+import { PublicJwkType } from "../PublicJwk.mjs";
+
+//#region src/modules/kms/jwk/kty/okp/X25519PublicJwk.d.ts
+type Jwk = KmsJwkPublicOkp & {
+  crv: 'X25519';
+};
+declare class X25519PublicJwk implements PublicJwkType<Jwk> {
+  readonly jwk: Jwk;
+  static supportdEncryptionKeyAgreementAlgorithms: "ECDH-HSALSA20"[];
+  static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
+  static multicodecPrefix: number;
+  supportdEncryptionKeyAgreementAlgorithms: "ECDH-HSALSA20"[];
+  supportedSignatureAlgorithms: ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];
+  multicodecPrefix: number;
+  constructor(jwk: Jwk);
+  get publicKey(): {
+    crv: "X25519";
+    kty: "OKP";
+    publicKey: AnyUint8Array;
+  };
+  /**
+   * Not supported for X25519
+   */
+  get compressedPublicKey(): null;
+  get multicodec(): AnyUint8Array;
+  static fromPublicKey(publicKey: AnyUint8Array): X25519PublicJwk;
+  static fromMulticodec(multicodec: AnyUint8Array): X25519PublicJwk;
+}
+//#endregion
+export { X25519PublicJwk };
+//# sourceMappingURL=X25519PublicJwk.d.mts.map

package/build/modules/kms/jwk/kty/okp/X25519PublicJwk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"X25519PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/X25519PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,eAAA,YAA2B,cAAc;EAFjD,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,wCAAgB,EAAA,eAAA,EAAA;EAAyB,OAAA,4BAAA,EAER,0BAFQ,EAAA;EASZ,OAAA,gBAAA,EAAA,MAAA;EAPI,wCAAA,EAAA,eAAA,EAAA;EAOJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;EAiBnB,WAAA,CAAA,GAAA,EAjBmB,GAiBnB;EAIkB,IAAA,SAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,QAAA;IAKX,GAAA,EAAA,KAAA;IAAa,SAAA,eAAA;EAnChB,CAAA;EAAa;;;;oBA0B9B;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/okp/X25519PublicJwk.mjs

@@ -0,0 +1,43 @@
+
+
+import { KnownJwaKeyAgreementAlgorithms } from "../../jwa.mjs";
+import { okpPublicJwkToPublicKey, okpPublicKeyToPublicJwk } from "./okpPublicKey.mjs";
+
+//#region src/modules/kms/jwk/kty/okp/X25519PublicJwk.ts
+var X25519PublicJwk = class X25519PublicJwk {
+	constructor(jwk) {
+		this.jwk = jwk;
+		this.supportdEncryptionKeyAgreementAlgorithms = X25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedSignatureAlgorithms = X25519PublicJwk.supportedSignatureAlgorithms;
+		this.multicodecPrefix = X25519PublicJwk.multicodecPrefix;
+	}
+	get publicKey() {
+		return {
+			crv: this.jwk.crv,
+			kty: this.jwk.kty,
+			publicKey: okpPublicJwkToPublicKey(this.jwk)
+		};
+	}
+	/**
+	* Not supported for X25519
+	*/
+	get compressedPublicKey() {
+		return null;
+	}
+	get multicodec() {
+		return okpPublicJwkToPublicKey(this.jwk);
+	}
+	static fromPublicKey(publicKey) {
+		return new X25519PublicJwk(okpPublicKeyToPublicJwk(publicKey, "X25519"));
+	}
+	static fromMulticodec(multicodec) {
+		return new X25519PublicJwk(okpPublicKeyToPublicJwk(multicodec, "X25519"));
+	}
+};
+X25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_HSALSA20];
+X25519PublicJwk.supportedSignatureAlgorithms = [];
+X25519PublicJwk.multicodecPrefix = 236;
+
+//#endregion
+export { X25519PublicJwk };
+//# sourceMappingURL=X25519PublicJwk.mjs.map

package/build/modules/kms/jwk/kty/okp/X25519PublicJwk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"X25519PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/X25519PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicOkp } from './okpJwk'\nimport { okpPublicJwkToPublicKey, okpPublicKeyToPublicJwk } from './okpPublicKey'\n\ntype Jwk = KmsJwkPublicOkp & { crv: 'X25519' }\n\nexport class X25519PublicJwk implements PublicJwkType<Jwk> {\n  public static supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_HSALSA20]\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = []\n  public static multicodecPrefix = 236\n\n  public supportdEncryptionKeyAgreementAlgorithms = X25519PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = X25519PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = X25519PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: okpPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  /**\n   * Not supported for X25519\n   */\n  public get compressedPublicKey() {\n    return null\n  }\n\n  public get multicodec() {\n    return okpPublicJwkToPublicKey(this.jwk)\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(publicKey, 'X25519')\n    return new X25519PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = okpPublicKeyToPublicJwk(multicodec, 'X25519')\n    return new X25519PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,kBAAb,MAAa,gBAA8C;CASzD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,2CAA2C,gBAAgB;OAC3D,+BAA+B,gBAAgB;OAC/C,mBAAmB,gBAAgB;;CAI1C,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,wBAAwB,KAAK,IAAI;GAC7C;;;;;CAMH,IAAW,sBAAsB;AAC/B,SAAO;;CAGT,IAAW,aAAa;AACtB,SAAO,wBAAwB,KAAK,IAAI;;CAG1C,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,gBADC,wBAAwB,WAAW,SAAS,CACzB;;CAGjC,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,gBADC,wBAAwB,YAAY,SAAS,CAC1B;;;gBApCnB,2CAA2C,CAAC,+BAA+B,cAAc;gBACzF,+BAA6D,EAAE;gBAC/D,mBAAmB"}

package/build/modules/kms/jwk/kty/okp/okpJwk.d.mts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+
+//#region src/modules/kms/jwk/kty/okp/okpJwk.d.ts
+declare const zKmsJwkPublicOkp: z.ZodObject<{
+  kty: z.ZodLiteral<"OKP">;
+  crv: z.ZodEnum<{
+    Ed25519: "Ed25519";
+    X25519: "X25519";
+  }>;
+  x: z.ZodString;
+  d: z.ZodOptional<z.ZodString>;
+  kid: z.ZodOptional<z.ZodString>;
+  alg: z.ZodOptional<z.ZodString>;
+  key_ops: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sign">, z.ZodLiteral<"verify">, z.ZodLiteral<"encrypt">, z.ZodLiteral<"decrypt">, z.ZodLiteral<"wrapKey">, z.ZodLiteral<"unwrapKey">, z.ZodLiteral<"deriveKey">, z.ZodLiteral<"deriveBits">]>, z.ZodString]>>>;
+  use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sig">, z.ZodLiteral<"enc">]>, z.ZodString]>>;
+  ext: z.ZodOptional<z.ZodBoolean>;
+  x5c: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  x5t: z.ZodOptional<z.ZodString>;
+  'x5t#S256': z.ZodOptional<z.ZodString>;
+  x5u: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type KmsJwkPublicOkp = z.output<typeof zKmsJwkPublicOkp>;
+declare const zKmsJwkPrivateOkp: z.ZodObject<{
+  d: z.ZodString;
+  kty: z.ZodLiteral<"OKP">;
+  crv: z.ZodEnum<{
+    Ed25519: "Ed25519";
+    X25519: "X25519";
+  }>;
+  x: z.ZodString;
+  kid: z.ZodOptional<z.ZodString>;
+  alg: z.ZodOptional<z.ZodString>;
+  key_ops: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sign">, z.ZodLiteral<"verify">, z.ZodLiteral<"encrypt">, z.ZodLiteral<"decrypt">, z.ZodLiteral<"wrapKey">, z.ZodLiteral<"unwrapKey">, z.ZodLiteral<"deriveKey">, z.ZodLiteral<"deriveBits">]>, z.ZodString]>>>;
+  use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sig">, z.ZodLiteral<"enc">]>, z.ZodString]>>;
+  ext: z.ZodOptional<z.ZodBoolean>;
+  x5c: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  x5t: z.ZodOptional<z.ZodString>;
+  'x5t#S256': z.ZodOptional<z.ZodString>;
+  x5u: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type KmsJwkPrivateOkp = z.output<typeof zKmsJwkPrivateOkp>;
+//#endregion
+export { KmsJwkPrivateOkp, KmsJwkPublicOkp, zKmsJwkPrivateOkp, zKmsJwkPublicOkp };
+//# sourceMappingURL=okpJwk.d.mts.map

package/build/modules/kms/jwk/kty/okp/okpJwk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"okpJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/okpJwk.ts"],"sourcesContent":[],"mappings":";;;cAMa,kBAAgB,CAAA,CAAA;;;;IAAhB,MAAA,EAAA,QAUX;;;;;;;;;;;;;;KACU,eAAA,GAAkB,CAAA,CAAE,cAAc;cAOjC,mBAAiB,CAAA,CAAA;;;;;;;;EAlBD,GAAA,eAAA,YAAA,CAAA;EAAA,GAAA,eAAA,YAAA,CAAA;EAWjB,OAAA,eAAe,WAAmB,WAAA,CAAA,SAAd,WAAM,CAAA,SAAA,aAAA,CAAA,MAAA,CAAA,cAAA,CAAA,QAAA,CAAA,cAAA,CAAA,SAAA,CAAA,cAAA,CAAA,SAAA,CAAA,cAAA,CAAA,SAAA,CAAA,cAAA,CAAA,WAAA,CAAA,cAAA,CAAA,WAAA,CAAA,cAAA,CAAA,YAAA,CAAA,CAAA,CAAA,aAAA,CAAA,CAAA,CAAA,CAAA;EAOzB,GAAA,eAAA,WAKX,CAAA,SAAA,WAAA,CAAA,SAAA,aAAA,CAAA,KAAA,CAAA,cAAA,CAAA,KAAA,CAAA,CAAA,CAAA,aAAA,CAAA,CAAA,CAAA;;;;;;;KACU,gBAAA,GAAmB,CAAA,CAAE,cAAc"}

package/build/modules/kms/jwk/kty/okp/okpJwk.mjs

@@ -0,0 +1,26 @@
+
+
+import { zBase64Url, zOptionalToUndefined } from "../../../../../utils/zod.mjs";
+import { vJwkCommon } from "../../jwk.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/jwk/kty/okp/okpJwk.ts
+const zKmsJwkPublicOkp = z.object({
+	...vJwkCommon.shape,
+	kty: z.literal("OKP"),
+	crv: z.enum(["X25519", "Ed25519"]),
+	x: zBase64Url,
+	d: z.optional(zBase64Url)
+});
+const zKmsJwkPrivateToPublicOkp = z.object({
+	...zKmsJwkPublicOkp.shape,
+	d: zOptionalToUndefined(zBase64Url)
+});
+const zKmsJwkPrivateOkp = z.object({
+	...zKmsJwkPublicOkp.shape,
+	d: zBase64Url
+});
+
+//#endregion
+export { zKmsJwkPrivateOkp, zKmsJwkPrivateToPublicOkp, zKmsJwkPublicOkp };
+//# sourceMappingURL=okpJwk.mjs.map

package/build/modules/kms/jwk/kty/okp/okpJwk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"okpJwk.mjs","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/okpJwk.ts"],"sourcesContent":["import { z } from 'zod'\nimport { zBase64Url, zOptionalToUndefined } from '../../../../../utils/zod'\nimport { vJwkCommon } from '../../jwk'\n\n// TODO: we should probably create a separate Jwk type for each crv, so we\n// can use the type in Credo if we need a specific key\nexport const zKmsJwkPublicOkp = z.object({\n  ...vJwkCommon.shape,\n  kty: z.literal('OKP'),\n  crv: z.enum(['X25519', 'Ed25519']),\n\n  // Public\n  x: zBase64Url,\n\n  // Private\n  d: z.optional(zBase64Url),\n})\nexport type KmsJwkPublicOkp = z.output<typeof zKmsJwkPublicOkp>\n\nexport const zKmsJwkPrivateToPublicOkp = z.object({\n  ...zKmsJwkPublicOkp.shape,\n  d: zOptionalToUndefined(zBase64Url),\n})\n\nexport const zKmsJwkPrivateOkp = z.object({\n  ...zKmsJwkPublicOkp.shape,\n\n  // Private\n  d: zBase64Url,\n})\nexport type KmsJwkPrivateOkp = z.output<typeof zKmsJwkPrivateOkp>\n"],"mappings":";;;;;;;AAMA,MAAa,mBAAmB,EAAE,OAAO;CACvC,GAAG,WAAW;CACd,KAAK,EAAE,QAAQ,MAAM;CACrB,KAAK,EAAE,KAAK,CAAC,UAAU,UAAU,CAAC;CAGlC,GAAG;CAGH,GAAG,EAAE,SAAS,WAAW;CAC1B,CAAC;AAGF,MAAa,4BAA4B,EAAE,OAAO;CAChD,GAAG,iBAAiB;CACpB,GAAG,qBAAqB,WAAW;CACpC,CAAC;AAEF,MAAa,oBAAoB,EAAE,OAAO;CACxC,GAAG,iBAAiB;CAGpB,GAAG;CACJ,CAAC"}

package/build/modules/kms/jwk/kty/okp/okpPublicKey.d.mts

@@ -0,0 +1,2 @@
+import "../../../../../types.mjs";
+import "./okpJwk.mjs";

package/build/modules/kms/jwk/kty/okp/okpPublicKey.mjs

@@ -0,0 +1,20 @@
+
+
+import { TypedArrayEncoder } from "../../../../../utils/TypedArrayEncoder.mjs";
+import "../../../../../utils/index.mjs";
+
+//#region src/modules/kms/jwk/kty/okp/okpPublicKey.ts
+function okpPublicJwkToPublicKey(publicJwk) {
+	return Uint8Array.from(TypedArrayEncoder.fromBase64(publicJwk.x));
+}
+function okpPublicKeyToPublicJwk(publicKey, crv) {
+	return {
+		kty: "OKP",
+		crv,
+		x: TypedArrayEncoder.toBase64URL(publicKey)
+	};
+}
+
+//#endregion
+export { okpPublicJwkToPublicKey, okpPublicKeyToPublicJwk };
+//# sourceMappingURL=okpPublicKey.mjs.map

package/build/modules/kms/jwk/kty/okp/okpPublicKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"okpPublicKey.mjs","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/okp/okpPublicKey.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { TypedArrayEncoder } from '../../../../../utils'\nimport type { KmsJwkPublicOkp } from './okpJwk'\n\nexport function okpPublicJwkToPublicKey(publicJwk: KmsJwkPublicOkp): AnyUint8Array {\n  const publicKey = Uint8Array.from(TypedArrayEncoder.fromBase64(publicJwk.x))\n\n  return publicKey\n}\n\nexport function okpPublicKeyToPublicJwk<Curve extends KmsJwkPublicOkp['crv']>(publicKey: AnyUint8Array, crv: Curve) {\n  const jwk = {\n    kty: 'OKP',\n    crv,\n    x: TypedArrayEncoder.toBase64URL(publicKey),\n  } satisfies KmsJwkPublicOkp & { crv: Curve }\n\n  return jwk\n}\n"],"mappings":";;;;;;AAIA,SAAgB,wBAAwB,WAA2C;AAGjF,QAFkB,WAAW,KAAK,kBAAkB,WAAW,UAAU,EAAE,CAAC;;AAK9E,SAAgB,wBAA8D,WAA0B,KAAY;AAOlH,QANY;EACV,KAAK;EACL;EACA,GAAG,kBAAkB,YAAY,UAAU;EAC5C"}

package/build/modules/kms/jwk/kty/rsa/RsaPublicJwk.d.mts

@@ -0,0 +1,34 @@
+import { KnownJwaKeyAgreementAlgorithm, KnownJwaSignatureAlgorithm } from "../../jwa.mjs";
+import { AnyUint8Array, Uint8ArrayBuffer } from "../../../../../types.mjs";
+import { KmsJwkPublicRsa } from "./rsaJwk.mjs";
+import { PublicJwkType } from "../PublicJwk.mjs";
+
+//#region src/modules/kms/jwk/kty/rsa/RsaPublicJwk.d.ts
+declare class RsaPublicJwk implements PublicJwkType<KmsJwkPublicRsa> {
+  readonly jwk: KmsJwkPublicRsa;
+  static supportdEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[];
+  static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
+  static multicodecPrefix: number;
+  multicodecPrefix: number;
+  supportdEncryptionKeyAgreementAlgorithms: ("ECDH-ES" | "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW" | "ECDH-HSALSA20")[];
+  get supportedSignatureAlgorithms(): ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];
+  constructor(jwk: KmsJwkPublicRsa);
+  get publicKey(): {
+    modulus: AnyUint8Array;
+    exponent: AnyUint8Array;
+    kty: "RSA";
+  };
+  /**
+   * Not supported for RSA
+   */
+  get compressedPublicKey(): null;
+  get multicodec(): Uint8ArrayBuffer;
+  static fromPublicKey(publicKey: {
+    modulus: AnyUint8Array;
+    exponent: AnyUint8Array;
+  }): RsaPublicJwk;
+  static fromMulticodec(_multicodec: AnyUint8Array): RsaPublicJwk;
+}
+//#endregion
+export { RsaPublicJwk };
+//# sourceMappingURL=RsaPublicJwk.d.mts.map

package/build/modules/kms/jwk/kty/rsa/RsaPublicJwk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RsaPublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/rsa/RsaPublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;cAQa,YAAA,YAAwB,cAAc;gBA0BT;mDAzBgB;uCACZ;EAFjC,OAAA,gBAAa,EAAA,MAAA;EAAyB,gBAAA,EAAA,MAAA;EA0BT,wCAAA,EAAA,CAAA,SAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,gBAAA,GAAA,eAAA,CAAA,EAAA;EAzBgB,IAAA,4BAAA,CAAA,CAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;EACZ,WAAA,CAAA,GAAA,EAwBJ,eAxBI;EAwBJ,IAAA,SAAA,CAAA,CAAA,EAAA;;;IAgBf,GAAA,EAAA,KAAA;EAIyB,CAAA;EAAyB;;;EAIjB,IAAA,mBAAA,CAAA,CAAA,EAAA,IAAA;EAlDvB,IAAA,UAAA,CAAA,CAAA,EA0CV,gBA1CU;EAAa,OAAA,aAAA,CAAA,SAAA,EAAA;aA8CE;cAAyB;MAAe;qCAIhD,gBAAgB"}

package/build/modules/kms/jwk/kty/rsa/RsaPublicJwk.mjs

@@ -0,0 +1,65 @@
+
+
+import { KeyManagementError } from "../../../error/KeyManagementError.mjs";
+import { TypedArrayEncoder } from "../../../../../utils/TypedArrayEncoder.mjs";
+import "../../../../../utils/index.mjs";
+import { rsaPublicJwkToPublicKey, rsaPublicKeyToPublicJwk } from "./rsaPublicKey.mjs";
+
+//#region src/modules/kms/jwk/kty/rsa/RsaPublicJwk.ts
+var RsaPublicJwk = class RsaPublicJwk {
+	get supportedSignatureAlgorithms() {
+		const keyBits = TypedArrayEncoder.fromBase64(this.jwk.n).length * 8;
+		const minBits2048 = ["PS256", "RS256"];
+		const minBits3072 = [
+			...minBits2048,
+			"RS384",
+			"PS384"
+		];
+		const minBits4096 = [
+			...minBits3072,
+			"RS512",
+			"PS512"
+		];
+		return keyBits >= 4096 ? minBits4096 : keyBits >= 3072 ? minBits3072 : keyBits >= 2048 ? minBits2048 : [];
+	}
+	constructor(jwk) {
+		this.jwk = jwk;
+		this.multicodecPrefix = RsaPublicJwk.multicodecPrefix;
+		this.supportdEncryptionKeyAgreementAlgorithms = RsaPublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+	}
+	get publicKey() {
+		return {
+			kty: this.jwk.kty,
+			...rsaPublicJwkToPublicKey(this.jwk)
+		};
+	}
+	/**
+	* Not supported for RSA
+	*/
+	get compressedPublicKey() {
+		return null;
+	}
+	get multicodec() {
+		throw new KeyManagementError("multicodec not supported for RsaPublicJwk");
+	}
+	static fromPublicKey(publicKey) {
+		return new RsaPublicJwk(rsaPublicKeyToPublicJwk(publicKey));
+	}
+	static fromMulticodec(_multicodec) {
+		throw new KeyManagementError("fromMulticodec not supported for RsaPublicJwk");
+	}
+};
+RsaPublicJwk.supportdEncryptionKeyAgreementAlgorithms = [];
+RsaPublicJwk.supportedSignatureAlgorithms = [
+	"PS256",
+	"RS256",
+	"RS384",
+	"PS384",
+	"RS512",
+	"PS512"
+];
+RsaPublicJwk.multicodecPrefix = 4613;
+
+//#endregion
+export { RsaPublicJwk };
+//# sourceMappingURL=RsaPublicJwk.mjs.map