@matter/protocol 0.11.0-alpha.0-20241005-e3e4e4a7a

package/src/certificate/CertificationDeclarationManager.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes, PrivateKey } from "#general";
+import { VendorId } from "#types";
+import { CertificateManager, TlvCertificationDeclaration } from "./CertificateManager.js";
+
+// This is the private key from Appendix F of the Matter 1.1 Core Specification.
+// The specification specifies it in PEM format:
+//
+// -----BEGIN EC PRIVATE KEY-----
+// MHcCAQEEIK7zSEEW6UgexXvgRy30G/SZBk5QJK2GnspeiJgC1IB1oAoGCCqGSM49
+// AwEHoUQDQgAEPDmJIkUrVcrzicJb0bykZWlSzLkOiGkkmthHRlMBTL+V1oeWXgNr
+// UhxRA35rjO3vyh60QEZpT6CIgu7WUZ3sug==
+// -----END EC PRIVATE KEY-----
+//
+// You can extract the key using openssl:
+//
+// openssl asn1parse -in key.txt
+const TestCMS_SignerPrivateKey = Bytes.fromHex("AEF3484116E9481EC57BE0472DF41BF499064E5024AD869ECA5E889802D48075");
+
+// You can extract the subject key identifier from the certificate in the same
+// section.  The x509 command is best for that:
+//
+// openssl x509 -in cert.txt -text
+//
+// Look for the line under "X509v3 Subject Key Identifier:"
+const TestCMS_SignerSubjectKeyIdentifier = Bytes.fromHex("62FA823359ACFAA9963E1CFA140ADDF504F37160");
+
+export class CertificationDeclarationManager {
+    static generate(vendorId: VendorId, productId: number, provisional = false) {
+        const certificationElements = TlvCertificationDeclaration.encode({
+            formatVersion: 1,
+            vendorId,
+            produceIdArray: [productId],
+            deviceTypeId: 22,
+            certificateId: "CSA00000SWC00000-00",
+            securityLevel: 0,
+            securityInformation: 0,
+            versionNumber: 1,
+            certificationType: provisional ? 1 : 0, // 0 = Test, 1 = Provisional/In certification, 2 = official
+        });
+
+        return CertificateManager.certificationDeclarationToAsn1(
+            certificationElements,
+            TestCMS_SignerSubjectKeyIdentifier,
+            PrivateKey(TestCMS_SignerPrivateKey),
+        );
+    }
+}

package/src/certificate/ChipPAAuthorities.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Bytes } from "#general";
+
+// from CHIPAttCert_test_vectors.h ...
+
+// PAA without Vendor ID
+
+export const TestCert_PAA_NoVID_PublicKey = Bytes.fromHex(
+    "0410ef02a81a87b68121fba8d31978f807a317e50aa8a828446828914b933de8edd4a5c39c9ff71a4ce3647fd7f62653b7d2495fcba4c0f47f876880039e07204a",
+);
+export const TestCert_PAA_NoVID_PrivateKey = Bytes.fromHex(
+    "e1f073c934853baffb38bf7e8bdad7a0a674107c7769892a0ff2e06c1a2ef7a7",
+);
+export const TestCert_PAA_NoVID_SKID = Bytes.fromHex("785CE705B86B8F4E6FC793AA60CB43EA696882D5");
+export const TestCert_PAA_NoVID_Cert = Bytes.fromHex(
+    "3082019130820137a00302010202070b8fbaa8dd86ee300a06082a8648ce3d040302301a3118301606035504030c0f4d61747465722054657374205041413020170d3231303632383134323334335a180f39393939313233313233353935395a301a3118301606035504030c0f4d61747465722054657374205041413059301306072a8648ce3d020106082a8648ce3d0301070342000410ef02a81a87b68121fba8d31978f807a317e50aa8a828446828914b933de8edd4a5c39c9ff71a4ce3647fd7f62653b7d2495fcba4c0f47f876880039e07204aa366306430120603551d130101ff040830060101ff020101300e0603551d0f0101ff040403020106301d0603551d0e04160414785ce705b86b8f4e6fc793aa60cb43ea696882d5301f0603551d23041830168014785ce705b86b8f4e6fc793aa60cb43ea696882d5300a06082a8648ce3d0403020348003045022100b9efdb3ea06a52ec0bf01e61daed2c2d156ddb6cf014101dab798fac05fa47e5022060061d3e35d60d9d4b0d448dad7612f7e85c582e3fc312dc18794dd373715e5d",
+);
+
+// PAA with Vendor ID 0xFFF1
+
+export const TestCert_PAA_FFF1_PrivateKey = Bytes.fromHex(
+    "6512caecaecfc543d60623161597162f014684c565a129b62fd28c27ab1ccc50",
+);
+export const TestCert_PAA_FFF1_PublicKey = Bytes.fromHex(
+    "04b6cb6372887f2928f5bac81aa9d93ae2431cada9d79e242f65177ef9ced932a28ecd03baaf6a8fca184a1a503542960d453f303f1f19421d751e8f8f1a9a9b75",
+);
+export const TestCert_PAA_FFF1_SKID = Bytes.fromHex("6AFD22771F511FECBF1641976710DCDC31A1717E");
+export const TestCert_PAA_FFF1_Cert = Bytes.fromHex(
+    "308201bd30820164a00302010202084ea8e83182d41c1c300a06082a8648ce3d04030230303118301606035504030c0f4d617474657220546573742050414131143012060a2b0601040182a27c02010c04464646313020170d3231303632383134323334335a180f39393939313233313233353935395a30303118301606035504030c0f4d617474657220546573742050414131143012060a2b0601040182a27c02010c04464646313059301306072a8648ce3d020106082a8648ce3d03010703420004b6cb6372887f2928f5bac81aa9d93ae2431cada9d79e242f65177ef9ced932a28ecd03baaf6a8fca184a1a503542960d453f303f1f19421d751e8f8f1a9a9b75a366306430120603551d130101ff040830060101ff020101300e0603551d0f0101ff040403020106301d0603551d0e041604146afd22771f511fecbf1641976710dcdc31a1717e301f0603551d230418301680146afd22771f511fecbf1641976710dcdc31a1717e300a06082a8648ce3d0403020347003044022050aa8002f4d932a9a00538f65368ad0fffc8efbbc9beb7da569835cf9aa7510e022023bac8fe0f23e75445b65339081a47994929c72aaf0a1548d40d034d514b25de",
+);

package/src/certificate/DeviceCertification.ts

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Construction, Crypto, ImplementationError, InternalError, PrivateKey } from "#general";
+import { SecureSession } from "#session/SecureSession.js";
+import { ProductDescription } from "#types";
+import { AttestationCertificateManager } from "./AttestationCertificateManager.js";
+import { CertificationDeclarationManager } from "./CertificationDeclarationManager.js";
+
+/**
+ * Device certification used by the OperationalCredentials cluster.
+ */
+export class DeviceCertification {
+    #privateKey?: PrivateKey;
+    #certificate?: Uint8Array;
+    #intermediateCertificate?: Uint8Array;
+    #declaration?: Uint8Array;
+    readonly #construction: Construction<DeviceCertification>;
+
+    get construction() {
+        return this.#construction;
+    }
+
+    get certificate() {
+        return this.#assertInitialized().certificate;
+    }
+
+    get intermediateCertificate() {
+        return this.#assertInitialized().intermediateCertificate;
+    }
+
+    get declaration() {
+        return this.#assertInitialized().declaration;
+    }
+
+    constructor(config?: DeviceCertification.Definition, product?: ProductDescription) {
+        // Certification Provider function is used to request the certificates delayed
+        if (typeof config === "function") {
+            const configProvider = config;
+            this.#construction = Construction(this, async () => {
+                this.#initializeFromConfig(await configProvider());
+            });
+            return;
+        }
+
+        // We need a dummy construction to avoid errors
+        this.#construction = Construction(this, () => {});
+
+        // With a directly provided config or without we con initialize directly
+        if (config === undefined) {
+            if (product === undefined) {
+                throw new ImplementationError(`Cannot generate device certification without product information`);
+            }
+
+            const paa = new AttestationCertificateManager(product.vendorId);
+            const { keyPair: dacKeyPair, dac } = paa.getDACert(product.productId);
+
+            config = {
+                privateKey: PrivateKey(dacKeyPair.privateKey),
+                certificate: dac,
+                intermediateCertificate: paa.getPAICert(),
+                declaration: CertificationDeclarationManager.generate(product.vendorId, product.productId),
+            };
+        }
+        this.#initializeFromConfig(config);
+    }
+
+    #initializeFromConfig(config: DeviceCertification.Configuration) {
+        this.#privateKey = config.privateKey instanceof Uint8Array ? PrivateKey(config.privateKey) : config.privateKey;
+        this.#certificate = config.certificate;
+        this.#intermediateCertificate = config.intermediateCertificate;
+        this.#declaration = config.declaration;
+    }
+
+    sign(session: SecureSession, data: Uint8Array) {
+        return Crypto.sign(this.#assertInitialized().privateKey, [data, session.attestationChallengeKey]);
+    }
+
+    /**
+     * Makes sure that the device certification is initialized and construction is completed and returns "Non-undefined"
+     * values
+     */
+    #assertInitialized() {
+        this.#construction.assert();
+        if (
+            this.#certificate === undefined ||
+            this.#intermediateCertificate === undefined ||
+            this.#declaration === undefined ||
+            this.#privateKey === undefined
+        ) {
+            throw new InternalError(
+                `Device certification not initialized while trying to access it. This should never happen.`,
+            );
+        }
+        return {
+            certificate: this.#certificate,
+            intermediateCertificate: this.#intermediateCertificate,
+            declaration: this.#declaration,
+            privateKey: this.#privateKey,
+        };
+    }
+}
+
+export namespace DeviceCertification {
+    export interface Configuration {
+        privateKey: PrivateKey | Uint8Array;
+        certificate: Uint8Array;
+        intermediateCertificate: Uint8Array;
+        declaration: Uint8Array;
+    }
+
+    export type Definition = Configuration | (() => Promise<Configuration>);
+}

package/src/certificate/RootCertificateManager.ts

@@ -0,0 +1,179 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+    BinaryKeyPair,
+    Bytes,
+    Construction,
+    Crypto,
+    Environment,
+    Environmental,
+    Logger,
+    PrivateKey,
+    StorageContext,
+    StorageManager,
+    Time,
+    asyncNew,
+    toHex,
+} from "#general";
+import { CaseAuthenticatedTag, FabricId, NodeId } from "#types";
+import {
+    CertificateManager,
+    OperationalCertificate,
+    RootCertificate,
+    TlvOperationalCertificate,
+    TlvRootCertificate,
+    Unsigned,
+    jsToMatterDate,
+} from "./CertificateManager.js";
+
+const logger = Logger.get("RootCertificateManager");
+
+export class RootCertificateManager {
+    private rootCertId = BigInt(0);
+    private rootKeyPair = Crypto.createKeyPair();
+    private rootKeyIdentifier = Crypto.hash(this.rootKeyPair.publicKey).slice(0, 20);
+    private rootCertBytes = this.generateRootCert();
+    private nextCertificateId = BigInt(1);
+    #construction: Construction<RootCertificateManager>;
+
+    get construction() {
+        return this.#construction;
+    }
+
+    static async create(options: StorageContext | RootCertificateManager.Data) {
+        return asyncNew(RootCertificateManager, options);
+    }
+
+    constructor(options: StorageContext | RootCertificateManager.Data) {
+        this.#construction = Construction(this, async () => {
+            // Use provided root certificate data or read from storage if we have them stored, else store the just generated data
+            const certValues = options instanceof StorageContext ? await options.values() : options;
+
+            if (
+                typeof certValues.rootCertId === "bigint" &&
+                (ArrayBuffer.isView(certValues.rootKeyPair) || typeof certValues.rootKeyPair === "object") &&
+                ArrayBuffer.isView(certValues.rootKeyIdentifier) &&
+                ArrayBuffer.isView(certValues.rootCertBytes) &&
+                (typeof certValues.nextCertificateId === "number" || typeof certValues.nextCertificateId === "bigint")
+            ) {
+                this.rootCertId = BigInt(certValues.rootCertId);
+                this.rootKeyPair = PrivateKey(certValues.rootKeyPair as BinaryKeyPair);
+                this.rootKeyIdentifier = certValues.rootKeyIdentifier;
+                this.rootCertBytes = certValues.rootCertBytes;
+                this.nextCertificateId = BigInt(certValues.nextCertificateId);
+                logger.debug(`Loaded root certificate with ID ${this.rootCertId} from storage`);
+                return;
+            }
+
+            logger.debug(`Created new root certificate with ID ${this.rootCertId}`);
+
+            if (options instanceof StorageContext) {
+                await options.set({
+                    rootCertId: this.rootCertId,
+                    rootKeyPair: this.rootKeyPair.keyPair,
+                    rootKeyIdentifier: this.rootKeyIdentifier,
+                    rootCertBytes: this.rootCertBytes,
+                    nextCertificateId: this.nextCertificateId,
+                });
+            }
+        });
+    }
+
+    [Environmental.create](env: Environment) {
+        const storage = env.get(StorageManager).createContext("certificates");
+        const instance = new RootCertificateManager(storage);
+        env.set(RootCertificateManager, instance);
+        return instance;
+    }
+
+    get rootCert() {
+        return this.rootCertBytes;
+    }
+
+    get data(): RootCertificateManager.Data {
+        return {
+            rootCertId: this.rootCertId,
+            rootKeyPair: this.rootKeyPair.keyPair,
+            rootKeyIdentifier: this.rootKeyIdentifier,
+            rootCertBytes: this.rootCertBytes,
+            nextCertificateId: this.nextCertificateId,
+        };
+    }
+
+    private generateRootCert() {
+        const now = Time.get().now();
+        const unsignedCertificate: Unsigned<RootCertificate> = {
+            serialNumber: Bytes.fromHex(toHex(this.rootCertId)),
+            signatureAlgorithm: 1 /* EcdsaWithSHA256 */,
+            publicKeyAlgorithm: 1 /* EC */,
+            ellipticCurveIdentifier: 1 /* P256v1 */,
+            issuer: { rcacId: this.rootCertId },
+            notBefore: jsToMatterDate(now, -1),
+            notAfter: jsToMatterDate(now, 10),
+            subject: { rcacId: this.rootCertId },
+            ellipticCurvePublicKey: this.rootKeyPair.publicKey,
+            extensions: {
+                basicConstraints: { isCa: true },
+                keyUsage: {
+                    keyCertSign: true,
+                    cRLSign: true,
+                },
+                subjectKeyIdentifier: this.rootKeyIdentifier,
+                authorityKeyIdentifier: this.rootKeyIdentifier,
+            },
+        };
+        const signature = Crypto.sign(this.rootKeyPair, CertificateManager.rootCertToAsn1(unsignedCertificate));
+        return TlvRootCertificate.encode({ ...unsignedCertificate, signature });
+    }
+
+    generateNoc(
+        publicKey: Uint8Array,
+        fabricId: FabricId,
+        nodeId: NodeId,
+        caseAuthenticatedTags?: CaseAuthenticatedTag[],
+    ) {
+        const now = Time.get().now();
+        const certId = this.nextCertificateId++;
+        const unsignedCertificate: Unsigned<OperationalCertificate> = {
+            serialNumber: Bytes.fromHex(toHex(certId)),
+            signatureAlgorithm: 1 /* EcdsaWithSHA256 */,
+            publicKeyAlgorithm: 1 /* EC */,
+            ellipticCurveIdentifier: 1 /* P256v1 */,
+            issuer: { rcacId: this.rootCertId },
+            notBefore: jsToMatterDate(now, -1),
+            notAfter: jsToMatterDate(now, 10),
+            subject: { fabricId, nodeId, caseAuthenticatedTags },
+            ellipticCurvePublicKey: publicKey,
+            extensions: {
+                basicConstraints: { isCa: false },
+                keyUsage: {
+                    digitalSignature: true,
+                },
+                extendedKeyUsage: [2, 1],
+                subjectKeyIdentifier: Crypto.hash(publicKey).slice(0, 20),
+                authorityKeyIdentifier: this.rootKeyIdentifier,
+            },
+        };
+
+        const signature = Crypto.sign(
+            this.rootKeyPair,
+            CertificateManager.nodeOperationalCertToAsn1(unsignedCertificate),
+        );
+
+        return TlvOperationalCertificate.encode({ ...unsignedCertificate, signature });
+    }
+}
+
+export namespace RootCertificateManager {
+    export type Data = {
+        rootCertId: bigint;
+        rootKeyPair: BinaryKeyPair;
+        rootKeyIdentifier: Uint8Array;
+        rootCertBytes: Uint8Array;
+        nextCertificateId: bigint;
+    };
+}

package/src/certificate/index.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export * from "./AttestationCertificateManager.js";
+export * from "./CertificateManager.js";
+export * from "./CertificationDeclarationManager.js";
+export * from "./ChipPAAuthorities.js";
+export * from "./DeviceCertification.js";
+export * from "./RootCertificateManager.js";

package/src/cluster/client/AttributeClient.ts

@@ -0,0 +1,196 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ImplementationError } from "#general";
+import { FabricIndex as FabricIndexElement } from "#model";
+import { Attribute, AttributeError, AttributeId, ClusterId, EndpointNumber, FabricIndex, TlvSchema } from "#types";
+import { InteractionClient } from "../../interaction/InteractionClient.js";
+import { NoAssociatedFabricError } from "../../session/SecureSession.js";
+
+/**
+ * Factory function to create an AttributeClient for a given attribute.
+ */
+export function createAttributeClient<T>(
+    attribute: Attribute<T, any>,
+    name: string,
+    endpointId: EndpointNumber,
+    clusterId: ClusterId,
+    interactionClient: InteractionClient,
+    present = false,
+): AttributeClient<T> {
+    if (attribute.unknown) {
+        return new UnknownSupportedAttributeClient(attribute, name, endpointId, clusterId, interactionClient);
+    }
+    if (present) {
+        return new SupportedAttributeClient(attribute, name, endpointId, clusterId, interactionClient);
+    }
+    return new AttributeClient(attribute, name, endpointId, clusterId, interactionClient);
+}
+
+/**
+ * General class for AttributeClients
+ */
+export class AttributeClient<T = any> {
+    readonly #isWritable: boolean;
+    readonly #isFabricScoped: boolean;
+    readonly #updatedBySubscriptions: boolean;
+    protected readonly schema: TlvSchema<any>;
+    readonly #listeners = new Array<(newValue: T) => void>();
+    readonly id: AttributeId;
+    readonly #interactionClient: InteractionClient;
+
+    constructor(
+        readonly attribute: Attribute<T, any>,
+        readonly name: string,
+        readonly endpointId: EndpointNumber,
+        readonly clusterId: ClusterId,
+        interactionClient: InteractionClient,
+    ) {
+        const { schema, writable, fabricScoped, id, omitChanges } = attribute;
+        this.schema = schema;
+        this.#isWritable = writable;
+        this.#isFabricScoped = fabricScoped;
+        this.#updatedBySubscriptions = !omitChanges;
+        this.id = id;
+        this.#interactionClient = interactionClient;
+    }
+
+    /**
+     * Set the value of the attribute. When dataVersion parameter is provided the value is only set when the
+     * cluster dataVersion of the server matches. If it does not match it is rejected with an Error.
+     */
+    async set(value: T, dataVersion?: number) {
+        if (!this.#isWritable) throw new AttributeError(`Attribute ${this.name} is not writable`);
+
+        value = this.schema.injectField(
+            value,
+            <number>FabricIndexElement.id,
+            FabricIndex.OMIT_FABRIC,
+            existingFieldIndex => existingFieldIndex === undefined,
+        );
+
+        this.schema.validate(value);
+
+        if (this.#isFabricScoped) {
+            // Remove fabric index from structures if the OMIT_FABRIC instance was used (Should be used for all outgoing writes)
+            value = this.schema.removeField(
+                value,
+                <number>FabricIndexElement.id,
+                existingFieldIndex => existingFieldIndex === FabricIndex.OMIT_FABRIC,
+            );
+
+            try {
+                const sessionFabric = this.#interactionClient.session.associatedFabric;
+                // also remove fabric index if it is the same as the session fabric
+                value = this.schema.removeField(
+                    value,
+                    <number>FabricIndexElement.id,
+                    existingFieldIndex => existingFieldIndex.index === sessionFabric.fabricIndex,
+                );
+            } catch (e) {
+                NoAssociatedFabricError.accept(e);
+            }
+        }
+
+        return await this.#interactionClient.setAttribute<T>({
+            attributeData: {
+                endpointId: this.endpointId,
+                clusterId: this.clusterId,
+                attribute: this.attribute,
+                value,
+                dataVersion,
+            },
+        });
+    }
+
+    /** Get the value of the attribute. Fabric scoped reads are always done with the remote. */
+    async get(alwaysRequestFromRemote?: boolean, isFabricFiltered = true) {
+        if (alwaysRequestFromRemote === undefined) {
+            alwaysRequestFromRemote = this.#isFabricScoped || !this.#updatedBySubscriptions;
+        } else if (!alwaysRequestFromRemote && this.#isFabricScoped) {
+            alwaysRequestFromRemote = true;
+        }
+        return await this.#interactionClient.getAttribute({
+            endpointId: this.endpointId,
+            clusterId: this.clusterId,
+            attribute: this.attribute,
+            isFabricFiltered,
+            alwaysRequestFromRemote,
+        });
+    }
+
+    /**
+     * Get the value with version of the attribute. Fabric scoped reads are always done with the remote.
+     * */
+    async getWithVersion(alwaysRequestFromRemote?: boolean, isFabricFiltered = true) {
+        if (alwaysRequestFromRemote === undefined) {
+            alwaysRequestFromRemote = this.#isFabricScoped;
+        } else if (!alwaysRequestFromRemote && this.#isFabricScoped) {
+            alwaysRequestFromRemote = true;
+        }
+        return await this.#interactionClient.getAttributeWithVersion({
+            endpointId: this.endpointId,
+            clusterId: this.clusterId,
+            attribute: this.attribute,
+            isFabricFiltered,
+            alwaysRequestFromRemote,
+        });
+    }
+
+    /** Subscribe to the attribute. */
+    async subscribe(
+        minIntervalFloorSeconds: number,
+        maxIntervalCeilingSeconds: number,
+        knownDataVersion?: number,
+        isFabricFiltered = true,
+    ) {
+        if (!this.#updatedBySubscriptions) {
+            throw new ImplementationError(`Attribute ${this.name} is not updated by subscriptions.`);
+        }
+        return this.#interactionClient.subscribeAttribute({
+            endpointId: this.endpointId,
+            clusterId: this.clusterId,
+            attribute: this.attribute,
+            minIntervalFloorSeconds,
+            maxIntervalCeilingSeconds,
+            isFabricFiltered,
+            knownDataVersion,
+            listener: this.update.bind(this),
+        });
+    }
+
+    /**
+     * Update the value of the attribute. Just internally used!
+     * @private
+     */
+    update(value: T) {
+        this.#listeners.forEach(listener => listener(value));
+    }
+
+    /** Add a listener to the attribute. */
+    addListener(listener: (newValue: T) => void) {
+        this.#listeners.push(listener);
+    }
+
+    /** Remove a listener from the attribute. */
+    removeListener(listener: (newValue: T) => void) {
+        const entryIndex = this.#listeners.indexOf(listener);
+        if (entryIndex !== -1) {
+            this.#listeners.splice(entryIndex, 1);
+        }
+    }
+}
+
+/**
+ * Special AttributeClient class to allow identifying attributes that are supported because reported by the Devices.
+ */
+export class SupportedAttributeClient<T> extends AttributeClient<T> {}
+
+/**
+ * Special AttributeClient class to allow identifying attributes that are supported because reported by the Devices,
+ * but the contained attribute is unknown.
+ */
+export class UnknownSupportedAttributeClient extends SupportedAttributeClient<any> {}