@owf/cose 0.1.0 → 0.2.0-alpha-20260508112151

package/dist/index.d.mts

@@ -0,0 +1,620 @@
+import { Options, addExtension } from "cbor-x";
+import z$1, { ZodError, z } from "zod";
+//#region src/cbor/cbor-structure.d.ts
+type CborEncodeOptions = {
+  asDataItem?: boolean;
+};
+type AnyCborStructure = CborStructure<any, any>;
+type EncodedStructureType<T> = T extends CborStructure<infer EncodedStructure, unknown> ? EncodedStructure : any;
+type DecodedStructureType<T> = T extends CborStructure<unknown, infer DecodedStructure> ? DecodedStructure : any;
+type CborStructureStaticThis<T extends AnyCborStructure> = {
+  new (structure: any): T;
+  encodingSchema: z.ZodType<any, any, any> | undefined;
+  fromEncodedStructure: (encodedStructure: EncodedStructureType<T>) => {
+    decodedStructure: DecodedStructureType<T>;
+  };
+};
+declare class CborStructure<EncodedStructure = unknown, DecodedStructure = EncodedStructure> {
+  protected structure: DecodedStructure;
+  protected _tag: number | undefined;
+  constructor(structure: DecodedStructure);
+  get decodedStructure(): DecodedStructure;
+  /**
+   * Static getter for the Zod codec schema that defines the CBOR structure.
+   * Subclasses CAN override this to provide their specific schema for automatic encoding/decoding.
+   * The schema should be a Zod schema or codec that handles validation and transformation.
+   * If not provided, subclasses must override encode(), decode(), and fromEncodedStructure().
+   */
+  static get encodingSchema(): z.ZodType | undefined;
+  /**
+   * Returns the encoded structure that will be serialized to CBOR.
+   * By default, returns the protected structure property.
+   * Override if custom encoding logic is needed.
+   */
+  get encodedStructure(): EncodedStructure;
+  /**
+   * Encodes this structure to CBOR bytes.
+   */
+  encode(options?: CborEncodeOptions): Uint8Array;
+  /**
+   * Decodes CBOR bytes into a structure instance.
+   * Uses the encodingSchema's decode() method to validate and transform the decoded data.
+   */
+  static decode<T extends AnyCborStructure>(this: CborStructureStaticThis<T>, bytes: Uint8Array): T;
+  /**
+   * Creates a structure instance from the encoded CBOR structure (after calling cborDecode).
+   *
+   * Uses the encodingSchema's decode() method to validate and transform the structure if available.
+   * Otherwise, subclasses must override this method.
+   */
+  static fromEncodedStructure<T extends AnyCborStructure>(this: CborStructureStaticThis<T>, encodedStructure: EncodedStructureType<T>): T;
+  static fromDataItem<T extends AnyCborStructure>(this: CborStructureStaticThis<T>, dataItem: unknown): T;
+  /**
+   * Creates a structure instance from the decoded structure.
+   *
+   * Uses the encodingSchema's parse method to validate the structure if available.
+   * Otherwise, subclasses must override this method.
+   */
+  static fromDecodedStructure<T extends AnyCborStructure>(this: CborStructureStaticThis<T>, decodedStructure: DecodedStructureType<T>): T;
+}
+//#endregion
+//#region src/cbor/data-item.d.ts
+declare const zDataItemCodec: (outputSchema: z$1.ZodType) => z$1.ZodCodec<z$1.ZodCustom<DataItem<unknown>, DataItem<unknown>>, z$1.ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>>;
+type DataItemOptions<T = unknown> = {
+  data: T;
+  buffer: Uint8Array;
+} | {
+  data: T;
+} | {
+  buffer: Uint8Array;
+};
+/**
+ * DataItem is an extension defined https://www.rfc-editor.org/rfc/rfc8949.html#name-encoded-cbor-data-item
+ *  > Sometimes it is beneficial to carry an embedded CBOR data item that is
+ *  > not meant to be decoded immediately at the time the enclosing data item is being decoded.
+ *
+ * The idea of this class is to provide lazy encode and decode of cbor data.
+ *
+ * Due to a bug in the cbor-x library, we are eagerly encoding the data in the constructor.
+ * https://github.com/kriszyp/cbor-x/issues/83
+ *
+ */
+declare class DataItem<T = unknown> {
+  #private;
+  constructor(options: DataItemOptions<T>);
+  get data(): T;
+  get buffer(): Uint8Array;
+  static fromData<T>(data: T): DataItem<T>;
+  static fromBuffer<T>(buffer: Uint8Array): DataItem<T>;
+}
+//#endregion
+//#region src/cbor/models/date-only.d.ts
+declare const customInspectSymbol: unique symbol;
+declare class DateOnly {
+  private date;
+  constructor(date?: string);
+  get [Symbol.toStringTag](): string;
+  toString(): string;
+  toJSON(): string;
+  toISOString(): string;
+  [customInspectSymbol](): string;
+}
+//#endregion
+//#region src/cbor/parser.d.ts
+type CborOptions = Options & {
+  unwrapTopLevelDataItem?: boolean;
+};
+declare const cborDecode: <T>(input: Uint8Array, options?: CborOptions) => T;
+declare const cborEncode: (obj: unknown, options?: Options) => Uint8Array;
+//#endregion
+//#region src/cose/claims/default.d.ts
+/**
+ *
+ * Registered CWT claim keys
+ * @see https://www.rfc-editor.org/rfc/rfc8392#section-3.1
+ *
+ */
+declare enum RegisteredCwtClaimKey {
+  Issuer = 1,
+  Subject = 2,
+  Audience = 3,
+  ExpirationTime = 4,
+  NotBefore = 5,
+  IssuedAt = 6,
+  CwtId = 7
+}
+//#endregion
+//#region src/cose/headers/defaults.d.ts
+/**
+ *
+ * Registered CWT header keys
+ *
+ */
+declare enum RegisteredCwtHeaderClaimKey {
+  Algorithm = 1,
+  Critical = 2,
+  ContentType = 3,
+  KeyId = 4,
+  Iv = 5,
+  PartialIv = 6,
+  CounterSignature = 7,
+  CounterSignature0 = 9,
+  CounterSignatureV2 = 11,
+  CounterSignature0V2 = 12,
+  X5Bag = 32,
+  X5Chain = 33,
+  X5T = 34,
+  X5U = 35
+}
+declare enum SignatureAlgorithm {
+  EdDSA = -8,
+  ES256 = -7,
+  ES384 = -35,
+  ES512 = -36,
+  PS256 = -37,
+  PS384 = -38,
+  PS512 = -39,
+  RS256 = -257,
+  RS384 = -258,
+  RS512 = -259
+}
+declare enum MacAlgorithm {
+  HS256 = 5,
+  HS384 = 6,
+  HS512 = 7
+}
+declare enum EncryptionAlgorithm {
+  A128GCM = 1,
+  A192GCM = 2,
+  A256GCM = 3,
+  Direct = -6
+}
+type DigestAlgorithm = 'SHA-256' | 'SHA-384' | 'SHA-512';
+//#endregion
+//#region src/cose/headers/protected-headers.d.ts
+declare const protectedHeadersEncodedStructure: z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+declare const protectedHeadersDecodedStructure: z$1.ZodMap<z$1.ZodNumber, z$1.ZodUnknown>;
+type ProtectedHeadersDecodedStructure = z$1.infer<typeof protectedHeadersDecodedStructure>;
+type ProtectedHeadersEncodedStructure = z$1.infer<typeof protectedHeadersEncodedStructure>;
+type ProtectedHeaderOptions = {
+  protectedHeaders?: ProtectedHeadersDecodedStructure;
+};
+declare class ProtectedHeaders extends CborStructure<ProtectedHeadersEncodedStructure, ProtectedHeadersDecodedStructure> {
+  static get encodingSchema(): z$1.ZodCodec<z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, z$1.ZodMap<z$1.ZodNumber, z$1.ZodUnknown>>;
+  get headers(): Map<number, unknown>;
+  static create(options: ProtectedHeaderOptions): ProtectedHeaders;
+}
+//#endregion
+//#region src/cose/headers/unprotected-headers.d.ts
+declare const unprotectedHeadersStructure: z$1.ZodMap<z$1.ZodNumber, z$1.ZodUnknown>;
+type UnprotectedHeadersStructure = z$1.infer<typeof unprotectedHeadersStructure>;
+type UnprotectedHeaderOptions = {
+  unprotectedHeaders?: UnprotectedHeadersStructure;
+};
+declare class UnprotectedHeaders extends CborStructure<UnprotectedHeadersStructure> {
+  static get encodingSchema(): z$1.ZodMap<z$1.ZodNumber, z$1.ZodUnknown>;
+  get headers(): Map<number, unknown>;
+  static create(options: UnprotectedHeaderOptions): UnprotectedHeaders;
+}
+//#endregion
+//#region src/cose/mac0.d.ts
+declare const mac0EncodedSchema: z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodNullable<z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>], null>;
+declare const mac0DecodedSchema: z.ZodObject<{
+  protectedHeaders: z.ZodCustom<ProtectedHeaders, ProtectedHeaders>;
+  unprotectedHeaders: z.ZodCustom<UnprotectedHeaders, UnprotectedHeaders>;
+  payload: z.ZodNullable<z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+  tag: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+}, z.core.$strip>;
+type Mac0EncodedStructure = z.infer<typeof mac0EncodedSchema>;
+type Mac0DecodedStructure = z.infer<typeof mac0DecodedSchema>;
+type Mac0Context = {
+  mac: (options: {
+    toBeAuthenticated: Uint8Array;
+    key: Uint8Array;
+  }) => Promise<Uint8Array>;
+};
+type Mac0Options = {
+  protectedHeaders?: ProtectedHeaders | ProtectedHeaderOptions['protectedHeaders'];
+  unprotectedHeaders?: UnprotectedHeaders | UnprotectedHeaderOptions['unprotectedHeaders'];
+  externalAad?: Uint8Array;
+  payload?: Uint8Array | null;
+  detachedPayload?: Uint8Array;
+};
+declare class Mac0 extends CborStructure<Mac0EncodedStructure, Mac0DecodedStructure> {
+  static tag: number;
+  protected _tag: number;
+  static get encodingSchema(): z.ZodCodec<z.ZodTuple<[z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodNullable<z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>], null>, z.ZodObject<{
+    protectedHeaders: z.ZodCustom<ProtectedHeaders, ProtectedHeaders>;
+    unprotectedHeaders: z.ZodCustom<UnprotectedHeaders, UnprotectedHeaders>;
+    payload: z.ZodNullable<z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+    tag: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+  }, z.core.$strip>>;
+  externalAad?: Uint8Array;
+  detachedPayload?: Uint8Array;
+  get protectedHeaders(): ProtectedHeaders;
+  get unprotectedHeaders(): UnprotectedHeaders;
+  get payload(): Uint8Array<ArrayBufferLike> | null;
+  get tag(): Uint8Array<ArrayBufferLike>;
+  get toBeAuthenticated(): Uint8Array<ArrayBufferLike>;
+  /**
+   * Decodes CBOR bytes into a Sign1 instance.
+   * Uses the encodingSchema's decode() method to validate and transform the decoded data.
+   */
+  static decode<T extends AnyCborStructure>(this: CborStructureStaticThis<T>, bytes: Uint8Array): T;
+  static toBeAuthenticated(options: {
+    payload: Uint8Array;
+    protectedHeaders: ProtectedHeaders;
+    externalAad?: Uint8Array;
+  }): Uint8Array<ArrayBufferLike>;
+  get signatureAlgorithmName(): MacAlgorithm;
+  static create(options: Mac0Options): Mac0;
+  authenticate(options: {
+    key: Uint8Array;
+  }, ctx: Pick<Mac0Context, 'mac'>): Promise<this>;
+}
+//#endregion
+//#region src/cose/key/curve.d.ts
+declare enum Curve {
+  'P-256' = 1,
+  'P-384' = 2,
+  'P-521' = 3,
+  X25519 = 4,
+  X448 = 5,
+  Ed25519 = 6,
+  Ed448 = 7
+}
+//#endregion
+//#region src/utils/typed-map.d.ts
+/**
+ * TypedMap provides compile-time type safety for Maps where each key has its own specific value type.
+ * Unlike Map<K, V> which has the same value type V for all keys, TypedMap<Schema, OptionalKeys>
+ * allows different value types per key (heterogeneous values).
+ *
+ * Example:
+ *   type CoseKeySchema = {
+ *     [CoseKeyParameter.KeyType]: KeyType     // number key → KeyType value
+ *     [CoseKeyParameter.Curve]: Curve         // number key → Curve value
+ *     [CoseKeyParameter.X]: Uint8Array        // number key → Uint8Array value
+ *   }
+ *
+ *   const map = new TypedMap<CoseKeySchema>()
+ *   map.get(CoseKeyParameter.KeyType)  // TypeScript knows this is KeyType!
+ *   map.get(CoseKeyParameter.Curve)    // TypeScript knows this is Curve!
+ *   map.get(CoseKeyParameter.X)        // TypeScript knows this is Uint8Array!
+ *
+ * @template Schema - Object type mapping keys to their value types
+ * @template OptionalKeys - Union of keys that are optional (can be absent)
+ */
+declare class TypedMap<Schema extends Record<PropertyKey, any>, OptionalKeys extends keyof Schema = never> {
+  private readonly map;
+  constructor(entries?: (readonly [keyof Schema, Schema[keyof Schema]])[] | null);
+  static fromMap<Schema extends Record<PropertyKey, any>, OptionalKeys extends keyof Schema = never>(map: Map<any, any>): TypedMap<Schema, OptionalKeys>;
+  static fromObject<Schema extends Record<PropertyKey, any>, OptionalKeys extends keyof Schema = never>(object: Record<string | number, any>): TypedMap<Schema, OptionalKeys>;
+  /**
+   * Type-safe get that returns the correct value type for each key.
+   * Required keys return T, optional keys return T | undefined.
+   */
+  get<K extends keyof Schema>(key: K): K extends OptionalKeys ? Schema[K] | undefined : Schema[K];
+  /**
+   * Type-safe set that ensures the value matches the key's type
+   */
+  set<K extends keyof Schema>(key: K, value: Schema[K]): this;
+  has(key: keyof Schema): boolean;
+  delete(key: keyof Schema): boolean;
+  clear(): void;
+  get size(): number;
+  keys(): IterableIterator<keyof Schema>;
+  values(): IterableIterator<Schema[keyof Schema]>;
+  entries(): IterableIterator<[keyof Schema, Schema[keyof Schema]]>;
+  forEach(callbackfn: (value: Schema[keyof Schema], key: keyof Schema, map: Map<keyof Schema, Schema[keyof Schema]>) => void, thisArg?: any): void;
+  [Symbol.iterator](): IterableIterator<[keyof Schema, Schema[keyof Schema]]>;
+  toMap(): Map<keyof Schema, Schema[keyof Schema]>;
+}
+type EntriesArrayToSchema<T extends ReadonlyArray<readonly [any, any]>> = { [K in T[number][0]]: Extract<T[number], readonly [K, any]>[1] };
+type EntriesBase = ReadonlyArray<readonly [string | number, z.ZodType<any>]>;
+type InferredEntries<Entries extends EntriesBase> = { [K in keyof Entries]: readonly [Entries[K][0], z.infer<Entries[K][1]>] };
+type InferredSchema<Entries extends EntriesBase> = EntriesArrayToSchema<InferredEntries<Entries>>;
+type OptionalKeys<Entries extends EntriesBase> = Entries[number] extends infer E ? E extends readonly [infer K, infer V] ? V extends z.ZodExactOptional<any> ? K : never : never : never;
+/**
+ * Utility function to create a typed map codec.
+ * Takes an array of [key, valueSchema] entries to support any key type (including non-string keys for CBOR).
+ *
+ * Example:
+ *   const coseKeyMap = typedMap([
+ *     [CoseKeyParameter.KeyType, z.number()],
+ *     [CoseKeyParameter.Curve, z.number()],
+ *     [CoseKeyParameter.X, z.instanceof(Uint8Array)]
+ *   ] as const)
+ *
+ * The resulting schema validates a Map and transforms it to TypedMap<Schema, never>.
+ */
+declare function typedMap<const Entries extends EntriesBase>(entries: Entries, {
+  allowAdditionalKeys,
+  encode,
+  decode
+}?: {
+  /**
+   * Whether to allow additional keys in the typed map
+   *
+   * @default true
+   */
+  allowAdditionalKeys?: boolean;
+  /**
+   * Allows overriding the encode function. The original encode method is passed as second
+   * argument, so you can use this method to pre/post process
+   */
+  encode?: (decoded: TypedMap<InferredSchema<Entries>, OptionalKeys<Entries>>, originalEncode: (decoded: TypedMap<InferredSchema<Entries>, OptionalKeys<Entries>>) => Map<unknown, unknown>) => Map<unknown, unknown>;
+  /**
+   * Allows overriding the decode function. The original decode method is passed as second
+   * argument, so you can use this method to pre/post process
+   */
+  decode?: (encoded: Map<unknown, unknown>, originalDecode: (decoded: Map<unknown, unknown>) => TypedMap<InferredSchema<Entries>, OptionalKeys<Entries>>) => TypedMap<InferredSchema<Entries>, OptionalKeys<Entries>>;
+}): z.ZodCodec<z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodCustom<TypedMap<InferredSchema<Entries>, OptionalKeys<Entries>>, TypedMap<InferredSchema<Entries>, OptionalKeys<Entries>>>>;
+//#endregion
+//#region src/cose/key/key-operation.d.ts
+declare enum KeyOps {
+  Sign = 1,
+  Verify = 2,
+  Encrypt = 3,
+  Decrypt = 4,
+  WrapKey = 5,
+  UnwrapKey = 6,
+  DeriveKey = 7,
+  DeriveBits = 8,
+  MACCreate = 9,
+  MACVerify = 10
+}
+//#endregion
+//#region src/cose/key/key-type.d.ts
+declare enum KeyType {
+  Okp = 1,
+  Ec = 2,
+  Oct = 4,
+  Reserved = 0
+}
+//#endregion
+//#region src/cose/key/key.d.ts
+declare enum CoseKeyParameter {
+  KeyType = 1,
+  KeyId = 2,
+  Algorithm = 3,
+  KeyOps = 4,
+  BaseIv = 5,
+  CurveOrK = -1,
+  X = -2,
+  Y = -3,
+  D = -4
+}
+declare const coseKeySchema: z.ZodCodec<z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodCustom<TypedMap<{
+  1: string | KeyType;
+  2: string | Uint8Array<ArrayBufferLike>;
+  3: string | number;
+  4: (string | KeyOps)[];
+  5: Uint8Array<ArrayBufferLike>;
+  [-1]: Uint8Array<ArrayBufferLike> | Curve;
+  [-2]: Uint8Array<ArrayBufferLike>;
+  [-3]: Uint8Array<ArrayBufferLike>;
+  [-4]: Uint8Array<ArrayBufferLike>;
+}, CoseKeyParameter.KeyId | CoseKeyParameter.Algorithm | CoseKeyParameter.KeyOps | CoseKeyParameter.BaseIv | CoseKeyParameter.CurveOrK | CoseKeyParameter.X | CoseKeyParameter.Y | CoseKeyParameter.D>, TypedMap<{
+  1: string | KeyType;
+  2: string | Uint8Array<ArrayBufferLike>;
+  3: string | number;
+  4: (string | KeyOps)[];
+  5: Uint8Array<ArrayBufferLike>;
+  [-1]: Uint8Array<ArrayBufferLike> | Curve;
+  [-2]: Uint8Array<ArrayBufferLike>;
+  [-3]: Uint8Array<ArrayBufferLike>;
+  [-4]: Uint8Array<ArrayBufferLike>;
+}, CoseKeyParameter.KeyId | CoseKeyParameter.Algorithm | CoseKeyParameter.KeyOps | CoseKeyParameter.BaseIv | CoseKeyParameter.CurveOrK | CoseKeyParameter.X | CoseKeyParameter.Y | CoseKeyParameter.D>>>;
+type CoseKeyDecodedStructure = z.output<typeof coseKeySchema>;
+type CoseKeyEncodedStructure = z.input<typeof coseKeySchema>;
+type CoseKeyOptions = {
+  keyType: KeyType | string;
+  keyId?: string;
+  algorithm?: string | number;
+  keyOps?: Array<KeyOps | string>;
+  baseIv?: Uint8Array;
+  curve?: Curve;
+  x?: Uint8Array;
+  y?: Uint8Array;
+  d?: Uint8Array;
+  k?: Uint8Array;
+};
+declare class CoseKey extends CborStructure<CoseKeyEncodedStructure, CoseKeyDecodedStructure> {
+  static get encodingSchema(): z.ZodCodec<z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodCustom<TypedMap<{
+    1: string | KeyType;
+    2: string | Uint8Array<ArrayBufferLike>;
+    3: string | number;
+    4: (string | KeyOps)[];
+    5: Uint8Array<ArrayBufferLike>;
+    [-1]: Uint8Array<ArrayBufferLike> | Curve;
+    [-2]: Uint8Array<ArrayBufferLike>;
+    [-3]: Uint8Array<ArrayBufferLike>;
+    [-4]: Uint8Array<ArrayBufferLike>;
+  }, CoseKeyParameter.KeyId | CoseKeyParameter.Algorithm | CoseKeyParameter.KeyOps | CoseKeyParameter.BaseIv | CoseKeyParameter.CurveOrK | CoseKeyParameter.X | CoseKeyParameter.Y | CoseKeyParameter.D>, TypedMap<{
+    1: string | KeyType;
+    2: string | Uint8Array<ArrayBufferLike>;
+    3: string | number;
+    4: (string | KeyOps)[];
+    5: Uint8Array<ArrayBufferLike>;
+    [-1]: Uint8Array<ArrayBufferLike> | Curve;
+    [-2]: Uint8Array<ArrayBufferLike>;
+    [-3]: Uint8Array<ArrayBufferLike>;
+    [-4]: Uint8Array<ArrayBufferLike>;
+  }, CoseKeyParameter.KeyId | CoseKeyParameter.Algorithm | CoseKeyParameter.KeyOps | CoseKeyParameter.BaseIv | CoseKeyParameter.CurveOrK | CoseKeyParameter.X | CoseKeyParameter.Y | CoseKeyParameter.D>>>;
+  get keyType(): string | KeyType;
+  get keyId(): string | undefined;
+  get algorithm(): SignatureAlgorithm | undefined;
+  get keyOps(): (string | KeyOps)[] | undefined;
+  get baseIv(): Uint8Array<ArrayBufferLike> | undefined;
+  get curve(): Curve | undefined;
+  get x(): Uint8Array<ArrayBufferLike> | undefined;
+  get y(): Uint8Array<ArrayBufferLike> | undefined;
+  get d(): Uint8Array<ArrayBufferLike> | undefined;
+  get k(): Uint8Array<ArrayBufferLike> | undefined;
+  static create(options: CoseKeyOptions): CoseKey;
+  static fromJwk(jwk: Record<string, unknown>): CoseKey;
+  get publicKey(): Uint8Array<ArrayBuffer>;
+  get privateKey(): Uint8Array<ArrayBufferLike>;
+  get jwk(): Record<string, unknown>;
+}
+//#endregion
+//#region src/cose/key/jwk.d.ts
+declare const jwkCoseOptionsMap: Record<string, keyof CoseKeyOptions>;
+declare const coseOptionsJwkMap: {
+  [k: string]: string;
+};
+declare const jwkToCoseKey: {
+  kty: (kty?: unknown) => KeyType;
+  crv: (crv?: unknown) => Curve;
+  alg: (alg?: unknown) => SignatureAlgorithm | MacAlgorithm | EncryptionAlgorithm;
+  kid: (kid?: unknown) => unknown;
+  keyOps: (keyOps?: unknown) => KeyOps[] | undefined;
+  x: (s?: unknown) => Uint8Array<ArrayBufferLike> | undefined;
+  y: (s?: unknown) => Uint8Array<ArrayBufferLike> | undefined;
+  d: (s?: unknown) => Uint8Array<ArrayBufferLike> | undefined;
+};
+declare const coseKeyToJwk: {
+  keyType: (keyType: KeyType) => any;
+  keyId: (keyId: unknown) => unknown;
+  algorithm: (algorithm?: SignatureAlgorithm | MacAlgorithm) => any;
+  keyOps: (keyOps?: unknown) => any[] | undefined;
+  baseIv: (baseIv?: unknown) => unknown;
+  curve: (curve?: Curve) => any;
+  x: (x?: Uint8Array) => string | undefined;
+  y: (y?: Uint8Array) => string | undefined;
+  d: (d?: Uint8Array) => string | undefined;
+};
+//#endregion
+//#region src/cose/sign1.d.ts
+declare const sign1EncodedSchema: z$1.ZodTuple<[z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, z$1.ZodMap<z$1.ZodNumber, z$1.ZodUnknown>, z$1.ZodNullable<z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>], null>;
+declare const sign1DecodedSchema: z$1.ZodObject<{
+  protectedHeaders: z$1.ZodCustom<ProtectedHeaders, ProtectedHeaders>;
+  unprotectedHeaders: z$1.ZodCustom<UnprotectedHeaders, UnprotectedHeaders>;
+  payload: z$1.ZodNullable<z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+  signature: z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+}, z$1.core.$strip>;
+type Sign1EncodedStructure = z$1.infer<typeof sign1EncodedSchema>;
+type Sign1DecodedStructure = z$1.infer<typeof sign1DecodedSchema>;
+type Sign1Context = {
+  sign: (options: {
+    toBeSigned: Uint8Array;
+    key: CoseKey;
+    algorithm: SignatureAlgorithm;
+  }) => Promise<Uint8Array>;
+  getPublicKey: (options: {
+    certificate: Uint8Array | Uint8Array[];
+    alg: string;
+  }) => Promise<Uint8Array>;
+  verify: (options: {
+    sign1: Sign1;
+    key: Uint8Array | CoseKey;
+  }) => Promise<boolean>;
+  x509: {
+    getIssuerNameField: (options: {
+      certificate: Uint8Array | Uint8Array[];
+      field: string;
+    }) => string[];
+    getPublicKey: (options: {
+      certificate: Uint8Array | Uint8Array[];
+      alg: string;
+    }) => Promise<Uint8Array>;
+  };
+};
+type Sign1Options = {
+  protectedHeaders?: ProtectedHeaders | ProtectedHeaderOptions['protectedHeaders'];
+  unprotectedHeaders?: UnprotectedHeaders | UnprotectedHeaderOptions['unprotectedHeaders'];
+  externalAad?: Uint8Array;
+  payload?: Uint8Array | null;
+  detachedPayload?: Uint8Array;
+};
+declare class Sign1 extends CborStructure<Sign1EncodedStructure, Sign1DecodedStructure> {
+  static tag: number;
+  protected _tag: number;
+  static get encodingSchema(): z$1.ZodCodec<z$1.ZodTuple<[z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, z$1.ZodMap<z$1.ZodNumber, z$1.ZodUnknown>, z$1.ZodNullable<z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>], null>, z$1.ZodObject<{
+    protectedHeaders: z$1.ZodCustom<ProtectedHeaders, ProtectedHeaders>;
+    unprotectedHeaders: z$1.ZodCustom<UnprotectedHeaders, UnprotectedHeaders>;
+    payload: z$1.ZodNullable<z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+    signature: z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+  }, z$1.core.$strip>>;
+  detachedPayload?: Uint8Array;
+  externalAad?: Uint8Array;
+  get protectedHeaders(): ProtectedHeaders;
+  get unprotectedHeaders(): UnprotectedHeaders;
+  get payload(): Uint8Array<ArrayBufferLike> | null;
+  get signature(): Uint8Array<ArrayBufferLike>;
+  get certificateChain(): Uint8Array<ArrayBufferLike>[];
+  get certificate(): Uint8Array<ArrayBufferLike>;
+  getIssuingCountry(ctx: Pick<Sign1Context, 'x509'>): string;
+  getIssuingStateOrProvince(ctx: Pick<Sign1Context, 'x509'>): string;
+  get toBeSigned(): Uint8Array<ArrayBufferLike>;
+  /**
+   * Decodes CBOR bytes into a Sign1 instance.
+   * Uses the encodingSchema's decode() method to validate and transform the decoded data.
+   */
+  static decode<T extends AnyCborStructure>(this: CborStructureStaticThis<T>, bytes: Uint8Array): T;
+  static toBeSigned(options: {
+    payload: Uint8Array;
+    protectedHeaders: ProtectedHeaders;
+    externalAad?: Uint8Array;
+  }): Uint8Array<ArrayBufferLike>;
+  get signatureAlgorithmName(): string;
+  get x5chain(): Uint8Array<ArrayBufferLike>[] | undefined;
+  verifySignature(options: {
+    key?: CoseKey;
+  }, ctx: Pick<Sign1Context, 'getPublicKey' | 'verify'>): Promise<boolean>;
+  static create(options: Sign1Options): Sign1;
+  sign(options: {
+    externalAad?: Uint8Array;
+    signingKey: CoseKey;
+    algorithm?: SignatureAlgorithm;
+    detachedPayload?: Uint8Array;
+  }, ctx: Pick<Sign1Context, 'sign'>): Promise<this>;
+}
+//#endregion
+//#region src/cose/cwt.d.ts
+type CwtOptions = Sign1Options | Mac0Options;
+declare class Cwt {
+  private options;
+  constructor(options: CwtOptions);
+  static create(options: CwtOptions): Cwt;
+  static fromToken(token: Uint8Array): Cwt;
+  get asSign1(): Sign1;
+  get asMac0(): Mac0;
+  get payload(): Uint8Array<ArrayBufferLike>;
+  get protectedHeaders(): Map<number, unknown> | ProtectedHeaders | undefined;
+  get unprotectedHeaders(): Map<number, unknown> | UnprotectedHeaders | undefined;
+}
+//#endregion
+//#region src/cose/error.d.ts
+declare class CoseError extends Error {
+  constructor(message?: string);
+}
+declare class CoseUnsupportedMacError extends CoseError {}
+declare class CoseInvalidSignatureError extends CoseError {}
+declare class CoseInvalidAlgorithmError extends CoseError {}
+declare class CosePayloadMustBeNullError extends CoseError {}
+declare class CosePayloadMustBeDefinedError extends CoseError {}
+declare class CosePayloadInvalidStructureError extends CoseError {}
+declare class CoseInvalidTypeForKeyError extends CoseError {}
+declare class CoseInvalidValueForKtyError extends CoseError {}
+declare class CoseInvalidKtyForRawError extends CoseError {}
+declare class CoseXNotDefinedError extends CoseError {}
+declare class CoseYNotDefinedError extends CoseError {}
+declare class CoseDNotDefinedError extends CoseError {}
+declare class CoseKNotDefinedError extends CoseError {}
+declare class CoseEphemeralMacKeyIsRequiredError extends CoseError {}
+declare class CoseCertificateNotFoundError extends CoseError {}
+declare class CoseKeyTypeNotSupportedForPrivateKeyExtractionError extends CoseError {}
+//#endregion
+//#region src/utils/zod.d.ts
+declare const zUint8Array: z$1.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+//#endregion
+//#region src/utils/zod-error.d.ts
+declare class ValidationError extends Error {
+  zodError: ZodError | undefined;
+  constructor(message: string, zodError?: ZodError);
+}
+//#endregion
+export { AnyCborStructure, CborEncodeOptions, CborOptions, CborStructure, CborStructureStaticThis, CoseCertificateNotFoundError, CoseDNotDefinedError, CoseEphemeralMacKeyIsRequiredError, CoseInvalidAlgorithmError, CoseInvalidKtyForRawError, CoseInvalidSignatureError, CoseInvalidTypeForKeyError, CoseInvalidValueForKtyError, CoseKNotDefinedError, CoseKey, CoseKeyDecodedStructure, CoseKeyEncodedStructure, CoseKeyOptions, CoseKeyParameter, CoseKeyTypeNotSupportedForPrivateKeyExtractionError, CosePayloadInvalidStructureError, CosePayloadMustBeDefinedError, CosePayloadMustBeNullError, CoseUnsupportedMacError, CoseXNotDefinedError, CoseYNotDefinedError, Curve, Cwt, CwtOptions, DataItem, DataItemOptions, DateOnly, DecodedStructureType, DigestAlgorithm, EncodedStructureType, EncryptionAlgorithm, KeyOps, KeyType, Mac0, Mac0Context, Mac0DecodedStructure, Mac0EncodedStructure, Mac0Options, MacAlgorithm, ProtectedHeaderOptions, ProtectedHeaders, ProtectedHeadersDecodedStructure, ProtectedHeadersEncodedStructure, RegisteredCwtClaimKey, RegisteredCwtHeaderClaimKey, Sign1, Sign1Context, Sign1DecodedStructure, Sign1EncodedStructure, Sign1Options, SignatureAlgorithm, TypedMap, UnprotectedHeaderOptions, UnprotectedHeaders, UnprotectedHeadersStructure, ValidationError, addExtension, cborDecode, cborEncode, coseKeyToJwk, coseOptionsJwkMap, jwkCoseOptionsMap, jwkToCoseKey, mac0DecodedSchema, mac0EncodedSchema, protectedHeadersDecodedStructure, protectedHeadersEncodedStructure, sign1DecodedSchema, sign1EncodedSchema, typedMap, unprotectedHeadersStructure, zDataItemCodec, zUint8Array };
+//# sourceMappingURL=index.d.mts.map