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

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

@@ -0,0 +1,262 @@
+import { AnyUint8Array, Uint8ArrayBuffer } from "../../../types.mjs";
+import "../../../index.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsDecryptOptions.d.ts
+declare const zKmsDecryptDataDecryptionAesGcm: z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    A128GCM: "A128GCM";
+    A192GCM: "A192GCM";
+    A256GCM: "A256GCM";
+  }>;
+  iv: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+  aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  tag: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>;
+type KmsDecryptDataDecryptionAesGcm = z.output<typeof zKmsDecryptDataDecryptionAesGcm>;
+declare const zKmsDecryptDataDecryptionAesCbc: z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    A128CBC: "A128CBC";
+    A256CBC: "A256CBC";
+  }>;
+  iv: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>;
+type KmsDecryptDataDecryptionAesCbc = z.output<typeof zKmsDecryptDataDecryptionAesCbc>;
+declare const zKmsDecryptDataDecryptionC20p: z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    C20P: "C20P";
+    XC20P: "XC20P";
+  }>;
+  iv: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+  aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  tag: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>;
+type KmsDecryptDataDecryptionC20p = z.output<typeof zKmsDecryptDataDecryptionC20p>;
+declare const zKmsDecryptDataDecryption: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    A128CBC: "A128CBC";
+    A256CBC: "A256CBC";
+  }>;
+  iv: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>, z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    "A128CBC-HS256": "A128CBC-HS256";
+    "A192CBC-HS384": "A192CBC-HS384";
+    "A256CBC-HS512": "A256CBC-HS512";
+  }>;
+  iv: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+  aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  tag: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>, z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    A128GCM: "A128GCM";
+    A192GCM: "A192GCM";
+    A256GCM: "A256GCM";
+  }>;
+  iv: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+  aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  tag: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>, z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    C20P: "C20P";
+    XC20P: "XC20P";
+  }>;
+  iv: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+  aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  tag: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>, z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    "XSALSA20-POLY1305": "XSALSA20-POLY1305";
+  }>;
+  iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+}, z.core.$strip>], "algorithm">;
+type KmsDecryptDataDecryption = z.output<typeof zKmsDecryptDataDecryption>;
+declare const zKmsDecryptOptions: z.ZodObject<{
+  key: z.ZodUnion<readonly [z.ZodObject<{
+    keyId: z.ZodString;
+    privateJwk: z.ZodOptional<z.ZodNever>;
+    keyAgreement: z.ZodOptional<z.ZodNever>;
+  }, z.core.$strip>, z.ZodObject<{
+    privateJwk: 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>;
+    keyId: z.ZodOptional<z.ZodNever>;
+    keyAgreement: z.ZodOptional<z.ZodNever>;
+  }, z.core.$strip>, z.ZodObject<{
+    keyAgreement: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      keyId: z.ZodString;
+      algorithm: z.ZodLiteral<"ECDH-ES">;
+      externalPublicJwk: z.ZodUnion<readonly [z.ZodObject<{
+        kty: z.ZodLiteral<"OKP">;
+        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>;
+        crv: z.ZodEnum<{
+          X25519: "X25519";
+        }>;
+      }, z.core.$strip>, z.ZodObject<{
+        kty: z.ZodLiteral<"EC">;
+        x: z.ZodString;
+        y: z.ZodString;
+        d: 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>;
+        crv: z.ZodEnum<{
+          "P-256": "P-256";
+          "P-384": "P-384";
+          "P-521": "P-521";
+          secp256k1: "secp256k1";
+        }>;
+      }, z.core.$strip>]>;
+      apu: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+      apv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+    }, z.core.$strip>, z.ZodObject<{
+      keyId: z.ZodString;
+      algorithm: z.ZodEnum<{
+        "ECDH-ES+A128KW": "ECDH-ES+A128KW";
+        "ECDH-ES+A192KW": "ECDH-ES+A192KW";
+        "ECDH-ES+A256KW": "ECDH-ES+A256KW";
+      }>;
+      externalPublicJwk: z.ZodUnion<readonly [z.ZodObject<{
+        kty: z.ZodLiteral<"OKP">;
+        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>;
+        crv: z.ZodEnum<{
+          X25519: "X25519";
+        }>;
+      }, z.core.$strip>, z.ZodObject<{
+        kty: z.ZodLiteral<"EC">;
+        x: z.ZodString;
+        y: z.ZodString;
+        d: 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>;
+        crv: z.ZodEnum<{
+          "P-256": "P-256";
+          "P-384": "P-384";
+          "P-521": "P-521";
+          secp256k1: "secp256k1";
+        }>;
+      }, z.core.$strip>]>;
+      encryptedKey: z.ZodObject<{
+        tag: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+        iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+        encrypted: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+      }, z.core.$strip>;
+      apu: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+      apv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+    }, z.core.$strip>, z.ZodObject<{
+      keyId: z.ZodString;
+      algorithm: z.ZodLiteral<"ECDH-HSALSA20">;
+      externalPublicJwk: z.ZodOptional<z.ZodObject<{
+        kty: z.ZodLiteral<"OKP">;
+        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>;
+        crv: z.ZodEnum<{
+          X25519: "X25519";
+        }>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>], "algorithm">;
+    keyId: z.ZodOptional<z.ZodNever>;
+    privateJwk: z.ZodOptional<z.ZodNever>;
+  }, z.core.$strip>]>;
+  decryption: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    algorithm: z.ZodEnum<{
+      A128CBC: "A128CBC";
+      A256CBC: "A256CBC";
+    }>;
+    iv: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+  }, z.core.$strip>, z.ZodObject<{
+    algorithm: z.ZodEnum<{
+      "A128CBC-HS256": "A128CBC-HS256";
+      "A192CBC-HS384": "A192CBC-HS384";
+      "A256CBC-HS512": "A256CBC-HS512";
+    }>;
+    iv: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+    aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+    tag: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+  }, z.core.$strip>, z.ZodObject<{
+    algorithm: z.ZodEnum<{
+      A128GCM: "A128GCM";
+      A192GCM: "A192GCM";
+      A256GCM: "A256GCM";
+    }>;
+    iv: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+    aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+    tag: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+  }, z.core.$strip>, z.ZodObject<{
+    algorithm: z.ZodEnum<{
+      C20P: "C20P";
+      XC20P: "XC20P";
+    }>;
+    iv: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+    aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+    tag: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+  }, z.core.$strip>, z.ZodObject<{
+    algorithm: z.ZodEnum<{
+      "XSALSA20-POLY1305": "XSALSA20-POLY1305";
+    }>;
+    iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  }, z.core.$strip>], "algorithm">;
+  encrypted: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>;
+type KmsDecryptOptions = z.output<typeof zKmsDecryptOptions>;
+interface KmsDecryptReturn {
+  /**
+   * The decrypted data
+   */
+  data: Uint8ArrayBuffer;
+}
+//#endregion
+export { KmsDecryptDataDecryption, KmsDecryptDataDecryptionAesCbc, KmsDecryptDataDecryptionAesGcm, KmsDecryptDataDecryptionC20p, KmsDecryptOptions, KmsDecryptReturn };
+//# sourceMappingURL=KmsDecryptOptions.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsDecryptOptions.d.mts","names":[],"sources":["../../../../src/modules/kms/options/KmsDecryptOptions.ts"],"sourcesContent":[],"mappings":";;;;;cAQM,iCAA+B,CAAA,CAAA;;;;;EAA/B,CAAA,CAAA;;;;;KAYM,8BAAA,GAAiC,CAAA,CAAE,cAAc;cAGvD,iCAA+B,CAAA,CAAA;;;;;;;AAfA,KAmBzB,8BAAA,GAAiC,CAAA,CAAE,MAnBV,CAAA,OAmBwB,+BAnBxB,CAAA;AAgCgE,cAS/F,6BAKJ,EALiC,CAAA,CAAA,SAKjC,CAAA;;;;;;;;;KAMU,4BAAA,GAA+B,CAAA,CAAE,cAAc;cAErD,2BAAyB,CAAA,CAAA,uBAAA,CAAA,CAAA;;;IAbI,OAAA,EAAA,SAAA;EAAA,CAAA,CAAA;EAWvB,EAAA,aAAA,8BAAiC;AAA4C,CAAA,eAEnF,CAAA,aAAA,CAAA;;;;;;EAAyB,EAAA,aAAA,8BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;KAOnB,wBAAA,GAA2B,CAAA,CAAE,cAAc;cAE1C,oBAAkB,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;IATA,YAAA,eAAA,WAAA,CAAA;EAAA,CAAA,eAAA,CAAA,aAAA,CAAA;IAOnB,YAAA,yBAA2C,CAAA,YAAA,CAAA;MAE1C,KAAA,aA2CX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEU,iBAAA,GAAoB,CAAA,CAAE,cAAc;UAE/B,gBAAA;;;;QAIT"}

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

@@ -0,0 +1,76 @@
+
+
+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 { zKmsKeyAgreementDecryptOptions } from "./KmsKeyAgreementDecryptOptions.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsDecryptOptions.ts
+const zKmsDecryptDataDecryptionAesGcm = z.object({
+	algorithm: z.enum([
+		KnownJwaContentEncryptionAlgorithms.A128GCM,
+		KnownJwaContentEncryptionAlgorithms.A192GCM,
+		KnownJwaContentEncryptionAlgorithms.A256GCM
+	]),
+	iv: zAnyUint8Array.refine((iv) => iv.length === 12, "iv must be 12 bytes for AES GCM"),
+	aad: z.optional(zAnyUint8Array),
+	tag: zAnyUint8Array
+});
+const zKmsDecryptDataDecryptionAesCbc = z.object({
+	algorithm: z.enum([KnownJwaContentEncryptionAlgorithms.A128CBC, KnownJwaContentEncryptionAlgorithms.A256CBC]),
+	iv: zAnyUint8Array.refine((iv) => iv.length === 16, "iv must be 16 bytes for AES CBC")
+});
+const zKmsDecryptDataDecryptionAesCbcHmac = z.object({
+	algorithm: z.enum([
+		KnownJwaContentEncryptionAlgorithms.A128CBC_HS256,
+		KnownJwaContentEncryptionAlgorithms.A192CBC_HS384,
+		KnownJwaContentEncryptionAlgorithms.A256CBC_HS512
+	]),
+	iv: zAnyUint8Array.refine((iv) => iv.length === 16, "iv must be 16 bytes for AES CBC with HMAC"),
+	aad: z.optional(zAnyUint8Array),
+	tag: zAnyUint8Array
+});
+const zKmsDecryptDataDecryptionSalsa = z.object({
+	algorithm: z.enum([KnownJwaContentEncryptionAlgorithms["XSALSA20-POLY1305"]]),
+	iv: zAnyUint8Array.optional()
+});
+const zKmsDecryptDataDecryptionC20p = z.object({
+	algorithm: z.enum([KnownJwaContentEncryptionAlgorithms.C20P, KnownJwaContentEncryptionAlgorithms.XC20P]),
+	iv: zAnyUint8Array,
+	aad: z.optional(zAnyUint8Array),
+	tag: zAnyUint8Array
+});
+const zKmsDecryptDataDecryption = z.discriminatedUnion("algorithm", [
+	zKmsDecryptDataDecryptionAesCbc,
+	zKmsDecryptDataDecryptionAesCbcHmac,
+	zKmsDecryptDataDecryptionAesGcm,
+	zKmsDecryptDataDecryptionC20p,
+	zKmsDecryptDataDecryptionSalsa
+]);
+const zKmsDecryptOptions = z.object({
+	key: z.union([
+		z.object({
+			keyId: zKmsKeyId,
+			privateJwk: z.never().optional(),
+			keyAgreement: z.never().optional()
+		}),
+		z.object({
+			privateJwk: zKmsJwkPrivateOct.describe("A private oct (symmetric) jwk"),
+			keyId: z.never().optional(),
+			keyAgreement: z.never().optional()
+		}),
+		z.object({
+			keyAgreement: zKmsKeyAgreementDecryptOptions,
+			keyId: z.never().optional(),
+			privateJwk: z.never().optional()
+		})
+	]),
+	decryption: zKmsDecryptDataDecryption.describe("Options related to the decryption algorithm to use for decrypting the data"),
+	encrypted: zAnyUint8Array.describe("The encrypted data to decrypt")
+});
+
+//#endregion
+export { zKmsDecryptOptions };
+//# sourceMappingURL=KmsDecryptOptions.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsDecryptOptions.mjs","names":[],"sources":["../../../../src/modules/kms/options/KmsDecryptOptions.ts"],"sourcesContent":["import { z } from 'zod'\nimport type { 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 { zKmsKeyAgreementDecryptOptions } from './KmsKeyAgreementDecryptOptions'\n\nconst zKmsDecryptDataDecryptionAesGcm = z.object({\n  // AES-GCM Content Decryption\n  algorithm: z.enum([\n    KnownJwaContentEncryptionAlgorithms.A128GCM,\n    KnownJwaContentEncryptionAlgorithms.A192GCM,\n    KnownJwaContentEncryptionAlgorithms.A256GCM,\n  ]),\n\n  iv: zAnyUint8Array.refine((iv) => iv.length === 12, 'iv must be 12 bytes for AES GCM'),\n  aad: z.optional(zAnyUint8Array),\n  tag: zAnyUint8Array,\n})\nexport type KmsDecryptDataDecryptionAesGcm = z.output<typeof zKmsDecryptDataDecryptionAesGcm>\n\n// AES-CBC Content Decryption\nconst zKmsDecryptDataDecryptionAesCbc = z.object({\n  algorithm: z.enum([KnownJwaContentEncryptionAlgorithms.A128CBC, KnownJwaContentEncryptionAlgorithms.A256CBC]),\n  iv: zAnyUint8Array.refine((iv) => iv.length === 16, 'iv must be 16 bytes for AES CBC'),\n})\nexport type KmsDecryptDataDecryptionAesCbc = z.output<typeof zKmsDecryptDataDecryptionAesCbc>\n\n// AES-CBC Content Decryption\nconst zKmsDecryptDataDecryptionAesCbcHmac = z.object({\n  algorithm: z.enum([\n    KnownJwaContentEncryptionAlgorithms.A128CBC_HS256,\n    KnownJwaContentEncryptionAlgorithms.A192CBC_HS384,\n    KnownJwaContentEncryptionAlgorithms.A256CBC_HS512,\n  ]),\n  iv: zAnyUint8Array.refine((iv) => iv.length === 16, 'iv must be 16 bytes for AES CBC with HMAC'),\n  aad: z.optional(zAnyUint8Array),\n  tag: zAnyUint8Array,\n})\nexport type KmsDecryptDataDecryptionAesCbcHmac = z.output<typeof zKmsDecryptDataDecryptionAesCbcHmac>\n\n// XSalsa20-Poly1305 Content Decryption\nconst zKmsDecryptDataDecryptionSalsa = z.object({\n  algorithm: z.enum([KnownJwaContentEncryptionAlgorithms['XSALSA20-POLY1305']]),\n  iv: zAnyUint8Array.optional(),\n})\n\n// ChaCha20-Poly1305 Content Decryption\nconst zKmsDecryptDataDecryptionC20p = z.object({\n  algorithm: z.enum([KnownJwaContentEncryptionAlgorithms.C20P, KnownJwaContentEncryptionAlgorithms.XC20P]),\n  iv: zAnyUint8Array,\n  aad: z.optional(zAnyUint8Array),\n  tag: zAnyUint8Array,\n})\n// FIXME: see how we can do refine with the discriminated union\n// .refine(\n//   ({ iv, algorithm }) => iv.length === (algorithm === 'C20P' ? 12 : 24),\n//   `iv must be 12 bytes for C20P (ChaCha20-Poly1305) or 24 bytes for XC20P (XChaCha20-Poly1305)`\n// )\nexport type KmsDecryptDataDecryptionC20p = z.output<typeof zKmsDecryptDataDecryptionC20p>\n\nconst zKmsDecryptDataDecryption = z.discriminatedUnion('algorithm', [\n  zKmsDecryptDataDecryptionAesCbc,\n  zKmsDecryptDataDecryptionAesCbcHmac,\n  zKmsDecryptDataDecryptionAesGcm,\n  zKmsDecryptDataDecryptionC20p,\n  zKmsDecryptDataDecryptionSalsa,\n])\nexport type KmsDecryptDataDecryption = z.output<typeof zKmsDecryptDataDecryption>\n\nexport const zKmsDecryptOptions = z.object({\n  /**\n   * The key to use for decrypting. There are three possible formats:\n   * - a key id, pointing to a symmetric (oct) jwk that can be used directly for decryption\n   * - a private symmetric (oct) jwk object that can be used directly for decryption\n   * - an object configuring key agreement, based on an existing asymmetric 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: zKmsKeyAgreementDecryptOptions,\n\n      // never helps with type narrowing\n      keyId: z.never().optional(),\n      privateJwk: z.never().optional(),\n    }),\n  ]),\n\n  /**\n   * The decryption algorithm used to decrypt the data/content.\n   * In JWE this parameter is referred to as \"enc\".\n   */\n  decryption: zKmsDecryptDataDecryption.describe(\n    'Options related to the decryption algorithm to use for decrypting the data'\n  ),\n\n  /**\n   * The encrypted data to decrypt\n   */\n  encrypted: zAnyUint8Array.describe('The encrypted data to decrypt'),\n})\n\nexport type KmsDecryptOptions = z.output<typeof zKmsDecryptOptions>\n\nexport interface KmsDecryptReturn {\n  /**\n   * The decrypted data\n   */\n  data: Uint8ArrayBuffer\n}\n"],"mappings":";;;;;;;;;;AAQA,MAAM,kCAAkC,EAAE,OAAO;CAE/C,WAAW,EAAE,KAAK;EAChB,oCAAoC;EACpC,oCAAoC;EACpC,oCAAoC;EACrC,CAAC;CAEF,IAAI,eAAe,QAAQ,OAAO,GAAG,WAAW,IAAI,kCAAkC;CACtF,KAAK,EAAE,SAAS,eAAe;CAC/B,KAAK;CACN,CAAC;AAIF,MAAM,kCAAkC,EAAE,OAAO;CAC/C,WAAW,EAAE,KAAK,CAAC,oCAAoC,SAAS,oCAAoC,QAAQ,CAAC;CAC7G,IAAI,eAAe,QAAQ,OAAO,GAAG,WAAW,IAAI,kCAAkC;CACvF,CAAC;AAIF,MAAM,sCAAsC,EAAE,OAAO;CACnD,WAAW,EAAE,KAAK;EAChB,oCAAoC;EACpC,oCAAoC;EACpC,oCAAoC;EACrC,CAAC;CACF,IAAI,eAAe,QAAQ,OAAO,GAAG,WAAW,IAAI,4CAA4C;CAChG,KAAK,EAAE,SAAS,eAAe;CAC/B,KAAK;CACN,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;CACJ,KAAK,EAAE,SAAS,eAAe;CAC/B,KAAK;CACN,CAAC;AAQF,MAAM,4BAA4B,EAAE,mBAAmB,aAAa;CAClE;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,WAAW,eAAe,SAAS,gCAAgC;CACpE,CAAC"}

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsDeleteKeyOptions.d.ts
+declare const zKmsDeleteKeyOptions: z.ZodObject<{
+  keyId: z.ZodString;
+}, z.core.$strip>;
+type KmsDeleteKeyOptions = z.output<typeof zKmsDeleteKeyOptions>;
+//#endregion
+export { KmsDeleteKeyOptions };
+//# sourceMappingURL=KmsDeleteKeyOptions.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsDeleteKeyOptions.d.mts","names":[],"sources":["../../../../src/modules/kms/options/KmsDeleteKeyOptions.ts"],"sourcesContent":[],"mappings":";;;cAGa,sBAAoB,CAAA,CAAA;;;KAOrB,mBAAA,GAAsB,CAAA,CAAE,cAAc"}

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

@@ -0,0 +1,11 @@
+
+
+import { zKmsKeyId } from "./common.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsDeleteKeyOptions.ts
+const zKmsDeleteKeyOptions = z.object({ keyId: zKmsKeyId });
+
+//#endregion
+export { zKmsDeleteKeyOptions };
+//# sourceMappingURL=KmsDeleteKeyOptions.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsDeleteKeyOptions.mjs","names":[],"sources":["../../../../src/modules/kms/options/KmsDeleteKeyOptions.ts"],"sourcesContent":["import { z } from 'zod'\nimport { zKmsKeyId } from './common'\n\nexport const zKmsDeleteKeyOptions = z.object({\n  /**\n   * The `kid` for the key.\n   */\n  keyId: zKmsKeyId,\n})\n\nexport type KmsDeleteKeyOptions = z.output<typeof zKmsDeleteKeyOptions>\n"],"mappings":";;;;;;AAGA,MAAa,uBAAuB,EAAE,OAAO,EAI3C,OAAO,WACR,CAAC"}

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

@@ -0,0 +1,270 @@
+import { AnyUint8Array, Uint8ArrayBuffer } from "../../../types.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsEncryptOptions.d.ts
+declare const zKmsEncryptDataEncryptionAesGcm: z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    A128GCM: "A128GCM";
+    A192GCM: "A192GCM";
+    A256GCM: "A256GCM";
+  }>;
+  iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+}, z.core.$strip>;
+type KmsEncryptDataEncryptionAesGcm = z.output<typeof zKmsEncryptDataEncryptionAesGcm>;
+declare const zKmsEncryptDataEncryptionAesCbc: z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    A128CBC: "A128CBC";
+    A256CBC: "A256CBC";
+  }>;
+  iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+}, z.core.$strip>;
+type KmsEncryptDataEncryptionAesCbc = z.output<typeof zKmsEncryptDataEncryptionAesCbc>;
+declare const zKmsEncryptDataEncryptionC20p: z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    C20P: "C20P";
+    XC20P: "XC20P";
+  }>;
+  iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+}, z.core.$strip>;
+type KmsEncryptDataEncryptionX20c = z.output<typeof zKmsEncryptDataEncryptionC20p>;
+declare const zKmsEncryptDataEncryption: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    A128CBC: "A128CBC";
+    A256CBC: "A256CBC";
+  }>;
+  iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+}, z.core.$strip>, z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    "A128CBC-HS256": "A128CBC-HS256";
+    "A192CBC-HS384": "A192CBC-HS384";
+    "A256CBC-HS512": "A256CBC-HS512";
+  }>;
+  iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+}, z.core.$strip>, z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    A128GCM: "A128GCM";
+    A192GCM: "A192GCM";
+    A256GCM: "A256GCM";
+  }>;
+  iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+}, z.core.$strip>, z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    C20P: "C20P";
+    XC20P: "XC20P";
+  }>;
+  iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+}, z.core.$strip>, z.ZodObject<{
+  algorithm: z.ZodEnum<{
+    "XSALSA20-POLY1305": "XSALSA20-POLY1305";
+  }>;
+  iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+}, z.core.$strip>], "algorithm">;
+type KmsEncryptDataEncryption = z.output<typeof zKmsEncryptDataEncryption>;
+declare const zKmsEncryptOptions: z.ZodObject<{
+  key: z.ZodUnion<readonly [z.ZodObject<{
+    keyId: z.ZodString;
+    privateJwk: z.ZodOptional<z.ZodNever>;
+    keyAgreement: z.ZodOptional<z.ZodNever>;
+  }, z.core.$strip>, z.ZodObject<{
+    privateJwk: 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>;
+    keyId: z.ZodOptional<z.ZodNever>;
+    keyAgreement: z.ZodOptional<z.ZodNever>;
+  }, z.core.$strip>, z.ZodObject<{
+    keyAgreement: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      keyId: z.ZodString;
+      algorithm: z.ZodLiteral<"ECDH-ES">;
+      externalPublicJwk: z.ZodUnion<readonly [z.ZodObject<{
+        kty: z.ZodLiteral<"OKP">;
+        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>;
+        crv: z.ZodEnum<{
+          X25519: "X25519";
+        }>;
+      }, z.core.$strip>, z.ZodObject<{
+        kty: z.ZodLiteral<"EC">;
+        x: z.ZodString;
+        y: z.ZodString;
+        d: 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>;
+        crv: z.ZodEnum<{
+          "P-256": "P-256";
+          "P-384": "P-384";
+          "P-521": "P-521";
+          secp256k1: "secp256k1";
+        }>;
+      }, z.core.$strip>]>;
+      apu: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+      apv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+    }, z.core.$strip>, z.ZodObject<{
+      keyId: z.ZodString;
+      algorithm: z.ZodEnum<{
+        "ECDH-ES+A128KW": "ECDH-ES+A128KW";
+        "ECDH-ES+A192KW": "ECDH-ES+A192KW";
+        "ECDH-ES+A256KW": "ECDH-ES+A256KW";
+      }>;
+      externalPublicJwk: z.ZodUnion<readonly [z.ZodObject<{
+        kty: z.ZodLiteral<"OKP">;
+        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>;
+        crv: z.ZodEnum<{
+          X25519: "X25519";
+        }>;
+      }, z.core.$strip>, z.ZodObject<{
+        kty: z.ZodLiteral<"EC">;
+        x: z.ZodString;
+        y: z.ZodString;
+        d: 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>;
+        crv: z.ZodEnum<{
+          "P-256": "P-256";
+          "P-384": "P-384";
+          "P-521": "P-521";
+          secp256k1: "secp256k1";
+        }>;
+      }, z.core.$strip>]>;
+      apu: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+      apv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+    }, z.core.$strip>, z.ZodObject<{
+      keyId: z.ZodOptional<z.ZodString>;
+      algorithm: z.ZodLiteral<"ECDH-HSALSA20">;
+      externalPublicJwk: z.ZodObject<{
+        kty: z.ZodLiteral<"OKP">;
+        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>;
+        crv: z.ZodEnum<{
+          X25519: "X25519";
+        }>;
+      }, z.core.$strip>;
+    }, z.core.$strip>], "algorithm">;
+    keyId: z.ZodOptional<z.ZodNever>;
+    privateJwk: z.ZodOptional<z.ZodNever>;
+  }, z.core.$strip>]>;
+  encryption: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    algorithm: z.ZodEnum<{
+      A128CBC: "A128CBC";
+      A256CBC: "A256CBC";
+    }>;
+    iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  }, z.core.$strip>, z.ZodObject<{
+    algorithm: z.ZodEnum<{
+      "A128CBC-HS256": "A128CBC-HS256";
+      "A192CBC-HS384": "A192CBC-HS384";
+      "A256CBC-HS512": "A256CBC-HS512";
+    }>;
+    iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+    aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  }, z.core.$strip>, z.ZodObject<{
+    algorithm: z.ZodEnum<{
+      A128GCM: "A128GCM";
+      A192GCM: "A192GCM";
+      A256GCM: "A256GCM";
+    }>;
+    iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+    aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  }, z.core.$strip>, z.ZodObject<{
+    algorithm: z.ZodEnum<{
+      C20P: "C20P";
+      XC20P: "XC20P";
+    }>;
+    iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+    aad: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  }, z.core.$strip>, z.ZodObject<{
+    algorithm: z.ZodEnum<{
+      "XSALSA20-POLY1305": "XSALSA20-POLY1305";
+    }>;
+    iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  }, z.core.$strip>], "algorithm">;
+  data: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>;
+type KmsEncryptOptions = z.output<typeof zKmsEncryptOptions>;
+interface KmsEncryptReturn {
+  /**
+   * The encrypted data, also known as "ciphertext" in JWE
+   */
+  encrypted: Uint8ArrayBuffer;
+  /**
+   * Optional authentication tag
+   */
+  tag?: Uint8ArrayBuffer;
+  /**
+   * The initialization vector. For algorithms where the iv is required
+   * and not provided, this will contain the auto-generated value.
+   */
+  iv?: AnyUint8Array;
+  /**
+   * The encrypted content encryption key, if key wrapping was used
+   */
+  encryptedKey?: KmsEncryptedKey;
+}
+declare const zKmsEncryptedKey: z.ZodObject<{
+  tag: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  iv: z.ZodOptional<z.ZodCustom<AnyUint8Array, AnyUint8Array>>;
+  encrypted: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>;
+/**
+ * An encrypted content encryption key (CEK).
+ */
+type KmsEncryptedKey = z.infer<typeof zKmsEncryptedKey>;
+//#endregion
+export { KmsEncryptDataEncryption, KmsEncryptDataEncryptionAesCbc, KmsEncryptDataEncryptionAesGcm, KmsEncryptDataEncryptionX20c, KmsEncryptOptions, KmsEncryptReturn, KmsEncryptedKey };
+//# sourceMappingURL=KmsEncryptOptions.d.mts.map