@credo-ts/core 0.6.0-pr-2392-20251010173905 → 0.6.0-pr-2457-20251016083534

package/build/modules/kms/options/KmsEncryptOptions.mjs

@@ -1,6 +1,7 @@
 
 
 import { KnownJwaContentEncryptionAlgorithms } from "../jwk/jwa.mjs";
+import { zAnyUint8Array } from "../../../utils/zod.mjs";
 import { zKmsJwkPrivateOct } from "../jwk/kty/oct/octJwk.mjs";
 import { zKmsKeyId } from "./common.mjs";
 import { zKmsKeyAgreementEncryptOptions } from "./KmsKeyAgreementEncryptOptions.mjs";
@@ -13,12 +14,12 @@ const zKmsEncryptDataEncryptionAesGcm = z.object({
 		KnownJwaContentEncryptionAlgorithms.A192GCM,
 		KnownJwaContentEncryptionAlgorithms.A256GCM
 	]),
-	iv: z.optional(z.instanceof(Uint8Array).refine((iv) => iv.length === 12, "iv must be 12 bytes for AES GCM")),
-	aad: z.optional(z.instanceof(Uint8Array))
+	iv: z.optional(zAnyUint8Array.refine((iv) => iv.length === 12, "iv must be 12 bytes for AES GCM")),
+	aad: z.optional(zAnyUint8Array)
 });
 const zKmsEncryptDataEncryptionAesCbc = z.object({
 	algorithm: z.enum([KnownJwaContentEncryptionAlgorithms.A128CBC, KnownJwaContentEncryptionAlgorithms.A256CBC]),
-	iv: z.optional(z.instanceof(Uint8Array).refine((iv) => iv.length === 16, "iv must be 16 bytes for AES CBC"))
+	iv: z.optional(zAnyUint8Array.refine((iv) => iv.length === 16, "iv must be 16 bytes for AES CBC"))
 });
 const zKmsEncryptDataEncryptionAesCbcHmac = z.object({
 	algorithm: z.enum([
@@ -26,17 +27,17 @@ const zKmsEncryptDataEncryptionAesCbcHmac = z.object({
 		KnownJwaContentEncryptionAlgorithms.A192CBC_HS384,
 		KnownJwaContentEncryptionAlgorithms.A256CBC_HS512
 	]),
-	iv: z.optional(z.instanceof(Uint8Array).refine((iv) => iv.length === 16, "iv must be 16 bytes for AES CBC with HMAC")),
-	aad: z.optional(z.instanceof(Uint8Array))
+	iv: z.optional(zAnyUint8Array.refine((iv) => iv.length === 16, "iv must be 16 bytes for AES CBC with HMAC")),
+	aad: z.optional(zAnyUint8Array)
 });
 const zKmsDecryptDataEncryptionSalsa = z.object({
 	algorithm: z.enum([KnownJwaContentEncryptionAlgorithms["XSALSA20-POLY1305"]]),
-	iv: z.instanceof(Uint8Array).optional()
+	iv: zAnyUint8Array.optional()
 });
 const zKmsEncryptDataEncryptionC20p = z.object({
 	algorithm: z.enum([KnownJwaContentEncryptionAlgorithms.C20P, KnownJwaContentEncryptionAlgorithms.XC20P]),
-	iv: z.optional(z.instanceof(Uint8Array)),
-	aad: z.optional(z.instanceof(Uint8Array))
+	iv: z.optional(zAnyUint8Array),
+	aad: z.optional(zAnyUint8Array)
 });
 const zKmsEncryptDataEncryption = z.discriminatedUnion("algorithm", [
 	zKmsEncryptDataEncryptionAesCbc,
@@ -64,12 +65,12 @@ const zKmsEncryptOptions = z.object({
 		})
 	]),
 	encryption: zKmsEncryptDataEncryption.describe("Options related to the encryption algorithm to use for encrypting the data"),
-	data: z.instanceof(Uint8Array).describe("The data to encrypt")
+	data: zAnyUint8Array.describe("The data to encrypt")
 });
 const zKmsEncryptedKey = z.object({
-	tag: z.instanceof(Uint8Array).optional(),
-	iv: z.instanceof(Uint8Array).optional(),
-	encrypted: z.instanceof(Uint8Array)
+	tag: zAnyUint8Array.optional(),
+	iv: zAnyUint8Array.optional(),
+	encrypted: zAnyUint8Array
 });
 
 //#endregion

package/build/modules/kms/options/KmsEncryptOptions.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"KmsEncryptOptions.mjs","names":[],"sources":["../../../../src/modules/kms/options/KmsEncryptOptions.ts"],"sourcesContent":["import { z } from 'zod'\nimport { KnownJwaContentEncryptionAlgorithms } from '../jwk/jwa'\nimport { zKmsJwkPrivateOct } from '../jwk/kty/oct/octJwk'\nimport { zKmsKeyAgreementEncryptOptions } from './KmsKeyAgreementEncryptOptions'\nimport { zKmsKeyId } from './common'\n\nconst zKmsEncryptDataEncryptionAesGcm = z.object({\n  // AES-GCM Content Encryption\n  algorithm: z.enum([\n    KnownJwaContentEncryptionAlgorithms.A128GCM,\n    KnownJwaContentEncryptionAlgorithms.A192GCM,\n    KnownJwaContentEncryptionAlgorithms.A256GCM,\n  ]),\n\n  iv: z.optional(z.instanceof(Uint8Array).refine((iv) => iv.length === 12, 'iv must be 12 bytes for AES GCM')),\n  aad: z.optional(z.instanceof(Uint8Array)),\n})\nexport type KmsEncryptDataEncryptionAesGcm = z.output<typeof zKmsEncryptDataEncryptionAesGcm>\n\n// AES-CBC Content Encryption\nconst zKmsEncryptDataEncryptionAesCbc = z.object({\n  algorithm: z.enum([KnownJwaContentEncryptionAlgorithms.A128CBC, KnownJwaContentEncryptionAlgorithms.A256CBC]),\n  iv: z.optional(z.instanceof(Uint8Array).refine((iv) => iv.length === 16, 'iv must be 16 bytes for AES CBC')),\n})\nexport type KmsEncryptDataEncryptionAesCbc = z.output<typeof zKmsEncryptDataEncryptionAesCbc>\n\n// AES-CBC with HMAC-SHA2 Content Encryption\nconst zKmsEncryptDataEncryptionAesCbcHmac = z.object({\n  algorithm: z.enum([\n    KnownJwaContentEncryptionAlgorithms.A128CBC_HS256,\n    KnownJwaContentEncryptionAlgorithms.A192CBC_HS384,\n    KnownJwaContentEncryptionAlgorithms.A256CBC_HS512,\n  ]),\n  iv: z.optional(\n    z.instanceof(Uint8Array).refine((iv) => iv.length === 16, 'iv must be 16 bytes for AES CBC with HMAC')\n  ),\n  aad: z.optional(z.instanceof(Uint8Array)),\n})\nexport type KmsEncryptDataEncryptionAesCbcHmac = z.output<typeof zKmsEncryptDataEncryptionAesCbcHmac>\n\n// XSalsa-Poly1305 Content Encryption\nconst zKmsDecryptDataEncryptionSalsa = z.object({\n  algorithm: z.enum([KnownJwaContentEncryptionAlgorithms['XSALSA20-POLY1305']]),\n  iv: z.instanceof(Uint8Array).optional(),\n})\n\n// ChaCha20-Poly130 Content Encryption\nconst zKmsEncryptDataEncryptionC20p = z.object({\n  algorithm: z.enum([KnownJwaContentEncryptionAlgorithms.C20P, KnownJwaContentEncryptionAlgorithms.XC20P]),\n  iv: z.optional(z.instanceof(Uint8Array)),\n  aad: z.optional(z.instanceof(Uint8Array)),\n})\n// FIXME: if we use refine, we can't use discriminated union. and that makes the error handlnig shitty\n// .refine(\n//   ({ iv, algorithm }) => !iv || iv.length === (algorithm === 'C20P' ? 12 : 24),\n//   `iv must be 12 bytes for C20P (ChaCha20-Poly1305) or 24 bytes for XC20P (XChaCha20-Poly1305)`\n// )\n\nexport type KmsEncryptDataEncryptionX20c = z.output<typeof zKmsEncryptDataEncryptionC20p>\n\nexport const zKmsEncryptDataEncryption = z.discriminatedUnion('algorithm', [\n  zKmsEncryptDataEncryptionAesCbc,\n  zKmsEncryptDataEncryptionAesCbcHmac,\n  zKmsEncryptDataEncryptionAesGcm,\n  zKmsEncryptDataEncryptionC20p,\n  zKmsDecryptDataEncryptionSalsa,\n])\nexport type KmsEncryptDataEncryption = z.output<typeof zKmsEncryptDataEncryption>\n\nexport const zKmsEncryptOptions = z.object({\n  /**\n   * The key to use for encrypting. There are three possible formats:\n   * - a key id, pointing to a symmetric (oct) jwk that can be used directly for encryption\n   * - a private symmetric (oct) jwk object that can be used directly for encryption\n   * - an object configuring key agreement, based on an existing assymetric key\n   */\n  key: z.union([\n    z.object({\n      keyId: zKmsKeyId,\n\n      // never helps with type narrowing\n      privateJwk: z.never().optional(),\n      keyAgreement: z.never().optional(),\n    }),\n    z.object({\n      privateJwk: zKmsJwkPrivateOct.describe('A private oct (symmetric) jwk'),\n\n      // never helps with type narrowing\n      keyId: z.never().optional(),\n      keyAgreement: z.never().optional(),\n    }),\n    z.object({\n      keyAgreement: zKmsKeyAgreementEncryptOptions,\n\n      // never helps with type narrowing\n      keyId: z.never().optional(),\n      privateJwk: z.never().optional(),\n    }),\n  ]),\n\n  /**\n   * The encryption algorithm used to encrypt the data/content.\n   * In JWE this parameter is referred to as \"enc\".\n   */\n  encryption: zKmsEncryptDataEncryption.describe(\n    'Options related to the encryption algorithm to use for encrypting the data'\n  ),\n\n  /**\n   * The data to encrypt\n   */\n  data: z.instanceof(Uint8Array).describe('The data to encrypt'),\n})\n\nexport type KmsEncryptOptions = z.output<typeof zKmsEncryptOptions>\nexport interface KmsEncryptReturn {\n  /**\n   * The encrypted data, also known as \"ciphertext\" in JWE\n   */\n  encrypted: Uint8Array\n\n  /**\n   * Optional authentication tag\n   */\n  tag?: Uint8Array\n\n  /**\n   * The initialization vector. For algorithms where the iv is required\n   * and not provided, this will contain the auto-generated value.\n   */\n  iv?: Uint8Array\n\n  /**\n   * The encrypted content encryption key, if key wrapping was used\n   */\n  encryptedKey?: KmsEncryptedKey\n}\n\nexport const zKmsEncryptedKey = z.object({\n  /**\n   * Optional authentication tag\n   */\n  tag: z.instanceof(Uint8Array).optional(),\n\n  /**\n   * The initialization vector.\n   */\n  iv: z.instanceof(Uint8Array).optional(),\n\n  /**\n   * The encrypted key\n   */\n  encrypted: z.instanceof(Uint8Array),\n})\n\n/**\n * An encrypted content encryption key (CEK).\n */\nexport type KmsEncryptedKey = z.infer<typeof zKmsEncryptedKey>\n"],"mappings":";;;;;;;;;AAMA,MAAM,kCAAkC,EAAE,OAAO;CAE/C,WAAW,EAAE,KAAK;EAChB,oCAAoC;EACpC,oCAAoC;EACpC,oCAAoC;EACrC,CAAC;CAEF,IAAI,EAAE,SAAS,EAAE,WAAW,WAAW,CAAC,QAAQ,OAAO,GAAG,WAAW,IAAI,kCAAkC,CAAC;CAC5G,KAAK,EAAE,SAAS,EAAE,WAAW,WAAW,CAAC;CAC1C,CAAC;AAIF,MAAM,kCAAkC,EAAE,OAAO;CAC/C,WAAW,EAAE,KAAK,CAAC,oCAAoC,SAAS,oCAAoC,QAAQ,CAAC;CAC7G,IAAI,EAAE,SAAS,EAAE,WAAW,WAAW,CAAC,QAAQ,OAAO,GAAG,WAAW,IAAI,kCAAkC,CAAC;CAC7G,CAAC;AAIF,MAAM,sCAAsC,EAAE,OAAO;CACnD,WAAW,EAAE,KAAK;EAChB,oCAAoC;EACpC,oCAAoC;EACpC,oCAAoC;EACrC,CAAC;CACF,IAAI,EAAE,SACJ,EAAE,WAAW,WAAW,CAAC,QAAQ,OAAO,GAAG,WAAW,IAAI,4CAA4C,CACvG;CACD,KAAK,EAAE,SAAS,EAAE,WAAW,WAAW,CAAC;CAC1C,CAAC;AAIF,MAAM,iCAAiC,EAAE,OAAO;CAC9C,WAAW,EAAE,KAAK,CAAC,oCAAoC,qBAAqB,CAAC;CAC7E,IAAI,EAAE,WAAW,WAAW,CAAC,UAAU;CACxC,CAAC;AAGF,MAAM,gCAAgC,EAAE,OAAO;CAC7C,WAAW,EAAE,KAAK,CAAC,oCAAoC,MAAM,oCAAoC,MAAM,CAAC;CACxG,IAAI,EAAE,SAAS,EAAE,WAAW,WAAW,CAAC;CACxC,KAAK,EAAE,SAAS,EAAE,WAAW,WAAW,CAAC;CAC1C,CAAC;AASF,MAAa,4BAA4B,EAAE,mBAAmB,aAAa;CACzE;CACA;CACA;CACA;CACA;CACD,CAAC;AAGF,MAAa,qBAAqB,EAAE,OAAO;CAOzC,KAAK,EAAE,MAAM;EACX,EAAE,OAAO;GACP,OAAO;GAGP,YAAY,EAAE,OAAO,CAAC,UAAU;GAChC,cAAc,EAAE,OAAO,CAAC,UAAU;GACnC,CAAC;EACF,EAAE,OAAO;GACP,YAAY,kBAAkB,SAAS,gCAAgC;GAGvE,OAAO,EAAE,OAAO,CAAC,UAAU;GAC3B,cAAc,EAAE,OAAO,CAAC,UAAU;GACnC,CAAC;EACF,EAAE,OAAO;GACP,cAAc;GAGd,OAAO,EAAE,OAAO,CAAC,UAAU;GAC3B,YAAY,EAAE,OAAO,CAAC,UAAU;GACjC,CAAC;EACH,CAAC;CAMF,YAAY,0BAA0B,SACpC,6EACD;CAKD,MAAM,EAAE,WAAW,WAAW,CAAC,SAAS,sBAAsB;CAC/D,CAAC;AA0BF,MAAa,mBAAmB,EAAE,OAAO;CAIvC,KAAK,EAAE,WAAW,WAAW,CAAC,UAAU;CAKxC,IAAI,EAAE,WAAW,WAAW,CAAC,UAAU;CAKvC,WAAW,EAAE,WAAW,WAAW;CACpC,CAAC"}
+{"version":3,"file":"KmsEncryptOptions.mjs","names":[],"sources":["../../../../src/modules/kms/options/KmsEncryptOptions.ts"],"sourcesContent":["import { z } from 'zod'\nimport type { AnyUint8Array, Uint8ArrayBuffer } from '../../../types'\nimport { zAnyUint8Array } from '../../../utils/zod'\nimport { KnownJwaContentEncryptionAlgorithms } from '../jwk/jwa'\nimport { zKmsJwkPrivateOct } from '../jwk/kty/oct/octJwk'\nimport { zKmsKeyId } from './common'\nimport { zKmsKeyAgreementEncryptOptions } from './KmsKeyAgreementEncryptOptions'\n\nconst zKmsEncryptDataEncryptionAesGcm = z.object({\n  // AES-GCM Content Encryption\n  algorithm: z.enum([\n    KnownJwaContentEncryptionAlgorithms.A128GCM,\n    KnownJwaContentEncryptionAlgorithms.A192GCM,\n    KnownJwaContentEncryptionAlgorithms.A256GCM,\n  ]),\n\n  iv: z.optional(zAnyUint8Array.refine((iv) => iv.length === 12, 'iv must be 12 bytes for AES GCM')),\n  aad: z.optional(zAnyUint8Array),\n})\nexport type KmsEncryptDataEncryptionAesGcm = z.output<typeof zKmsEncryptDataEncryptionAesGcm>\n\n// AES-CBC Content Encryption\nconst zKmsEncryptDataEncryptionAesCbc = z.object({\n  algorithm: z.enum([KnownJwaContentEncryptionAlgorithms.A128CBC, KnownJwaContentEncryptionAlgorithms.A256CBC]),\n  iv: z.optional(zAnyUint8Array.refine((iv) => iv.length === 16, 'iv must be 16 bytes for AES CBC')),\n})\nexport type KmsEncryptDataEncryptionAesCbc = z.output<typeof zKmsEncryptDataEncryptionAesCbc>\n\n// AES-CBC with HMAC-SHA2 Content Encryption\nconst zKmsEncryptDataEncryptionAesCbcHmac = z.object({\n  algorithm: z.enum([\n    KnownJwaContentEncryptionAlgorithms.A128CBC_HS256,\n    KnownJwaContentEncryptionAlgorithms.A192CBC_HS384,\n    KnownJwaContentEncryptionAlgorithms.A256CBC_HS512,\n  ]),\n  iv: z.optional(zAnyUint8Array.refine((iv) => iv.length === 16, 'iv must be 16 bytes for AES CBC with HMAC')),\n  aad: z.optional(zAnyUint8Array),\n})\nexport type KmsEncryptDataEncryptionAesCbcHmac = z.output<typeof zKmsEncryptDataEncryptionAesCbcHmac>\n\n// XSalsa-Poly1305 Content Encryption\nconst zKmsDecryptDataEncryptionSalsa = z.object({\n  algorithm: z.enum([KnownJwaContentEncryptionAlgorithms['XSALSA20-POLY1305']]),\n  iv: zAnyUint8Array.optional(),\n})\n\n// ChaCha20-Poly130 Content Encryption\nconst zKmsEncryptDataEncryptionC20p = z.object({\n  algorithm: z.enum([KnownJwaContentEncryptionAlgorithms.C20P, KnownJwaContentEncryptionAlgorithms.XC20P]),\n  iv: z.optional(zAnyUint8Array),\n  aad: z.optional(zAnyUint8Array),\n})\n// FIXME: if we use refine, we can't use discriminated union. and that makes the error handlnig shitty\n// .refine(\n//   ({ iv, algorithm }) => !iv || iv.length === (algorithm === 'C20P' ? 12 : 24),\n//   `iv must be 12 bytes for C20P (ChaCha20-Poly1305) or 24 bytes for XC20P (XChaCha20-Poly1305)`\n// )\n\nexport type KmsEncryptDataEncryptionX20c = z.output<typeof zKmsEncryptDataEncryptionC20p>\n\nexport const zKmsEncryptDataEncryption = z.discriminatedUnion('algorithm', [\n  zKmsEncryptDataEncryptionAesCbc,\n  zKmsEncryptDataEncryptionAesCbcHmac,\n  zKmsEncryptDataEncryptionAesGcm,\n  zKmsEncryptDataEncryptionC20p,\n  zKmsDecryptDataEncryptionSalsa,\n])\nexport type KmsEncryptDataEncryption = z.output<typeof zKmsEncryptDataEncryption>\n\nexport const zKmsEncryptOptions = z.object({\n  /**\n   * The key to use for encrypting. There are three possible formats:\n   * - a key id, pointing to a symmetric (oct) jwk that can be used directly for encryption\n   * - a private symmetric (oct) jwk object that can be used directly for encryption\n   * - an object configuring key agreement, based on an existing assymetric key\n   */\n  key: z.union([\n    z.object({\n      keyId: zKmsKeyId,\n\n      // never helps with type narrowing\n      privateJwk: z.never().optional(),\n      keyAgreement: z.never().optional(),\n    }),\n    z.object({\n      privateJwk: zKmsJwkPrivateOct.describe('A private oct (symmetric) jwk'),\n\n      // never helps with type narrowing\n      keyId: z.never().optional(),\n      keyAgreement: z.never().optional(),\n    }),\n    z.object({\n      keyAgreement: zKmsKeyAgreementEncryptOptions,\n\n      // never helps with type narrowing\n      keyId: z.never().optional(),\n      privateJwk: z.never().optional(),\n    }),\n  ]),\n\n  /**\n   * The encryption algorithm used to encrypt the data/content.\n   * In JWE this parameter is referred to as \"enc\".\n   */\n  encryption: zKmsEncryptDataEncryption.describe(\n    'Options related to the encryption algorithm to use for encrypting the data'\n  ),\n\n  /**\n   * The data to encrypt\n   */\n  data: zAnyUint8Array.describe('The data to encrypt'),\n})\n\nexport type KmsEncryptOptions = z.output<typeof zKmsEncryptOptions>\nexport interface KmsEncryptReturn {\n  /**\n   * The encrypted data, also known as \"ciphertext\" in JWE\n   */\n  encrypted: Uint8ArrayBuffer\n\n  /**\n   * Optional authentication tag\n   */\n  tag?: Uint8ArrayBuffer\n\n  /**\n   * The initialization vector. For algorithms where the iv is required\n   * and not provided, this will contain the auto-generated value.\n   */\n  iv?: AnyUint8Array // may be any uint8array since the user can also provide it as input\n\n  /**\n   * The encrypted content encryption key, if key wrapping was used\n   */\n  encryptedKey?: KmsEncryptedKey\n}\n\nexport const zKmsEncryptedKey = z.object({\n  /**\n   * Optional authentication tag\n   */\n  tag: zAnyUint8Array.optional(),\n\n  /**\n   * The initialization vector.\n   */\n  iv: zAnyUint8Array.optional(),\n\n  /**\n   * The encrypted key\n   */\n  encrypted: zAnyUint8Array,\n})\n\n/**\n * An encrypted content encryption key (CEK).\n */\nexport type KmsEncryptedKey = z.infer<typeof zKmsEncryptedKey>\n"],"mappings":";;;;;;;;;;AAQA,MAAM,kCAAkC,EAAE,OAAO;CAE/C,WAAW,EAAE,KAAK;EAChB,oCAAoC;EACpC,oCAAoC;EACpC,oCAAoC;EACrC,CAAC;CAEF,IAAI,EAAE,SAAS,eAAe,QAAQ,OAAO,GAAG,WAAW,IAAI,kCAAkC,CAAC;CAClG,KAAK,EAAE,SAAS,eAAe;CAChC,CAAC;AAIF,MAAM,kCAAkC,EAAE,OAAO;CAC/C,WAAW,EAAE,KAAK,CAAC,oCAAoC,SAAS,oCAAoC,QAAQ,CAAC;CAC7G,IAAI,EAAE,SAAS,eAAe,QAAQ,OAAO,GAAG,WAAW,IAAI,kCAAkC,CAAC;CACnG,CAAC;AAIF,MAAM,sCAAsC,EAAE,OAAO;CACnD,WAAW,EAAE,KAAK;EAChB,oCAAoC;EACpC,oCAAoC;EACpC,oCAAoC;EACrC,CAAC;CACF,IAAI,EAAE,SAAS,eAAe,QAAQ,OAAO,GAAG,WAAW,IAAI,4CAA4C,CAAC;CAC5G,KAAK,EAAE,SAAS,eAAe;CAChC,CAAC;AAIF,MAAM,iCAAiC,EAAE,OAAO;CAC9C,WAAW,EAAE,KAAK,CAAC,oCAAoC,qBAAqB,CAAC;CAC7E,IAAI,eAAe,UAAU;CAC9B,CAAC;AAGF,MAAM,gCAAgC,EAAE,OAAO;CAC7C,WAAW,EAAE,KAAK,CAAC,oCAAoC,MAAM,oCAAoC,MAAM,CAAC;CACxG,IAAI,EAAE,SAAS,eAAe;CAC9B,KAAK,EAAE,SAAS,eAAe;CAChC,CAAC;AASF,MAAa,4BAA4B,EAAE,mBAAmB,aAAa;CACzE;CACA;CACA;CACA;CACA;CACD,CAAC;AAGF,MAAa,qBAAqB,EAAE,OAAO;CAOzC,KAAK,EAAE,MAAM;EACX,EAAE,OAAO;GACP,OAAO;GAGP,YAAY,EAAE,OAAO,CAAC,UAAU;GAChC,cAAc,EAAE,OAAO,CAAC,UAAU;GACnC,CAAC;EACF,EAAE,OAAO;GACP,YAAY,kBAAkB,SAAS,gCAAgC;GAGvE,OAAO,EAAE,OAAO,CAAC,UAAU;GAC3B,cAAc,EAAE,OAAO,CAAC,UAAU;GACnC,CAAC;EACF,EAAE,OAAO;GACP,cAAc;GAGd,OAAO,EAAE,OAAO,CAAC,UAAU;GAC3B,YAAY,EAAE,OAAO,CAAC,UAAU;GACjC,CAAC;EACH,CAAC;CAMF,YAAY,0BAA0B,SACpC,6EACD;CAKD,MAAM,eAAe,SAAS,sBAAsB;CACrD,CAAC;AA0BF,MAAa,mBAAmB,EAAE,OAAO;CAIvC,KAAK,eAAe,UAAU;CAK9B,IAAI,eAAe,UAAU;CAK7B,WAAW;CACZ,CAAC"}

package/build/modules/kms/options/KmsKeyAgreementDecryptOptions.d.mts

@@ -1,3 +1,4 @@
+import { AnyUint8Array } from "../../../types.mjs";
 import { z } from "zod";
 
 //#region src/modules/kms/options/KmsKeyAgreementDecryptOptions.d.ts
@@ -103,20 +104,20 @@ declare const zKmsKeyAgreementDecryptEcdhEsKw: z.ZodObject<{
    * The encrypted content encryption key (cek)
    */
   encryptedKey: z.ZodObject<{
-    tag: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-    iv: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-    encrypted: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
+    tag: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+    iv: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+    encrypted: z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>;
   }, "strip", z.ZodTypeAny, {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   }, {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   }>;
-  apu: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-  apv: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
+  apu: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+  apv: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
 }, "strip", z.ZodTypeAny, {
   keyId: string;
   algorithm: "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW";
@@ -151,12 +152,12 @@ declare const zKmsKeyAgreementDecryptEcdhEsKw: z.ZodObject<{
     d?: undefined;
   };
   encryptedKey: {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }, {
   keyId: string;
   algorithm: "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW";
@@ -191,12 +192,12 @@ declare const zKmsKeyAgreementDecryptEcdhEsKw: z.ZodObject<{
     d?: undefined;
   };
   encryptedKey: {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }>;
 type KmsKeyAgreementDecryptEcdhEsKw = z.output<typeof zKmsKeyAgreementDecryptEcdhEsKw>;
 declare const zKmsKeyAgreementDecryptEcdhHsalsa20: z.ZodObject<{
@@ -388,8 +389,8 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
     x5u?: string | undefined;
     d?: undefined;
   }>]>;
-  apu: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-  apv: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
+  apu: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+  apv: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
 }, "strip", z.ZodTypeAny, {
   keyId: string;
   algorithm: "ECDH-ES";
@@ -423,8 +424,8 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
     x5u?: string | undefined;
     d?: undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }, {
   keyId: string;
   algorithm: "ECDH-ES";
@@ -458,8 +459,8 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
     x5u?: string | undefined;
     d?: undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }>, z.ZodObject<{
   /**
    * The key id pointing to the ephemeral public key.
@@ -562,20 +563,20 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
    * The encrypted content encryption key (cek)
    */
   encryptedKey: z.ZodObject<{
-    tag: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-    iv: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-    encrypted: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
+    tag: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+    iv: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+    encrypted: z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>;
   }, "strip", z.ZodTypeAny, {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   }, {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   }>;
-  apu: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-  apv: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
+  apu: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+  apv: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
 }, "strip", z.ZodTypeAny, {
   keyId: string;
   algorithm: "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW";
@@ -610,12 +611,12 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
     d?: undefined;
   };
   encryptedKey: {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }, {
   keyId: string;
   algorithm: "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW";
@@ -650,12 +651,12 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
     d?: undefined;
   };
   encryptedKey: {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }>, z.ZodObject<{
   /**
    * The key id to use for decrypting the content encryption key.

package/build/modules/kms/options/KmsKeyAgreementDecryptOptions.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"KmsKeyAgreementDecryptOptions.d.mts","names":[],"sources":["../../../../src/modules/kms/options/KmsKeyAgreementDecryptOptions.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"KmsKeyAgreementDecryptOptions.d.mts","names":[],"sources":["../../../../src/modules/kms/options/KmsKeyAgreementDecryptOptions.ts"],"sourcesContent":[],"mappings":";;;;cAOM,iCAA+B,CAAA,CAAA;;;;;AAPd;EA0BrB,KAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAnBmC,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAAA,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAoBzB,OAAA,CAAA,EAAA,MAAA,EAAA,GAAA,SAA8B;IAAA,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAAmB,GAAA,CAAA,EAAA,OAAA,GAAA,SAAA;IAAhB,GAAE,CAAA,EAAA,MAAA,EAAA,GAAA,SAAA;IAAM,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAE/C,UAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAiBJ,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAjBuC,GAAA,CAAA,kBAAA,SAAA;EAkB7B,GAAA,CAAA,kBAAkC,SAAA;CAAA,CAAA;AAAmB,KApBrD,8BAAA,GAAiC,CAAA,CAAE,MAoBkB,CAAA,OApBJ,+BAoBI,CAAA;cAlB3D,mCAkB6C,EAlBV,CAAA,CAAA,SAkBU,CAAA;EAAM;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAFY,kCAAA,GAAqC,CAAA,CAAE,cAAc;cAEpD,gCAA8B,CAAA,CAAA,oCAAA,CAAA,CAAA;;;;;;;;;;;IAAA,GAAA,eAAA,aAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAA,CAAA,EAAA,MAAA;IAAA,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAO/B,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAA6B,OAAA,CAAA,EAAA,MAAA,EAAA,GAAA,SAAA;IAAmB,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAAhB,GAAE,CAAA,EAAA,OAAA,GAAA,SAAA;IAAM,GAAA,CAAA,EAAA,MAAA,EAAA,GAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAxC,6BAAA,GAAgC,CAAA,CAAE,cAAc"}

package/build/modules/kms/options/KmsKeyAgreementDecryptOptions.d.ts

@@ -1,3 +1,4 @@
+import { AnyUint8Array } from "../../../types.js";
 import { z } from "zod";
 
 //#region src/modules/kms/options/KmsKeyAgreementDecryptOptions.d.ts
@@ -103,20 +104,20 @@ declare const zKmsKeyAgreementDecryptEcdhEsKw: z.ZodObject<{
    * The encrypted content encryption key (cek)
    */
   encryptedKey: z.ZodObject<{
-    tag: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-    iv: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-    encrypted: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
+    tag: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+    iv: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+    encrypted: z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>;
   }, "strip", z.ZodTypeAny, {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   }, {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   }>;
-  apu: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-  apv: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
+  apu: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+  apv: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
 }, "strip", z.ZodTypeAny, {
   keyId: string;
   algorithm: "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW";
@@ -151,12 +152,12 @@ declare const zKmsKeyAgreementDecryptEcdhEsKw: z.ZodObject<{
     d?: undefined;
   };
   encryptedKey: {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }, {
   keyId: string;
   algorithm: "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW";
@@ -191,12 +192,12 @@ declare const zKmsKeyAgreementDecryptEcdhEsKw: z.ZodObject<{
     d?: undefined;
   };
   encryptedKey: {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }>;
 type KmsKeyAgreementDecryptEcdhEsKw = z.output<typeof zKmsKeyAgreementDecryptEcdhEsKw>;
 declare const zKmsKeyAgreementDecryptEcdhHsalsa20: z.ZodObject<{
@@ -388,8 +389,8 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
     x5u?: string | undefined;
     d?: undefined;
   }>]>;
-  apu: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-  apv: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
+  apu: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+  apv: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
 }, "strip", z.ZodTypeAny, {
   keyId: string;
   algorithm: "ECDH-ES";
@@ -423,8 +424,8 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
     x5u?: string | undefined;
     d?: undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }, {
   keyId: string;
   algorithm: "ECDH-ES";
@@ -458,8 +459,8 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
     x5u?: string | undefined;
     d?: undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }>, z.ZodObject<{
   /**
    * The key id pointing to the ephemeral public key.
@@ -562,20 +563,20 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
    * The encrypted content encryption key (cek)
    */
   encryptedKey: z.ZodObject<{
-    tag: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-    iv: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-    encrypted: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
+    tag: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+    iv: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+    encrypted: z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>;
   }, "strip", z.ZodTypeAny, {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   }, {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   }>;
-  apu: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
-  apv: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
+  apu: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
+  apv: z.ZodOptional<z.ZodType<AnyUint8Array, z.ZodTypeDef, AnyUint8Array>>;
 }, "strip", z.ZodTypeAny, {
   keyId: string;
   algorithm: "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW";
@@ -610,12 +611,12 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
     d?: undefined;
   };
   encryptedKey: {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }, {
   keyId: string;
   algorithm: "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW";
@@ -650,12 +651,12 @@ declare const zKmsKeyAgreementDecryptOptions: z.ZodDiscriminatedUnion<"algorithm
     d?: undefined;
   };
   encryptedKey: {
-    encrypted: Uint8Array<ArrayBuffer>;
-    iv?: Uint8Array<ArrayBuffer> | undefined;
-    tag?: Uint8Array<ArrayBuffer> | undefined;
+    encrypted: AnyUint8Array;
+    iv?: AnyUint8Array | undefined;
+    tag?: AnyUint8Array | undefined;
   };
-  apu?: Uint8Array<ArrayBuffer> | undefined;
-  apv?: Uint8Array<ArrayBuffer> | undefined;
+  apu?: AnyUint8Array | undefined;
+  apv?: AnyUint8Array | undefined;
 }>, z.ZodObject<{
   /**
    * The key id to use for decrypting the content encryption key.

package/build/modules/kms/options/KmsKeyAgreementDecryptOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KmsKeyAgreementDecryptOptions.d.ts","names":[],"sources":["../../../../src/modules/kms/options/KmsKeyAgreementDecryptOptions.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"KmsKeyAgreementDecryptOptions.d.ts","names":[],"sources":["../../../../src/modules/kms/options/KmsKeyAgreementDecryptOptions.ts"],"sourcesContent":[],"mappings":";;;;cAOM,iCAA+B,CAAA,CAAA;;;AAPd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAOc,CAAA,EAAA,MAAA;IAAA,CAAA,EAAA,MAAA;IAoBzB,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAA8B,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAAmB,OAAA,CAAA,EAAA,MAAA,EAAA,GAAA,SAAA;IAAhB,GAAE,CAAA,EAAA,MAAA,GAAA,SAAA;IAAM,GAAA,CAAA,EAAA,OAAA,GAAA,SAAA;IAE/C,GAAA,CAAA,EAAA,MAAA,EAAA,GAAA,SAAA;IAiBJ,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjBuC,EAAA,CAAA,kBAAA,SAAA;IAAA,GAAA,CAAA,kBAAA,SAAA;EAkB7B,CAAA;EAAkC,GAAA,CAAA,kBAAA,SAAA;KAAmB,CAAA,kBAAA,SAAA;;AAAR,KApB7C,8BAAA,GAAiC,CAAA,CAAE,MAoBU,CAAA,OApBI,+BAoBJ,CAAA;AAEzD,cApBM,mCA0B8D,EA1B3B,CAAA,CAAA,SA0B2B,CAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KARxD,kCAAA,GAAqC,CAAA,CAAE,cAAc;cAEpD,gCAA8B,CAAA,CAAA,oCAAA,CAAA,CAAA;;;;;;;;;IAAA,OAAA,eAAA,aAAA,WAAA,WAAA,CAAA,WAAA,CAAA,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,EAAA,MAAA,CAAA,EAAA,MAAA,EAAA,EAAA,MAAA,EAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAA,GAAA,EAAA,KAAA;IAAA,GAAA,EAAA,QAAA;IAO/B,CAAA,EAAA,MAAA;IAA6B,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAAmB,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAAhB,OAAE,CAAA,EAAA,MAAA,EAAA,GAAA,SAAA;IAAM,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAxC,6BAAA,GAAgC,CAAA,CAAE,cAAc"}

package/build/modules/kms/options/KmsKeyAgreementDecryptOptions.js

@@ -1,6 +1,7 @@
 
 
 const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.js');
+const require_zod = require('../../../utils/zod.js');
 const require_okpJwk = require('../jwk/kty/okp/okpJwk.js');
 const require_common = require('./common.js');
 const require_KmsKeyAgreementEncryptOptions = require('./KmsKeyAgreementEncryptOptions.js');
@@ -18,8 +19,8 @@ const zKmsKeyAgreementDecryptEcdhEsKw = zod.z.object({
 	]),
 	externalPublicJwk: require_KmsKeyAgreementEncryptOptions.zKmsJwkPublicEcdh,
 	encryptedKey: require_KmsEncryptOptions.zKmsEncryptedKey,
-	apu: zod.z.optional(zod.z.instanceof(Uint8Array)),
-	apv: zod.z.optional(zod.z.instanceof(Uint8Array))
+	apu: zod.z.optional(require_zod.zAnyUint8Array),
+	apv: zod.z.optional(require_zod.zAnyUint8Array)
 });
 const zKmsKeyAgreementDecryptEcdhHsalsa20 = zod.z.object({
 	keyId: require_common.zKmsKeyId,

package/build/modules/kms/options/KmsKeyAgreementDecryptOptions.mjs

@@ -1,5 +1,6 @@
 
 
+import { zAnyUint8Array } from "../../../utils/zod.mjs";
 import { zKmsJwkPublicOkp } from "../jwk/kty/okp/okpJwk.mjs";
 import { zKmsKeyId } from "./common.mjs";
 import { zKmsJwkPublicEcdh, zKmsKeyAgreementEcdhEs } from "./KmsKeyAgreementEncryptOptions.mjs";
@@ -16,8 +17,8 @@ const zKmsKeyAgreementDecryptEcdhEsKw = z.object({
 	]),
 	externalPublicJwk: zKmsJwkPublicEcdh,
 	encryptedKey: zKmsEncryptedKey,
-	apu: z.optional(z.instanceof(Uint8Array)),
-	apv: z.optional(z.instanceof(Uint8Array))
+	apu: z.optional(zAnyUint8Array),
+	apv: z.optional(zAnyUint8Array)
 });
 const zKmsKeyAgreementDecryptEcdhHsalsa20 = z.object({
 	keyId: zKmsKeyId,

package/build/modules/kms/options/KmsKeyAgreementDecryptOptions.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"KmsKeyAgreementDecryptOptions.mjs","names":[],"sources":["../../../../src/modules/kms/options/KmsKeyAgreementDecryptOptions.ts"],"sourcesContent":["import { z } from 'zod'\nimport { zKmsJwkPublicOkp } from '../jwk/kty/okp/okpJwk'\nimport { zKmsEncryptedKey } from './KmsEncryptOptions'\nimport { zKmsJwkPublicEcdh, zKmsKeyAgreementEcdhEs } from './KmsKeyAgreementEncryptOptions'\nimport { zKmsKeyId } from './common'\n\nconst zKmsKeyAgreementDecryptEcdhEsKw = z.object({\n  /**\n   * The key id pointing to the ephemeral public key.\n   *\n   * The key type MUST match with the externalPublicJwk\n   */\n  keyId: zKmsKeyId,\n\n  algorithm: z.enum(['ECDH-ES+A128KW', 'ECDH-ES+A192KW', 'ECDH-ES+A256KW']),\n\n  externalPublicJwk: zKmsJwkPublicEcdh,\n\n  /**\n   * The encrypted content encryption key (cek)\n   */\n  encryptedKey: zKmsEncryptedKey,\n\n  apu: z.optional(z.instanceof(Uint8Array)),\n  apv: z.optional(z.instanceof(Uint8Array)),\n})\nexport type KmsKeyAgreementDecryptEcdhEsKw = z.output<typeof zKmsKeyAgreementDecryptEcdhEsKw>\n\nconst zKmsKeyAgreementDecryptEcdhHsalsa20 = z.object({\n  /**\n   * The key id to use for decrypting the content encryption key.\n   */\n  keyId: zKmsKeyId,\n\n  /**\n   * Perform key agreement based on the HSALSA20 as used in Libsodium's\n   * Cryptobox. This is not based on an official JWA algorithm, but is\n   * used primarily for DIDComm v1 messaging.\n   */\n  algorithm: z.literal('ECDH-HSALSA20'),\n\n  /**\n   * Can be undefined for anonymous encryption\n   */\n  externalPublicJwk: zKmsJwkPublicOkp.extend({ crv: zKmsJwkPublicOkp.shape.crv.extract(['X25519']) }).optional(),\n})\nexport type KmsKeyAgreementDecryptEcdhHsalsa20 = z.output<typeof zKmsKeyAgreementDecryptEcdhHsalsa20>\n\nexport const zKmsKeyAgreementDecryptOptions = z\n  .discriminatedUnion('algorithm', [\n    zKmsKeyAgreementEcdhEs,\n    zKmsKeyAgreementDecryptEcdhEsKw,\n    zKmsKeyAgreementDecryptEcdhHsalsa20,\n  ])\n  .describe('Options for key agreement based on an assymetric key.')\nexport type KmsKeyAgreementDecryptOptions = z.output<typeof zKmsKeyAgreementDecryptOptions>\n"],"mappings":";;;;;;;;;AAMA,MAAM,kCAAkC,EAAE,OAAO;CAM/C,OAAO;CAEP,WAAW,EAAE,KAAK;EAAC;EAAkB;EAAkB;EAAiB,CAAC;CAEzE,mBAAmB;CAKnB,cAAc;CAEd,KAAK,EAAE,SAAS,EAAE,WAAW,WAAW,CAAC;CACzC,KAAK,EAAE,SAAS,EAAE,WAAW,WAAW,CAAC;CAC1C,CAAC;AAGF,MAAM,sCAAsC,EAAE,OAAO;CAInD,OAAO;CAOP,WAAW,EAAE,QAAQ,gBAAgB;CAKrC,mBAAmB,iBAAiB,OAAO,EAAE,KAAK,iBAAiB,MAAM,IAAI,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,UAAU;CAC/G,CAAC;AAGF,MAAa,iCAAiC,EAC3C,mBAAmB,aAAa;CAC/B;CACA;CACA;CACD,CAAC,CACD,SAAS,wDAAwD"}
+{"version":3,"file":"KmsKeyAgreementDecryptOptions.mjs","names":[],"sources":["../../../../src/modules/kms/options/KmsKeyAgreementDecryptOptions.ts"],"sourcesContent":["import { z } from 'zod'\nimport { zAnyUint8Array } from '../../../utils/zod'\nimport { zKmsJwkPublicOkp } from '../jwk/kty/okp/okpJwk'\nimport { zKmsKeyId } from './common'\nimport { zKmsEncryptedKey } from './KmsEncryptOptions'\nimport { zKmsJwkPublicEcdh, zKmsKeyAgreementEcdhEs } from './KmsKeyAgreementEncryptOptions'\n\nconst zKmsKeyAgreementDecryptEcdhEsKw = z.object({\n  /**\n   * The key id pointing to the ephemeral public key.\n   *\n   * The key type MUST match with the externalPublicJwk\n   */\n  keyId: zKmsKeyId,\n\n  algorithm: z.enum(['ECDH-ES+A128KW', 'ECDH-ES+A192KW', 'ECDH-ES+A256KW']),\n\n  externalPublicJwk: zKmsJwkPublicEcdh,\n\n  /**\n   * The encrypted content encryption key (cek)\n   */\n  encryptedKey: zKmsEncryptedKey,\n\n  apu: z.optional(zAnyUint8Array),\n  apv: z.optional(zAnyUint8Array),\n})\nexport type KmsKeyAgreementDecryptEcdhEsKw = z.output<typeof zKmsKeyAgreementDecryptEcdhEsKw>\n\nconst zKmsKeyAgreementDecryptEcdhHsalsa20 = z.object({\n  /**\n   * The key id to use for decrypting the content encryption key.\n   */\n  keyId: zKmsKeyId,\n\n  /**\n   * Perform key agreement based on the HSALSA20 as used in Libsodium's\n   * Cryptobox. This is not based on an official JWA algorithm, but is\n   * used primarily for DIDComm v1 messaging.\n   */\n  algorithm: z.literal('ECDH-HSALSA20'),\n\n  /**\n   * Can be undefined for anonymous encryption\n   */\n  externalPublicJwk: zKmsJwkPublicOkp.extend({ crv: zKmsJwkPublicOkp.shape.crv.extract(['X25519']) }).optional(),\n})\nexport type KmsKeyAgreementDecryptEcdhHsalsa20 = z.output<typeof zKmsKeyAgreementDecryptEcdhHsalsa20>\n\nexport const zKmsKeyAgreementDecryptOptions = z\n  .discriminatedUnion('algorithm', [\n    zKmsKeyAgreementEcdhEs,\n    zKmsKeyAgreementDecryptEcdhEsKw,\n    zKmsKeyAgreementDecryptEcdhHsalsa20,\n  ])\n  .describe('Options for key agreement based on an assymetric key.')\nexport type KmsKeyAgreementDecryptOptions = z.output<typeof zKmsKeyAgreementDecryptOptions>\n"],"mappings":";;;;;;;;;;AAOA,MAAM,kCAAkC,EAAE,OAAO;CAM/C,OAAO;CAEP,WAAW,EAAE,KAAK;EAAC;EAAkB;EAAkB;EAAiB,CAAC;CAEzE,mBAAmB;CAKnB,cAAc;CAEd,KAAK,EAAE,SAAS,eAAe;CAC/B,KAAK,EAAE,SAAS,eAAe;CAChC,CAAC;AAGF,MAAM,sCAAsC,EAAE,OAAO;CAInD,OAAO;CAOP,WAAW,EAAE,QAAQ,gBAAgB;CAKrC,mBAAmB,iBAAiB,OAAO,EAAE,KAAK,iBAAiB,MAAM,IAAI,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,UAAU;CAC/G,CAAC;AAGF,MAAa,iCAAiC,EAC3C,mBAAmB,aAAa;CAC/B;CACA;CACA;CACD,CAAC,CACD,SAAS,wDAAwD"}