@matter/protocol 0.15.0-alpha.0-20250617-f4d4cad23 → 0.15.0-alpha.0-20250620-16e218ed3

package/dist/esm/certificate/kinds/definitions/certification-declaration.d.ts

@@ -0,0 +1,18 @@
+/** Definitions for Matter Certification Declaration */
+export declare namespace CertificationDeclaration {
+    const TlvDc: import("#types").ObjectSchema<{
+        formatVersion: import("#types").FieldType<number>;
+        vendorId: import("#types").FieldType<import("#types").VendorId>;
+        produceIdArray: import("#types").FieldType<number[]>;
+        deviceTypeId: import("#types").FieldType<number>;
+        certificateId: import("#types").FieldType<string>;
+        securityLevel: import("#types").FieldType<number>;
+        securityInformation: import("#types").FieldType<number>;
+        versionNumber: import("#types").FieldType<number>;
+        certificationType: import("#types").FieldType<number>;
+        dacOriginVendorId: import("#types").OptionalFieldType<import("#types").VendorId>;
+        dacOriginProductId: import("#types").OptionalFieldType<number>;
+        authorizedPaaList: import("#types").OptionalFieldType<Uint8Array<ArrayBufferLike>[]>;
+    }>;
+}
+//# sourceMappingURL=certification-declaration.d.ts.map

package/dist/esm/certificate/kinds/definitions/certification-declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"certification-declaration.d.ts","sourceRoot":"","sources":["../../../../../src/certificate/kinds/definitions/certification-declaration.ts"],"names":[],"mappings":"AAkBA,uDAAuD;AACvD,yBAAiB,wBAAwB,CAAC;IAC/B,MAAM,KAAK;;;;;;;;;;;;;MAgBhB,CAAC;CACN"}

package/dist/esm/certificate/kinds/definitions/certification-declaration.js

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  TlvArray,
+  TlvByteString,
+  TlvField,
+  TlvObject,
+  TlvOptionalField,
+  TlvString,
+  TlvUInt16,
+  TlvUInt32,
+  TlvUInt8,
+  TlvVendorId
+} from "#types";
+var CertificationDeclaration;
+((CertificationDeclaration2) => {
+  CertificationDeclaration2.TlvDc = TlvObject({
+    formatVersion: TlvField(0, TlvUInt16),
+    vendorId: TlvField(1, TlvVendorId),
+    produceIdArray: TlvField(2, TlvArray(TlvUInt16, { minLength: 1, maxLength: 100 })),
+    deviceTypeId: TlvField(3, TlvUInt32),
+    certificateId: TlvField(4, TlvString.bound({ length: 19 })),
+    securityLevel: TlvField(5, TlvUInt8),
+    securityInformation: TlvField(6, TlvUInt16),
+    versionNumber: TlvField(7, TlvUInt16),
+    certificationType: TlvField(8, TlvUInt8),
+    dacOriginVendorId: TlvOptionalField(9, TlvVendorId),
+    dacOriginProductId: TlvOptionalField(10, TlvUInt16),
+    authorizedPaaList: TlvOptionalField(
+      11,
+      TlvArray(TlvByteString.bound({ length: 20 }), { minLength: 1, maxLength: 10 })
+    )
+  });
+})(CertificationDeclaration || (CertificationDeclaration = {}));
+export {
+  CertificationDeclaration
+};
+//# sourceMappingURL=certification-declaration.js.map

package/dist/esm/certificate/kinds/definitions/certification-declaration.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/certificate/kinds/definitions/certification-declaration.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAKA;AAAA,EACI;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACG;AAGA,IAAU;AAAA,CAAV,CAAUA,8BAAV;AACI,EAAMA,0BAAA,QAAQ,UAAU;AAAA,IAC3B,eAAe,SAAS,GAAG,SAAS;AAAA,IACpC,UAAU,SAAS,GAAG,WAAW;AAAA,IACjC,gBAAgB,SAAS,GAAG,SAAS,WAAW,EAAE,WAAW,GAAG,WAAW,IAAI,CAAC,CAAC;AAAA,IACjF,cAAc,SAAS,GAAG,SAAS;AAAA,IACnC,eAAe,SAAS,GAAG,UAAU,MAAM,EAAE,QAAQ,GAAG,CAAC,CAAC;AAAA,IAC1D,eAAe,SAAS,GAAG,QAAQ;AAAA,IACnC,qBAAqB,SAAS,GAAG,SAAS;AAAA,IAC1C,eAAe,SAAS,GAAG,SAAS;AAAA,IACpC,mBAAmB,SAAS,GAAG,QAAQ;AAAA,IACvC,mBAAmB,iBAAiB,GAAG,WAAW;AAAA,IAClD,oBAAoB,iBAAiB,IAAI,SAAS;AAAA,IAClD,mBAAmB;AAAA,MACf;AAAA,MACA,SAAS,cAAc,MAAM,EAAE,QAAQ,GAAG,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,GAAG,CAAC;AAAA,IACjF;AAAA,EACJ,CAAC;AAAA,GAjBY;",
+  "names": ["CertificationDeclaration"]
+}

package/dist/esm/certificate/kinds/definitions/operational.d.ts

@@ -0,0 +1,368 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TypeFromSchema } from "#types";
+/**
+ * Matter specific Certificate Sizes
+ * @see {@link MatterSpecification.v13.Core} 6.1.3.
+ */
+export declare const MAX_TLV_CERTIFICATE_SIZE = 400;
+export declare const TlvCertificateExtension: import("#types").ObjectSchema<{
+    basicConstraints: import("#types").FieldType<import("#types").TypeFromFields<{
+        isCa: import("#types").FieldType<boolean>;
+        pathLen: import("#types").OptionalFieldType<number>;
+    }>>;
+    keyUsage: import("#types").FieldType<import("#types").TypeFromPartialBitSchema<{
+        digitalSignature: import("#types").BitFlag;
+        nonRepudiation: import("#types").BitFlag;
+        keyEncipherment: import("#types").BitFlag;
+        dataEncipherment: import("#types").BitFlag;
+        keyAgreement: import("#types").BitFlag;
+        keyCertSign: import("#types").BitFlag;
+        cRLSign: import("#types").BitFlag;
+        encipherOnly: import("#types").BitFlag;
+        decipherOnly: import("#types").BitFlag;
+    }>>;
+    extendedKeyUsage: import("#types").OptionalFieldType<number[]>;
+    subjectKeyIdentifier: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+    authorityKeyIdentifier: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+    futureExtension: import("#types").OptionalRepeatedFieldType<Uint8Array<ArrayBufferLike>[]>;
+}>;
+export type CertificateExtension = TypeFromSchema<typeof TlvCertificateExtension>;
+/** Definitions for Matter Operational Certificates (RCAC, ICAC, NOC) */
+export declare namespace OperationalCertificate {
+    const TlvRcac: import("#types").ObjectSchemaWithMaxSize<{
+        serialNumber: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+        signatureAlgorithm: import("#types").FieldType<number>;
+        issuer: import("#types").FieldType<import("#types").TypeFromFields<{
+            commonName: import("#types").OptionalFieldType<string>;
+            sureName: import("#types").OptionalFieldType<string>;
+            serialNum: import("#types").OptionalFieldType<string>;
+            countryName: import("#types").OptionalFieldType<string>;
+            localityName: import("#types").OptionalFieldType<string>;
+            stateOrProvinceName: import("#types").OptionalFieldType<string>;
+            orgName: import("#types").OptionalFieldType<string>;
+            orgUnitName: import("#types").OptionalFieldType<string>;
+            title: import("#types").OptionalFieldType<string>;
+            name: import("#types").OptionalFieldType<string>;
+            givenName: import("#types").OptionalFieldType<string>;
+            initials: import("#types").OptionalFieldType<string>;
+            genQualifier: import("#types").OptionalFieldType<string>;
+            dnQualifier: import("#types").OptionalFieldType<string>;
+            pseudonym: import("#types").OptionalFieldType<string>;
+            domainComponent: import("#types").OptionalFieldType<string>;
+        } & {
+            nodeId: import("#types").OptionalFieldType<import("#types").NodeId>;
+            firmwareSigningId: import("#types").OptionalFieldType<number>;
+            icacId: import("#types").OptionalFieldType<number | bigint>;
+            rcacId: import("#types").OptionalFieldType<number | bigint>;
+            fabricId: import("#types").OptionalFieldType<import("#types").FabricId>;
+            caseAuthenticatedTags: import("#types").OptionalRepeatedFieldType<import("#types").CaseAuthenticatedTag[]>;
+        } & {
+            commonNamePs: import("#types").OptionalFieldType<string>;
+            sureNamePs: import("#types").OptionalFieldType<string>;
+            serialNumPs: import("#types").OptionalFieldType<string>;
+            countryNamePs: import("#types").OptionalFieldType<string>;
+            localityNamePs: import("#types").OptionalFieldType<string>;
+            stateOrProvinceNamePs: import("#types").OptionalFieldType<string>;
+            orgNamePs: import("#types").OptionalFieldType<string>;
+            orgUnitNamePs: import("#types").OptionalFieldType<string>;
+            titlePs: import("#types").OptionalFieldType<string>;
+            namePs: import("#types").OptionalFieldType<string>;
+            givenNamePs: import("#types").OptionalFieldType<string>;
+            initialsPs: import("#types").OptionalFieldType<string>;
+            genQualifierPs: import("#types").OptionalFieldType<string>;
+            dnQualifierPs: import("#types").OptionalFieldType<string>;
+            pseudonymPs: import("#types").OptionalFieldType<string>;
+        }>>;
+        notBefore: import("#types").FieldType<number>;
+        notAfter: import("#types").FieldType<number>;
+        subject: import("#types").FieldType<import("#types").TypeFromFields<{
+            commonName: import("#types").OptionalFieldType<string>;
+            sureName: import("#types").OptionalFieldType<string>;
+            serialNum: import("#types").OptionalFieldType<string>;
+            countryName: import("#types").OptionalFieldType<string>;
+            localityName: import("#types").OptionalFieldType<string>;
+            stateOrProvinceName: import("#types").OptionalFieldType<string>;
+            orgName: import("#types").OptionalFieldType<string>;
+            orgUnitName: import("#types").OptionalFieldType<string>;
+            title: import("#types").OptionalFieldType<string>;
+            name: import("#types").OptionalFieldType<string>;
+            givenName: import("#types").OptionalFieldType<string>;
+            initials: import("#types").OptionalFieldType<string>;
+            genQualifier: import("#types").OptionalFieldType<string>;
+            dnQualifier: import("#types").OptionalFieldType<string>;
+            pseudonym: import("#types").OptionalFieldType<string>;
+            domainComponent: import("#types").OptionalFieldType<string>;
+        } & {
+            rcacId: import("#types").FieldType<number | bigint>;
+            fabricId: import("#types").OptionalFieldType<import("#types").FabricId>;
+        } & {
+            commonNamePs: import("#types").OptionalFieldType<string>;
+            sureNamePs: import("#types").OptionalFieldType<string>;
+            serialNumPs: import("#types").OptionalFieldType<string>;
+            countryNamePs: import("#types").OptionalFieldType<string>;
+            localityNamePs: import("#types").OptionalFieldType<string>;
+            stateOrProvinceNamePs: import("#types").OptionalFieldType<string>;
+            orgNamePs: import("#types").OptionalFieldType<string>;
+            orgUnitNamePs: import("#types").OptionalFieldType<string>;
+            titlePs: import("#types").OptionalFieldType<string>;
+            namePs: import("#types").OptionalFieldType<string>;
+            givenNamePs: import("#types").OptionalFieldType<string>;
+            initialsPs: import("#types").OptionalFieldType<string>;
+            genQualifierPs: import("#types").OptionalFieldType<string>;
+            dnQualifierPs: import("#types").OptionalFieldType<string>;
+            pseudonymPs: import("#types").OptionalFieldType<string>;
+        }>>;
+        publicKeyAlgorithm: import("#types").FieldType<number>;
+        ellipticCurveIdentifier: import("#types").FieldType<number>;
+        ellipticCurvePublicKey: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+        extensions: import("#types").FieldType<import("#types").TypeFromFields<{
+            basicConstraints: import("#types").FieldType<import("#types").TypeFromFields<{
+                isCa: import("#types").FieldType<boolean>;
+                pathLen: import("#types").OptionalFieldType<number>;
+            }>>;
+            keyUsage: import("#types").FieldType<import("#types").TypeFromPartialBitSchema<{
+                digitalSignature: import("#types").BitFlag;
+                nonRepudiation: import("#types").BitFlag;
+                keyEncipherment: import("#types").BitFlag;
+                dataEncipherment: import("#types").BitFlag;
+                keyAgreement: import("#types").BitFlag;
+                keyCertSign: import("#types").BitFlag;
+                cRLSign: import("#types").BitFlag;
+                encipherOnly: import("#types").BitFlag;
+                decipherOnly: import("#types").BitFlag;
+            }>>;
+            extendedKeyUsage: import("#types").OptionalFieldType<number[]>;
+            subjectKeyIdentifier: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+            authorityKeyIdentifier: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+            futureExtension: import("#types").OptionalRepeatedFieldType<Uint8Array<ArrayBufferLike>[]>;
+        }>>;
+        signature: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+    }>;
+    const TlvNoc: import("#types").ObjectSchemaWithMaxSize<{
+        serialNumber: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+        signatureAlgorithm: import("#types").FieldType<number>;
+        issuer: import("#types").FieldType<import("#types").TypeFromFields<{
+            commonName: import("#types").OptionalFieldType<string>;
+            sureName: import("#types").OptionalFieldType<string>;
+            serialNum: import("#types").OptionalFieldType<string>;
+            countryName: import("#types").OptionalFieldType<string>;
+            localityName: import("#types").OptionalFieldType<string>;
+            stateOrProvinceName: import("#types").OptionalFieldType<string>;
+            orgName: import("#types").OptionalFieldType<string>;
+            orgUnitName: import("#types").OptionalFieldType<string>;
+            title: import("#types").OptionalFieldType<string>;
+            name: import("#types").OptionalFieldType<string>;
+            givenName: import("#types").OptionalFieldType<string>;
+            initials: import("#types").OptionalFieldType<string>;
+            genQualifier: import("#types").OptionalFieldType<string>;
+            dnQualifier: import("#types").OptionalFieldType<string>;
+            pseudonym: import("#types").OptionalFieldType<string>;
+            domainComponent: import("#types").OptionalFieldType<string>;
+        } & {
+            nodeId: import("#types").OptionalFieldType<import("#types").NodeId>;
+            firmwareSigningId: import("#types").OptionalFieldType<number>;
+            icacId: import("#types").OptionalFieldType<number | bigint>;
+            rcacId: import("#types").OptionalFieldType<number | bigint>;
+            fabricId: import("#types").OptionalFieldType<import("#types").FabricId>;
+            caseAuthenticatedTags: import("#types").OptionalRepeatedFieldType<import("#types").CaseAuthenticatedTag[]>;
+        } & {
+            commonNamePs: import("#types").OptionalFieldType<string>;
+            sureNamePs: import("#types").OptionalFieldType<string>;
+            serialNumPs: import("#types").OptionalFieldType<string>;
+            countryNamePs: import("#types").OptionalFieldType<string>;
+            localityNamePs: import("#types").OptionalFieldType<string>;
+            stateOrProvinceNamePs: import("#types").OptionalFieldType<string>;
+            orgNamePs: import("#types").OptionalFieldType<string>;
+            orgUnitNamePs: import("#types").OptionalFieldType<string>;
+            titlePs: import("#types").OptionalFieldType<string>;
+            namePs: import("#types").OptionalFieldType<string>;
+            givenNamePs: import("#types").OptionalFieldType<string>;
+            initialsPs: import("#types").OptionalFieldType<string>;
+            genQualifierPs: import("#types").OptionalFieldType<string>;
+            dnQualifierPs: import("#types").OptionalFieldType<string>;
+            pseudonymPs: import("#types").OptionalFieldType<string>;
+        }>>;
+        notBefore: import("#types").FieldType<number>;
+        notAfter: import("#types").FieldType<number>;
+        subject: import("#types").FieldType<import("#types").TypeFromFields<{
+            commonName: import("#types").OptionalFieldType<string>;
+            sureName: import("#types").OptionalFieldType<string>;
+            serialNum: import("#types").OptionalFieldType<string>;
+            countryName: import("#types").OptionalFieldType<string>;
+            localityName: import("#types").OptionalFieldType<string>;
+            stateOrProvinceName: import("#types").OptionalFieldType<string>;
+            orgName: import("#types").OptionalFieldType<string>;
+            orgUnitName: import("#types").OptionalFieldType<string>;
+            title: import("#types").OptionalFieldType<string>;
+            name: import("#types").OptionalFieldType<string>;
+            givenName: import("#types").OptionalFieldType<string>;
+            initials: import("#types").OptionalFieldType<string>;
+            genQualifier: import("#types").OptionalFieldType<string>;
+            dnQualifier: import("#types").OptionalFieldType<string>;
+            pseudonym: import("#types").OptionalFieldType<string>;
+            domainComponent: import("#types").OptionalFieldType<string>;
+        } & {
+            nodeId: import("#types").FieldType<import("#types").NodeId>;
+            fabricId: import("#types").FieldType<import("#types").FabricId>;
+            caseAuthenticatedTags: import("#types").OptionalRepeatedFieldType<import("#types").CaseAuthenticatedTag[]>;
+        } & {
+            commonNamePs: import("#types").OptionalFieldType<string>;
+            sureNamePs: import("#types").OptionalFieldType<string>;
+            serialNumPs: import("#types").OptionalFieldType<string>;
+            countryNamePs: import("#types").OptionalFieldType<string>;
+            localityNamePs: import("#types").OptionalFieldType<string>;
+            stateOrProvinceNamePs: import("#types").OptionalFieldType<string>;
+            orgNamePs: import("#types").OptionalFieldType<string>;
+            orgUnitNamePs: import("#types").OptionalFieldType<string>;
+            titlePs: import("#types").OptionalFieldType<string>;
+            namePs: import("#types").OptionalFieldType<string>;
+            givenNamePs: import("#types").OptionalFieldType<string>;
+            initialsPs: import("#types").OptionalFieldType<string>;
+            genQualifierPs: import("#types").OptionalFieldType<string>;
+            dnQualifierPs: import("#types").OptionalFieldType<string>;
+            pseudonymPs: import("#types").OptionalFieldType<string>;
+        }>>;
+        publicKeyAlgorithm: import("#types").FieldType<number>;
+        ellipticCurveIdentifier: import("#types").FieldType<number>;
+        ellipticCurvePublicKey: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+        extensions: import("#types").FieldType<import("#types").TypeFromFields<{
+            basicConstraints: import("#types").FieldType<import("#types").TypeFromFields<{
+                isCa: import("#types").FieldType<boolean>;
+                pathLen: import("#types").OptionalFieldType<number>;
+            }>>;
+            keyUsage: import("#types").FieldType<import("#types").TypeFromPartialBitSchema<{
+                digitalSignature: import("#types").BitFlag;
+                nonRepudiation: import("#types").BitFlag;
+                keyEncipherment: import("#types").BitFlag;
+                dataEncipherment: import("#types").BitFlag;
+                keyAgreement: import("#types").BitFlag;
+                keyCertSign: import("#types").BitFlag;
+                cRLSign: import("#types").BitFlag;
+                encipherOnly: import("#types").BitFlag;
+                decipherOnly: import("#types").BitFlag;
+            }>>;
+            extendedKeyUsage: import("#types").OptionalFieldType<number[]>;
+            subjectKeyIdentifier: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+            authorityKeyIdentifier: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+            futureExtension: import("#types").OptionalRepeatedFieldType<Uint8Array<ArrayBufferLike>[]>;
+        }>>;
+        signature: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+    }>;
+    const TlvIcac: import("#types").ObjectSchemaWithMaxSize<{
+        serialNumber: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+        signatureAlgorithm: import("#types").FieldType<number>;
+        issuer: import("#types").FieldType<import("#types").TypeFromFields<{
+            commonName: import("#types").OptionalFieldType<string>;
+            sureName: import("#types").OptionalFieldType<string>;
+            serialNum: import("#types").OptionalFieldType<string>;
+            countryName: import("#types").OptionalFieldType<string>;
+            localityName: import("#types").OptionalFieldType<string>;
+            stateOrProvinceName: import("#types").OptionalFieldType<string>;
+            orgName: import("#types").OptionalFieldType<string>;
+            orgUnitName: import("#types").OptionalFieldType<string>;
+            title: import("#types").OptionalFieldType<string>;
+            name: import("#types").OptionalFieldType<string>;
+            givenName: import("#types").OptionalFieldType<string>;
+            initials: import("#types").OptionalFieldType<string>;
+            genQualifier: import("#types").OptionalFieldType<string>;
+            dnQualifier: import("#types").OptionalFieldType<string>;
+            pseudonym: import("#types").OptionalFieldType<string>;
+            domainComponent: import("#types").OptionalFieldType<string>;
+        } & {
+            nodeId: import("#types").OptionalFieldType<import("#types").NodeId>;
+            firmwareSigningId: import("#types").OptionalFieldType<number>;
+            icacId: import("#types").OptionalFieldType<number | bigint>;
+            rcacId: import("#types").OptionalFieldType<number | bigint>;
+            fabricId: import("#types").OptionalFieldType<import("#types").FabricId>;
+            caseAuthenticatedTags: import("#types").OptionalRepeatedFieldType<import("#types").CaseAuthenticatedTag[]>;
+        } & {
+            commonNamePs: import("#types").OptionalFieldType<string>;
+            sureNamePs: import("#types").OptionalFieldType<string>;
+            serialNumPs: import("#types").OptionalFieldType<string>;
+            countryNamePs: import("#types").OptionalFieldType<string>;
+            localityNamePs: import("#types").OptionalFieldType<string>;
+            stateOrProvinceNamePs: import("#types").OptionalFieldType<string>;
+            orgNamePs: import("#types").OptionalFieldType<string>;
+            orgUnitNamePs: import("#types").OptionalFieldType<string>;
+            titlePs: import("#types").OptionalFieldType<string>;
+            namePs: import("#types").OptionalFieldType<string>;
+            givenNamePs: import("#types").OptionalFieldType<string>;
+            initialsPs: import("#types").OptionalFieldType<string>;
+            genQualifierPs: import("#types").OptionalFieldType<string>;
+            dnQualifierPs: import("#types").OptionalFieldType<string>;
+            pseudonymPs: import("#types").OptionalFieldType<string>;
+        }>>;
+        notBefore: import("#types").FieldType<number>;
+        notAfter: import("#types").FieldType<number>;
+        subject: import("#types").FieldType<import("#types").TypeFromFields<{
+            commonName: import("#types").OptionalFieldType<string>;
+            sureName: import("#types").OptionalFieldType<string>;
+            serialNum: import("#types").OptionalFieldType<string>;
+            countryName: import("#types").OptionalFieldType<string>;
+            localityName: import("#types").OptionalFieldType<string>;
+            stateOrProvinceName: import("#types").OptionalFieldType<string>;
+            orgName: import("#types").OptionalFieldType<string>;
+            orgUnitName: import("#types").OptionalFieldType<string>;
+            title: import("#types").OptionalFieldType<string>;
+            name: import("#types").OptionalFieldType<string>;
+            givenName: import("#types").OptionalFieldType<string>;
+            initials: import("#types").OptionalFieldType<string>;
+            genQualifier: import("#types").OptionalFieldType<string>;
+            dnQualifier: import("#types").OptionalFieldType<string>;
+            pseudonym: import("#types").OptionalFieldType<string>;
+            domainComponent: import("#types").OptionalFieldType<string>;
+        } & {
+            icacId: import("#types").FieldType<number | bigint>;
+            fabricId: import("#types").OptionalFieldType<import("#types").FabricId>;
+        } & {
+            commonNamePs: import("#types").OptionalFieldType<string>;
+            sureNamePs: import("#types").OptionalFieldType<string>;
+            serialNumPs: import("#types").OptionalFieldType<string>;
+            countryNamePs: import("#types").OptionalFieldType<string>;
+            localityNamePs: import("#types").OptionalFieldType<string>;
+            stateOrProvinceNamePs: import("#types").OptionalFieldType<string>;
+            orgNamePs: import("#types").OptionalFieldType<string>;
+            orgUnitNamePs: import("#types").OptionalFieldType<string>;
+            titlePs: import("#types").OptionalFieldType<string>;
+            namePs: import("#types").OptionalFieldType<string>;
+            givenNamePs: import("#types").OptionalFieldType<string>;
+            initialsPs: import("#types").OptionalFieldType<string>;
+            genQualifierPs: import("#types").OptionalFieldType<string>;
+            dnQualifierPs: import("#types").OptionalFieldType<string>;
+            pseudonymPs: import("#types").OptionalFieldType<string>;
+        }>>;
+        publicKeyAlgorithm: import("#types").FieldType<number>;
+        ellipticCurveIdentifier: import("#types").FieldType<number>;
+        ellipticCurvePublicKey: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+        extensions: import("#types").FieldType<import("#types").TypeFromFields<{
+            basicConstraints: import("#types").FieldType<import("#types").TypeFromFields<{
+                isCa: import("#types").FieldType<boolean>;
+                pathLen: import("#types").OptionalFieldType<number>;
+            }>>;
+            keyUsage: import("#types").FieldType<import("#types").TypeFromPartialBitSchema<{
+                digitalSignature: import("#types").BitFlag;
+                nonRepudiation: import("#types").BitFlag;
+                keyEncipherment: import("#types").BitFlag;
+                dataEncipherment: import("#types").BitFlag;
+                keyAgreement: import("#types").BitFlag;
+                keyCertSign: import("#types").BitFlag;
+                cRLSign: import("#types").BitFlag;
+                encipherOnly: import("#types").BitFlag;
+                decipherOnly: import("#types").BitFlag;
+            }>>;
+            extendedKeyUsage: import("#types").OptionalFieldType<number[]>;
+            subjectKeyIdentifier: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+            authorityKeyIdentifier: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+            futureExtension: import("#types").OptionalRepeatedFieldType<Uint8Array<ArrayBufferLike>[]>;
+        }>>;
+        signature: import("#types").FieldType<Uint8Array<ArrayBufferLike>>;
+    }>;
+    type Rcac = TypeFromSchema<typeof TlvRcac>;
+    type Icac = TypeFromSchema<typeof TlvIcac>;
+    type Noc = TypeFromSchema<typeof TlvNoc>;
+}
+//# sourceMappingURL=operational.d.ts.map

package/dist/esm/certificate/kinds/definitions/operational.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operational.d.ts","sourceRoot":"","sources":["../../../../../src/certificate/kinds/definitions/operational.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAmBH,cAAc,EACjB,MAAM,QAAQ,CAAC;AAGhB;;;GAGG;AACH,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAE5C,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;EAalC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAElF,wEAAwE;AACxE,yBAAiB,sBAAsB,CAAC;IAkG7B,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAMlB,CAAC;IAEI,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAOjB,CAAC;IAEI,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAMlB,CAAC;IAEH,KAAY,IAAI,GAAG,cAAc,CAAC,OAAO,OAAO,CAAC,CAAC;IAClD,KAAY,IAAI,GAAG,cAAc,CAAC,OAAO,OAAO,CAAC,CAAC;IAClD,KAAY,GAAG,GAAG,cAAc,CAAC,OAAO,MAAM,CAAC,CAAC;CACnD"}

package/dist/esm/certificate/kinds/definitions/operational.js

@@ -0,0 +1,148 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  TlvArray,
+  TlvBitmap,
+  TlvBoolean,
+  TlvByteString,
+  TlvCaseAuthenticatedTag,
+  TlvFabricId,
+  TlvField,
+  TlvNodeId,
+  TlvObject,
+  TlvObjectWithMaxSize,
+  TlvOptionalField,
+  TlvOptionalRepeatedField,
+  TlvString,
+  TlvTaggedList,
+  TlvUInt16,
+  TlvUInt32,
+  TlvUInt64,
+  TlvUInt8
+} from "#types";
+import { ExtensionKeyUsageBitmap } from "./base.js";
+const MAX_TLV_CERTIFICATE_SIZE = 400;
+const TlvCertificateExtension = TlvTaggedList({
+  basicConstraints: TlvField(
+    1,
+    TlvObject({
+      isCa: TlvField(1, TlvBoolean),
+      pathLen: TlvOptionalField(2, TlvUInt8)
+    })
+  ),
+  keyUsage: TlvField(2, TlvBitmap(TlvUInt16, ExtensionKeyUsageBitmap)),
+  extendedKeyUsage: TlvOptionalField(3, TlvArray(TlvUInt8)),
+  subjectKeyIdentifier: TlvField(4, TlvByteString.bound({ length: 20 })),
+  authorityKeyIdentifier: TlvField(5, TlvByteString.bound({ length: 20 })),
+  futureExtension: TlvOptionalRepeatedField(6, TlvByteString)
+});
+var OperationalCertificate;
+((OperationalCertificate2) => {
+  const AllowedSubjectAndIssuerMatterFields = {
+    nodeId: TlvOptionalField(17, TlvNodeId),
+    firmwareSigningId: TlvOptionalField(18, TlvUInt32),
+    icacId: TlvOptionalField(19, TlvUInt64),
+    rcacId: TlvOptionalField(20, TlvUInt64),
+    fabricId: TlvOptionalField(21, TlvFabricId),
+    caseAuthenticatedTags: TlvOptionalRepeatedField(22, TlvCaseAuthenticatedTag, { maxLength: 3 })
+  };
+  const TlvGenericMatterSubjectOrIssuerTaggedList = (matterFields) => {
+    const fields = {
+      // Standard DNs
+      commonName: TlvOptionalField(1, TlvString),
+      sureName: TlvOptionalField(2, TlvString),
+      serialNum: TlvOptionalField(3, TlvString),
+      countryName: TlvOptionalField(4, TlvString),
+      localityName: TlvOptionalField(5, TlvString),
+      stateOrProvinceName: TlvOptionalField(6, TlvString),
+      orgName: TlvOptionalField(7, TlvString),
+      orgUnitName: TlvOptionalField(8, TlvString),
+      title: TlvOptionalField(9, TlvString),
+      name: TlvOptionalField(10, TlvString),
+      givenName: TlvOptionalField(11, TlvString),
+      initials: TlvOptionalField(12, TlvString),
+      genQualifier: TlvOptionalField(13, TlvString),
+      dnQualifier: TlvOptionalField(14, TlvString),
+      pseudonym: TlvOptionalField(15, TlvString),
+      domainComponent: TlvOptionalField(16, TlvString),
+      // Matter specific DNs
+      ...matterFields,
+      // Standard DNs when encoded as Printable String
+      commonNamePs: TlvOptionalField(129, TlvString),
+      sureNamePs: TlvOptionalField(130, TlvString),
+      serialNumPs: TlvOptionalField(131, TlvString),
+      countryNamePs: TlvOptionalField(132, TlvString),
+      localityNamePs: TlvOptionalField(133, TlvString),
+      stateOrProvinceNamePs: TlvOptionalField(134, TlvString),
+      orgNamePs: TlvOptionalField(135, TlvString),
+      orgUnitNamePs: TlvOptionalField(136, TlvString),
+      titlePs: TlvOptionalField(137, TlvString),
+      namePs: TlvOptionalField(138, TlvString),
+      givenNamePs: TlvOptionalField(139, TlvString),
+      initialsPs: TlvOptionalField(140, TlvString),
+      genQualifierPs: TlvOptionalField(141, TlvString),
+      dnQualifierPs: TlvOptionalField(142, TlvString),
+      pseudonymPs: TlvOptionalField(143, TlvString)
+    };
+    return TlvTaggedList(fields);
+  };
+  const BaseMatterCertificate = (matterFields) => TlvObjectWithMaxSize(
+    {
+      serialNumber: TlvField(1, TlvByteString.bound({ maxLength: 20 })),
+      signatureAlgorithm: TlvField(2, TlvUInt8),
+      issuer: TlvField(
+        3,
+        TlvGenericMatterSubjectOrIssuerTaggedList({
+          ...AllowedSubjectAndIssuerMatterFields,
+          ...matterFields?.issuer ?? {}
+        })
+      ),
+      notBefore: TlvField(4, TlvUInt32),
+      notAfter: TlvField(5, TlvUInt32),
+      subject: TlvField(
+        6,
+        TlvGenericMatterSubjectOrIssuerTaggedList({
+          ...AllowedSubjectAndIssuerMatterFields,
+          ...matterFields?.subject ?? {}
+        })
+      ),
+      publicKeyAlgorithm: TlvField(7, TlvUInt8),
+      ellipticCurveIdentifier: TlvField(8, TlvUInt8),
+      ellipticCurvePublicKey: TlvField(9, TlvByteString),
+      extensions: TlvField(10, TlvCertificateExtension),
+      signature: TlvField(11, TlvByteString)
+    },
+    MAX_TLV_CERTIFICATE_SIZE
+  );
+  OperationalCertificate2.TlvRcac = BaseMatterCertificate({
+    subject: {
+      rcacId: TlvField(20, TlvUInt64),
+      fabricId: TlvOptionalField(21, TlvFabricId)
+    },
+    issuer: AllowedSubjectAndIssuerMatterFields
+  });
+  OperationalCertificate2.TlvNoc = BaseMatterCertificate({
+    subject: {
+      nodeId: TlvField(17, TlvNodeId),
+      fabricId: TlvField(21, TlvFabricId),
+      caseAuthenticatedTags: TlvOptionalRepeatedField(22, TlvCaseAuthenticatedTag, { maxLength: 3 })
+    },
+    issuer: AllowedSubjectAndIssuerMatterFields
+  });
+  OperationalCertificate2.TlvIcac = BaseMatterCertificate({
+    subject: {
+      icacId: TlvField(19, TlvUInt64),
+      fabricId: TlvOptionalField(21, TlvFabricId)
+    },
+    issuer: AllowedSubjectAndIssuerMatterFields
+  });
+})(OperationalCertificate || (OperationalCertificate = {}));
+export {
+  MAX_TLV_CERTIFICATE_SIZE,
+  OperationalCertificate,
+  TlvCertificateExtension
+};
+//# sourceMappingURL=operational.js.map

package/dist/esm/certificate/kinds/definitions/operational.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/certificate/kinds/definitions/operational.ts"],
+  "mappings": "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",
+  "names": ["OperationalCertificate"]
+}

package/dist/esm/certificate/kinds/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./AttestationCertificates.js";
+export * from "./CertificationDeclaration.js";
+export * from "./Icac.js";
+export * from "./Noc.js";
+export * from "./Rcac.js";
+export * from "./X509Base.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/certificate/kinds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/certificate/kinds/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC"}

package/dist/esm/certificate/kinds/index.js

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./AttestationCertificates.js";
+export * from "./CertificationDeclaration.js";
+export * from "./Icac.js";
+export * from "./Noc.js";
+export * from "./Rcac.js";
+export * from "./X509Base.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/certificate/kinds/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/certificate/kinds/index.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;",
+  "names": []
+}