@credo-ts/core 0.6.1-pr-2091-20241119140918 → 0.6.2-alpha-20251210145840

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

@@ -0,0 +1,270 @@
+import { AnyUint8Array } from "../../../types.mjs";
+import "../../../index.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsKeyAgreementEncryptOptions.d.ts
+declare const zKmsJwkPublicEcdh: 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>]>;
+type KmsJwkPublicEcdh = z.infer<typeof zKmsJwkPublicEcdh>;
+declare const zKmsKeyAgreementEcdhEs: 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>;
+type KmsKeyAgreementEcdhEs = z.output<typeof zKmsKeyAgreementEcdhEs>;
+declare const zKmsKeyAgreementEncryptEcdhEsKw: 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>;
+type KmsKeyAgreementEncryptEcdhEsKw = z.output<typeof zKmsKeyAgreementEncryptEcdhEsKw>;
+declare const zKmsKeyAgreementEncryptEcdhHsalsa20: 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>;
+type KmsKeyAgreementEncryptEcdhHsalsa20 = z.output<typeof zKmsKeyAgreementEncryptEcdhHsalsa20>;
+declare const zKmsKeyAgreementEncryptOptions: 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">;
+type KmsKeyAgreementEncryptOptions = z.output<typeof zKmsKeyAgreementEncryptOptions>;
+//#endregion
+export { KmsJwkPublicEcdh, KmsKeyAgreementEcdhEs, KmsKeyAgreementEncryptEcdhEsKw, KmsKeyAgreementEncryptEcdhHsalsa20, KmsKeyAgreementEncryptOptions };
+//# sourceMappingURL=KmsKeyAgreementEncryptOptions.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsKeyAgreementEncryptOptions.d.mts","names":[],"sources":["../../../../src/modules/kms/options/KmsKeyAgreementEncryptOptions.ts"],"sourcesContent":[],"mappings":";;;;;cAMa,mBAAiB,CAAA,CAAA,mBAAA,CAAA,CAAA;;;;;;EAAjB,OAAA,eAGX,WAAA,WAAA,CAAA,SAAA,WAAA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEU,gBAAA,GAAmB,CAAA,CAAE,aAAa;cAEjC,wBAAsB,CAAA,CAAA;;;;;;;;;IAPL,OAAA,eAAA,WAAA,WAAA,CAAA,SAAA,WAAA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsBlB,qBAAA,GAAwB,CAAA,CAAE,cAAc;cAE9C,iCAA+B,CAAA,CAAA;;;;;;;;IAxBP,GAAA,cAAA,CAAA,KAAA,CAAA;IAAA,CAAA,aAAA;IAKlB,CAAA,eAAgB,YAAkB,CAAA;IAEjC,GAAA,eAAA,YAcX,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkBU,8BAAA,GAAiC,CAAA,CAAE,cAAc;cAEvD,qCAAmC,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;KAgB7B,kCAAA,GAAqC,CAAA,CAAE,cAAc;cAEpD,gCAA8B,CAAA,CAAA,uBAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MApDR,SAAA,EAAA,WAAA;IAAA,CAAA,CAAA;EAevB,CAAA,eAAA,CAAA,CAAA,CAAA;EAEN,GAAA,eAAA,YAAA,8BAcJ,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4BU,6BAAA,GAAgC,CAAA,CAAE,cAAc"}

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

@@ -0,0 +1,47 @@
+
+
+import { zAnyUint8Array } from "../../../utils/zod.mjs";
+import { zKmsJwkPublicEc } from "../jwk/kty/ec/ecJwk.mjs";
+import { zKmsJwkPublicOkp } from "../jwk/kty/okp/okpJwk.mjs";
+import { zKmsKeyId } from "./common.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsKeyAgreementEncryptOptions.ts
+const zKmsJwkPublicEcdh = z.union([zKmsJwkPublicOkp.extend({ crv: zKmsJwkPublicOkp.shape.crv.extract(["X25519"]) }), zKmsJwkPublicEc.extend({ crv: zKmsJwkPublicEc.shape.crv.extract([
+	"P-256",
+	"P-384",
+	"P-521",
+	"secp256k1"
+]) })]);
+const zKmsKeyAgreementEcdhEs = z.object({
+	keyId: zKmsKeyId,
+	algorithm: z.literal("ECDH-ES"),
+	externalPublicJwk: zKmsJwkPublicEcdh,
+	apu: z.optional(zAnyUint8Array),
+	apv: z.optional(zAnyUint8Array)
+});
+const zKmsKeyAgreementEncryptEcdhEsKw = z.object({
+	keyId: zKmsKeyId,
+	algorithm: z.enum([
+		"ECDH-ES+A128KW",
+		"ECDH-ES+A192KW",
+		"ECDH-ES+A256KW"
+	]),
+	externalPublicJwk: zKmsJwkPublicEcdh,
+	apu: z.optional(zAnyUint8Array),
+	apv: z.optional(zAnyUint8Array)
+});
+const zKmsKeyAgreementEncryptEcdhHsalsa20 = z.object({
+	keyId: zKmsKeyId.optional(),
+	algorithm: z.literal("ECDH-HSALSA20"),
+	externalPublicJwk: zKmsJwkPublicOkp.extend({ crv: zKmsJwkPublicOkp.shape.crv.extract(["X25519"]) })
+});
+const zKmsKeyAgreementEncryptOptions = z.discriminatedUnion("algorithm", [
+	zKmsKeyAgreementEcdhEs,
+	zKmsKeyAgreementEncryptEcdhEsKw,
+	zKmsKeyAgreementEncryptEcdhHsalsa20
+]).describe("Options for key agreement based on an assymetric key.");
+
+//#endregion
+export { zKmsJwkPublicEcdh, zKmsKeyAgreementEcdhEs, zKmsKeyAgreementEncryptOptions };
+//# sourceMappingURL=KmsKeyAgreementEncryptOptions.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsKeyAgreementEncryptOptions.mjs","names":[],"sources":["../../../../src/modules/kms/options/KmsKeyAgreementEncryptOptions.ts"],"sourcesContent":["import { z } from 'zod'\nimport { zAnyUint8Array } from '../../../utils/zod'\nimport { zKmsJwkPublicEc } from '../jwk/kty/ec/ecJwk'\nimport { zKmsJwkPublicOkp } from '../jwk/kty/okp/okpJwk'\nimport { zKmsKeyId } from './common'\n\nexport const zKmsJwkPublicEcdh = z.union([\n  zKmsJwkPublicOkp.extend({ crv: zKmsJwkPublicOkp.shape.crv.extract(['X25519']) }),\n  zKmsJwkPublicEc.extend({ crv: zKmsJwkPublicEc.shape.crv.extract(['P-256', 'P-384', 'P-521', 'secp256k1']) }),\n])\n\nexport type KmsJwkPublicEcdh = z.infer<typeof zKmsJwkPublicEcdh>\n\nexport const zKmsKeyAgreementEcdhEs = 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.literal('ECDH-ES'),\n\n  externalPublicJwk: zKmsJwkPublicEcdh,\n\n  apu: z.optional(zAnyUint8Array),\n  apv: z.optional(zAnyUint8Array),\n})\nexport type KmsKeyAgreementEcdhEs = z.output<typeof zKmsKeyAgreementEcdhEs>\n\nconst zKmsKeyAgreementEncryptEcdhEsKw = 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  apu: z.optional(zAnyUint8Array),\n  apv: z.optional(zAnyUint8Array),\n})\nexport type KmsKeyAgreementEncryptEcdhEsKw = z.output<typeof zKmsKeyAgreementEncryptEcdhEsKw>\n\nconst zKmsKeyAgreementEncryptEcdhHsalsa20 = z.object({\n  /**\n   * The key id to use for encrypting the content encryption key.\n   * If no key id is provided, anonymous encryption is used.\n   */\n  keyId: zKmsKeyId.optional(),\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  externalPublicJwk: zKmsJwkPublicOkp.extend({ crv: zKmsJwkPublicOkp.shape.crv.extract(['X25519']) }),\n})\nexport type KmsKeyAgreementEncryptEcdhHsalsa20 = z.output<typeof zKmsKeyAgreementEncryptEcdhHsalsa20>\n\nexport const zKmsKeyAgreementEncryptOptions = z\n  .discriminatedUnion('algorithm', [\n    zKmsKeyAgreementEcdhEs,\n    zKmsKeyAgreementEncryptEcdhEsKw,\n    zKmsKeyAgreementEncryptEcdhHsalsa20,\n  ])\n  .describe('Options for key agreement based on an assymetric key.')\nexport type KmsKeyAgreementEncryptOptions = z.output<typeof zKmsKeyAgreementEncryptOptions>\n"],"mappings":";;;;;;;;;AAMA,MAAa,oBAAoB,EAAE,MAAM,CACvC,iBAAiB,OAAO,EAAE,KAAK,iBAAiB,MAAM,IAAI,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,EAChF,gBAAgB,OAAO,EAAE,KAAK,gBAAgB,MAAM,IAAI,QAAQ;CAAC;CAAS;CAAS;CAAS;CAAY,CAAC,EAAE,CAAC,CAC7G,CAAC;AAIF,MAAa,yBAAyB,EAAE,OAAO;CAM7C,OAAO;CAEP,WAAW,EAAE,QAAQ,UAAU;CAE/B,mBAAmB;CAEnB,KAAK,EAAE,SAAS,eAAe;CAC/B,KAAK,EAAE,SAAS,eAAe;CAChC,CAAC;AAGF,MAAM,kCAAkC,EAAE,OAAO;CAM/C,OAAO;CAEP,WAAW,EAAE,KAAK;EAAC;EAAkB;EAAkB;EAAiB,CAAC;CAEzE,mBAAmB;CAEnB,KAAK,EAAE,SAAS,eAAe;CAC/B,KAAK,EAAE,SAAS,eAAe;CAChC,CAAC;AAGF,MAAM,sCAAsC,EAAE,OAAO;CAKnD,OAAO,UAAU,UAAU;CAO3B,WAAW,EAAE,QAAQ,gBAAgB;CAErC,mBAAmB,iBAAiB,OAAO,EAAE,KAAK,iBAAiB,MAAM,IAAI,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;CACpG,CAAC;AAGF,MAAa,iCAAiC,EAC3C,mBAAmB,aAAa;CAC/B;CACA;CACA;CACD,CAAC,CACD,SAAS,wDAAwD"}

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

@@ -0,0 +1,47 @@
+import { KnownJwaSignatureAlgorithm } from "../jwk/jwa.mjs";
+import { KmsCreateKeyType } from "./KmsCreateKeyOptions.mjs";
+import { KmsDecryptDataDecryption } from "./KmsDecryptOptions.mjs";
+import { KmsEncryptDataEncryption } from "./KmsEncryptOptions.mjs";
+import { KmsKeyAgreementDecryptOptions } from "./KmsKeyAgreementDecryptOptions.mjs";
+import { KmsKeyAgreementEncryptOptions } from "./KmsKeyAgreementEncryptOptions.mjs";
+import { KmsJwkPrivate } from "../jwk/knownJwk.mjs";
+import "../jwk/index.mjs";
+
+//#region src/modules/kms/options/KmsOperation.d.ts
+type KmsOperationCreateKey = {
+  operation: 'createKey';
+  type: KmsCreateKeyType;
+};
+type KmsOperationImportKey = {
+  operation: 'importKey';
+  privateJwk: KmsJwkPrivate;
+};
+type KmsOperationDeleteKey = {
+  operation: 'deleteKey';
+};
+type KmsOperationSign = {
+  operation: 'sign';
+  algorithm: KnownJwaSignatureAlgorithm;
+};
+type KmsOperationVerify = {
+  operation: 'verify';
+  algorithm: KnownJwaSignatureAlgorithm;
+};
+type KmsOperationEncrypt = {
+  operation: 'encrypt';
+  encryption: KmsEncryptDataEncryption;
+  keyAgreement?: KmsKeyAgreementEncryptOptions;
+};
+type KmsOperationDecrypt = {
+  operation: 'decrypt';
+  decryption: KmsDecryptDataDecryption;
+  keyAgreement?: KmsKeyAgreementDecryptOptions;
+};
+type KmsOperationRandomBytes = {
+  operation: 'randomBytes';
+};
+type KmsOperation = KmsOperationCreateKey | KmsOperationImportKey | KmsOperationDeleteKey | KmsOperationSign | KmsOperationVerify | KmsOperationEncrypt | KmsOperationDecrypt | KmsOperationRandomBytes;
+declare function getKmsOperationHumanDescription(operation: KmsOperation): string;
+//#endregion
+export { KmsOperation, KmsOperationCreateKey, KmsOperationDecrypt, KmsOperationDeleteKey, KmsOperationEncrypt, KmsOperationImportKey, KmsOperationSign, KmsOperationVerify, getKmsOperationHumanDescription };
+//# sourceMappingURL=KmsOperation.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsOperation.d.mts","names":[],"sources":["../../../../src/modules/kms/options/KmsOperation.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;KAQY,qBAAA;;QAEJ;;KAGI,qBAAA;;EALA,UAAA,EAOE,aAPmB;AAKjC,CAAA;AAKY,KAAA,qBAAA,GAAqB;EAIrB,SAAA,EAAA,WAAgB;AAK5B,CAAA;AAKY,KAVA,gBAAA,GAUmB;EAMnB,SAAA,EAAA,MAAA;EAMA,SAAA,EApBC,0BAoBsB;AAInC,CAAA;AACI,KAtBQ,kBAAA,GAsBR;EACA,SAAA,EAAA,QAAA;EACA,SAAA,EAtBS,0BAsBT;CACA;AACA,KArBQ,mBAAA,GAqBR;EACA,SAAA,EAAA,SAAA;EACA,UAAA,EArBU,wBAqBV;EACA,YAAA,CAAA,EArBa,6BAqBb;CAAuB;AAEX,KApBJ,mBAAA,GAoBI;;cAlBF;iBACG;;KAGL,uBAAA;;;KAIA,YAAA,GACR,wBACA,wBACA,wBACA,mBACA,qBACA,sBACA,sBACA;iBAEY,+BAAA,YAA2C"}

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

@@ -0,0 +1,38 @@
+
+
+import { KeyManagementError } from "../error/KeyManagementError.mjs";
+import { getJwkHumanDescription } from "../jwk/humanDescription.mjs";
+import "../jwk/index.mjs";
+
+//#region src/modules/kms/options/KmsOperation.ts
+function getKmsOperationHumanDescription(operation) {
+	if (operation.operation === "deleteKey") return "'deleteKey' operation";
+	if (operation.operation === "createKey") {
+		let base = `'createKey' operation with kty '${operation.type.kty}'`;
+		if (operation.type.kty === "EC" || operation.type.kty === "OKP") base += ` and crv '${operation.type.crv}'`;
+		else if (operation.type.kty === "RSA") base += ` and bit length '${operation.type.modulusLength}'`;
+		else if (operation.type.kty === "oct") {
+			base += ` and algorithm '${operation.type.algorithm}'`;
+			if (operation.type.algorithm === "aes" || operation.type.algorithm === "hmac") base += ` with key length '${operation.type.length}'`;
+		}
+		return base;
+	}
+	if (operation.operation === "importKey") return `'importKey' operation with ${getJwkHumanDescription(operation.privateJwk)}`;
+	if (operation.operation === "sign" || operation.operation === "verify") return `'${operation.operation}' operation with algorithm '${operation.algorithm}'`;
+	if (operation.operation === "encrypt") {
+		let message = `'encrypt' operation with encryption algorithm '${operation.encryption.algorithm}'`;
+		if (operation.keyAgreement) message += `and key agreement algorithm '${operation.keyAgreement.algorithm}'`;
+		return message;
+	}
+	if (operation.operation === "decrypt") {
+		let message = `'decrypt' operation with encryption algorithm '${operation.decryption.algorithm}'`;
+		if (operation.keyAgreement) message += `and key agreement algorithm '${operation.keyAgreement.algorithm}'`;
+		return message;
+	}
+	if (operation.operation === "randomBytes") return `'randomBytes' operation`;
+	throw new KeyManagementError("Unsupported operation");
+}
+
+//#endregion
+export { getKmsOperationHumanDescription };
+//# sourceMappingURL=KmsOperation.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsOperation.mjs","names":[],"sources":["../../../../src/modules/kms/options/KmsOperation.ts"],"sourcesContent":["import { KeyManagementError } from '../error/KeyManagementError'\nimport { getJwkHumanDescription, type KmsJwkPrivate, type KnownJwaSignatureAlgorithm } from '../jwk'\nimport type { KmsCreateKeyType } from './KmsCreateKeyOptions'\nimport type { KmsDecryptDataDecryption } from './KmsDecryptOptions'\nimport type { KmsEncryptDataEncryption } from './KmsEncryptOptions'\nimport type { KmsKeyAgreementDecryptOptions } from './KmsKeyAgreementDecryptOptions'\nimport type { KmsKeyAgreementEncryptOptions } from './KmsKeyAgreementEncryptOptions'\n\nexport type KmsOperationCreateKey = {\n  operation: 'createKey'\n  type: KmsCreateKeyType\n}\n\nexport type KmsOperationImportKey = {\n  operation: 'importKey'\n  privateJwk: KmsJwkPrivate\n}\n\nexport type KmsOperationDeleteKey = {\n  operation: 'deleteKey'\n}\n\nexport type KmsOperationSign = {\n  operation: 'sign'\n  algorithm: KnownJwaSignatureAlgorithm\n}\n\nexport type KmsOperationVerify = {\n  operation: 'verify'\n  algorithm: KnownJwaSignatureAlgorithm\n}\n\nexport type KmsOperationEncrypt = {\n  operation: 'encrypt'\n  encryption: KmsEncryptDataEncryption\n  keyAgreement?: KmsKeyAgreementEncryptOptions\n}\n\nexport type KmsOperationDecrypt = {\n  operation: 'decrypt'\n  decryption: KmsDecryptDataDecryption\n  keyAgreement?: KmsKeyAgreementDecryptOptions\n}\n\nexport type KmsOperationRandomBytes = {\n  operation: 'randomBytes'\n}\n\nexport type KmsOperation =\n  | KmsOperationCreateKey\n  | KmsOperationImportKey\n  | KmsOperationDeleteKey\n  | KmsOperationSign\n  | KmsOperationVerify\n  | KmsOperationEncrypt\n  | KmsOperationDecrypt\n  | KmsOperationRandomBytes\n\nexport function getKmsOperationHumanDescription(operation: KmsOperation) {\n  if (operation.operation === 'deleteKey') {\n    return \"'deleteKey' operation\"\n  }\n\n  if (operation.operation === 'createKey') {\n    let base = `'createKey' operation with kty '${operation.type.kty}'`\n\n    if (operation.type.kty === 'EC' || operation.type.kty === 'OKP') {\n      base += ` and crv '${operation.type.crv}'`\n    } else if (operation.type.kty === 'RSA') {\n      base += ` and bit length '${operation.type.modulusLength}'`\n    } else if (operation.type.kty === 'oct') {\n      base += ` and algorithm '${operation.type.algorithm}'`\n\n      if (operation.type.algorithm === 'aes' || operation.type.algorithm === 'hmac') {\n        base += ` with key length '${operation.type.length}'`\n      }\n    }\n\n    return base\n  }\n\n  if (operation.operation === 'importKey') {\n    return `'importKey' operation with ${getJwkHumanDescription(operation.privateJwk)}`\n  }\n\n  if (operation.operation === 'sign' || operation.operation === 'verify') {\n    return `'${operation.operation}' operation with algorithm '${operation.algorithm}'`\n  }\n\n  if (operation.operation === 'encrypt') {\n    let message = `'encrypt' operation with encryption algorithm '${operation.encryption.algorithm}'`\n    if (operation.keyAgreement) {\n      message += `and key agreement algorithm '${operation.keyAgreement.algorithm}'`\n    }\n    return message\n  }\n\n  if (operation.operation === 'decrypt') {\n    let message = `'decrypt' operation with encryption algorithm '${operation.decryption.algorithm}'`\n    if (operation.keyAgreement) {\n      message += `and key agreement algorithm '${operation.keyAgreement.algorithm}'`\n    }\n    return message\n  }\n\n  if (operation.operation === 'randomBytes') {\n    return `'randomBytes' operation`\n  }\n\n  throw new KeyManagementError('Unsupported operation')\n}\n"],"mappings":";;;;;;;AA0DA,SAAgB,gCAAgC,WAAyB;AACvE,KAAI,UAAU,cAAc,YAC1B,QAAO;AAGT,KAAI,UAAU,cAAc,aAAa;EACvC,IAAI,OAAO,mCAAmC,UAAU,KAAK,IAAI;AAEjE,MAAI,UAAU,KAAK,QAAQ,QAAQ,UAAU,KAAK,QAAQ,MACxD,SAAQ,aAAa,UAAU,KAAK,IAAI;WAC/B,UAAU,KAAK,QAAQ,MAChC,SAAQ,oBAAoB,UAAU,KAAK,cAAc;WAChD,UAAU,KAAK,QAAQ,OAAO;AACvC,WAAQ,mBAAmB,UAAU,KAAK,UAAU;AAEpD,OAAI,UAAU,KAAK,cAAc,SAAS,UAAU,KAAK,cAAc,OACrE,SAAQ,qBAAqB,UAAU,KAAK,OAAO;;AAIvD,SAAO;;AAGT,KAAI,UAAU,cAAc,YAC1B,QAAO,8BAA8B,uBAAuB,UAAU,WAAW;AAGnF,KAAI,UAAU,cAAc,UAAU,UAAU,cAAc,SAC5D,QAAO,IAAI,UAAU,UAAU,8BAA8B,UAAU,UAAU;AAGnF,KAAI,UAAU,cAAc,WAAW;EACrC,IAAI,UAAU,kDAAkD,UAAU,WAAW,UAAU;AAC/F,MAAI,UAAU,aACZ,YAAW,gCAAgC,UAAU,aAAa,UAAU;AAE9E,SAAO;;AAGT,KAAI,UAAU,cAAc,WAAW;EACrC,IAAI,UAAU,kDAAkD,UAAU,WAAW,UAAU;AAC/F,MAAI,UAAU,aACZ,YAAW,gCAAgC,UAAU,aAAa,UAAU;AAE9E,SAAO;;AAGT,KAAI,UAAU,cAAc,cAC1B,QAAO;AAGT,OAAM,IAAI,mBAAmB,wBAAwB"}

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

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsRandomBytesOptions.d.ts
+declare const zKmsRandomBytesOptions: z.ZodObject<{
+  length: z.ZodNumber;
+}, z.core.$strip>;
+type KmsRandomBytesOptions = z.output<typeof zKmsRandomBytesOptions>;
+/**
+ * The generated random bytes
+ */
+type KmsRandomBytesReturn = Uint8Array;
+//#endregion
+export { KmsRandomBytesOptions, KmsRandomBytesReturn };
+//# sourceMappingURL=KmsRandomBytesOptions.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsRandomBytesOptions.d.mts","names":[],"sources":["../../../../src/modules/kms/options/KmsRandomBytesOptions.ts"],"sourcesContent":[],"mappings":";;;cAEa,wBAAsB,CAAA,CAAA;;;KAOvB,qBAAA,GAAwB,CAAA,CAAE,cAAc;AAPpD;;;AAAmC,KAYvB,oBAAA,GAAuB,UAZA"}

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

@@ -0,0 +1,10 @@
+
+
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsRandomBytesOptions.ts
+const zKmsRandomBytesOptions = z.object({ length: z.number().positive() });
+
+//#endregion
+export { zKmsRandomBytesOptions };
+//# sourceMappingURL=KmsRandomBytesOptions.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsRandomBytesOptions.mjs","names":[],"sources":["../../../../src/modules/kms/options/KmsRandomBytesOptions.ts"],"sourcesContent":["import { z } from 'zod'\n\nexport const zKmsRandomBytesOptions = z.object({\n  /**\n   * The number of random bytes to genreate\n   */\n  length: z.number().positive(),\n})\n\nexport type KmsRandomBytesOptions = z.output<typeof zKmsRandomBytesOptions>\n\n/**\n * The generated random bytes\n */\nexport type KmsRandomBytesReturn = Uint8Array\n"],"mappings":";;;;;AAEA,MAAa,yBAAyB,EAAE,OAAO,EAI7C,QAAQ,EAAE,QAAQ,CAAC,UAAU,EAC9B,CAAC"}

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

@@ -0,0 +1,33 @@
+import { AnyUint8Array, Uint8ArrayBuffer } from "../../../types.mjs";
+import "../../../index.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsSignOptions.d.ts
+declare const zKmsSignOptions: z.ZodObject<{
+  keyId: z.ZodString;
+  algorithm: z.ZodEnum<{
+    HS256: "HS256";
+    HS384: "HS384";
+    HS512: "HS512";
+    RS256: "RS256";
+    RS384: "RS384";
+    RS512: "RS512";
+    ES256: "ES256";
+    ES384: "ES384";
+    ES512: "ES512";
+    PS256: "PS256";
+    PS384: "PS384";
+    PS512: "PS512";
+    EdDSA: "EdDSA";
+    Ed25519: "Ed25519";
+    ES256K: "ES256K";
+  }>;
+  data: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>;
+type KmsSignOptions = z.output<typeof zKmsSignOptions>;
+interface KmsSignReturn {
+  signature: Uint8ArrayBuffer;
+}
+//#endregion
+export { KmsSignOptions, KmsSignReturn };
+//# sourceMappingURL=KmsSignOptions.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsSignOptions.d.mts","names":[],"sources":["../../../../src/modules/kms/options/KmsSignOptions.ts"],"sourcesContent":[],"mappings":";;;;;cAMa,iBAAe,CAAA,CAAA;;;;;IAAf,KAAA,EAAA,OAeX;;;;;;;IAf0B,KAAA,EAAA,OAAA;IAAA,KAAA,EAAA,OAAA;IAiBhB,KAAA,EAAA,OAAc;IACT,KAAA,EAAA,OAAa;;;;;;KADlB,cAAA,GAAiB,CAAA,CAAE,cAAc;UAC5B,aAAA;aACJ"}

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

@@ -0,0 +1,17 @@
+
+
+import { zKnownJwaSignatureAlgorithm } from "../jwk/jwa.mjs";
+import { zAnyUint8Array } from "../../../utils/zod.mjs";
+import { zKmsKeyId } from "./common.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsSignOptions.ts
+const zKmsSignOptions = z.object({
+	keyId: zKmsKeyId,
+	algorithm: zKnownJwaSignatureAlgorithm.describe("The JWA signature algorithm to use for signing"),
+	data: zAnyUint8Array.describe("The data to sign")
+});
+
+//#endregion
+export { zKmsSignOptions };
+//# sourceMappingURL=KmsSignOptions.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsSignOptions.mjs","names":[],"sources":["../../../../src/modules/kms/options/KmsSignOptions.ts"],"sourcesContent":["import { z } from 'zod'\nimport type { Uint8ArrayBuffer } from '../../../types'\nimport { zAnyUint8Array } from '../../../utils/zod'\nimport { zKnownJwaSignatureAlgorithm } from '../jwk/jwa'\nimport { zKmsKeyId } from './common'\n\nexport const zKmsSignOptions = z.object({\n  /**\n   * The key to use for signing\n   */\n  keyId: zKmsKeyId,\n\n  /**\n   * The JWA signature algorithm to use for signing\n   */\n  algorithm: zKnownJwaSignatureAlgorithm.describe('The JWA signature algorithm to use for signing'),\n\n  /**\n   * The data to sign\n   */\n  data: zAnyUint8Array.describe('The data to sign'),\n})\n\nexport type KmsSignOptions = z.output<typeof zKmsSignOptions>\nexport interface KmsSignReturn {\n  signature: Uint8ArrayBuffer\n}\n"],"mappings":";;;;;;;;AAMA,MAAa,kBAAkB,EAAE,OAAO;CAItC,OAAO;CAKP,WAAW,4BAA4B,SAAS,iDAAiD;CAKjG,MAAM,eAAe,SAAS,mBAAmB;CAClD,CAAC"}

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

@@ -0,0 +1,101 @@
+import { AnyUint8Array } from "../../../types.mjs";
+import { KmsJwkPublic } from "../jwk/knownJwk.mjs";
+import "../../../index.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/options/KmsVerifyOptions.d.ts
+declare const zKmsVerifyOptions: z.ZodObject<{
+  key: z.ZodUnion<readonly [z.ZodObject<{
+    keyId: z.ZodString;
+    publicJwk: z.ZodOptional<z.ZodNever>;
+  }, z.core.$strip>, z.ZodObject<{
+    publicJwk: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kty: z.ZodLiteral<"EC">;
+      crv: z.ZodEnum<{
+        "P-256": "P-256";
+        "P-384": "P-384";
+        "P-521": "P-521";
+        secp256k1: "secp256k1";
+      }>;
+      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>;
+    }, z.core.$strip>, z.ZodObject<{
+      kty: z.ZodLiteral<"RSA">;
+      n: z.ZodString;
+      e: z.ZodString;
+      d: z.ZodOptional<z.ZodUndefined>;
+      p: z.ZodOptional<z.ZodUndefined>;
+      q: z.ZodOptional<z.ZodUndefined>;
+      dp: z.ZodOptional<z.ZodUndefined>;
+      dq: z.ZodOptional<z.ZodUndefined>;
+      qi: z.ZodOptional<z.ZodUndefined>;
+      oth: 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>, 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>], "kty">;
+    keyId: z.ZodOptional<z.ZodNever>;
+  }, z.core.$strip>]>;
+  algorithm: z.ZodEnum<{
+    HS256: "HS256";
+    HS384: "HS384";
+    HS512: "HS512";
+    RS256: "RS256";
+    RS384: "RS384";
+    RS512: "RS512";
+    ES256: "ES256";
+    ES384: "ES384";
+    ES512: "ES512";
+    PS256: "PS256";
+    PS384: "PS384";
+    PS512: "PS512";
+    EdDSA: "EdDSA";
+    Ed25519: "Ed25519";
+    ES256K: "ES256K";
+  }>;
+  data: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+  signature: z.ZodCustom<AnyUint8Array, AnyUint8Array>;
+}, z.core.$strip>;
+type KmsVerifyOptions = z.output<typeof zKmsVerifyOptions>;
+type KmsVerifyReturn = {
+  verified: true;
+  publicJwk: KmsJwkPublic;
+} | {
+  verified: false;
+};
+//#endregion
+export { KmsVerifyOptions, KmsVerifyReturn };
+//# sourceMappingURL=KmsVerifyOptions.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KmsVerifyOptions.d.mts","names":[],"sources":["../../../../src/modules/kms/options/KmsVerifyOptions.ts"],"sourcesContent":[],"mappings":";;;;;;cAOa,mBAAiB,CAAA,CAAA;;;;;;MAAjB,GAAA,cAqCX,CAAA,IAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEU,gBAAA,GAAmB,CAAA,CAAE,cAAc;KAEnC,eAAA;;aAGK"}